Example #1
0
        public static void CreateXML()
        {
            XmlDocument doc = new XmlDocument();
            XmlDeclaration xmlDeclar = doc.CreateXmlDeclaration(version:"1.0",standalone:"yes",encoding:"");
            doc.PrependChild(xmlDeclar);
            XmlElement element = doc.CreateElement(name: "Users");
            doc.AppendChild(element);
            XmlElement user = doc.CreateElement(name: "User");

            user.SetAttribute(name: "ID", value: "1");
            element.AppendChild(newChild: user);
            XmlElement userage = doc.CreateElement(name: "Age");
            element.FirstChild.AppendChild(userage);
            XmlElement userName = doc.CreateElement(name: "Name");
            userName.InnerText = "jambor";
            element.FirstChild.PrependChild(newChild: userName);
            XmlElement userPhone= doc.CreateElement(name: "Phone");
            XmlNode xmlNode = doc.DocumentElement;
            element.FirstChild.InsertBefore(newChild: userPhone, refChild: xmlNode.FirstChild.FirstChild);
            //XmlElement userAdd = doc.CreateElement(name: "Address");

            //xmlNode.InsertAfter(newChild: userPhone, refChild: xmlNode.SelectNodes(xpath:"Name")[0]);

            doc.Save(filename: @"d:\user.xml");
        }
		public static XmlDocument XslExportTransform (XmlDocument doc)
		{
			XmlReader reader = Registry.GladeExportXsl.Transform (doc, null, (XmlResolver)null);
			doc = new XmlDocument ();
			doc.PreserveWhitespace = true;
			doc.Load (reader);

			XmlDocumentType doctype = doc.CreateDocumentType ("glade-interface", null, Glade20SystemId, null);
			doc.PrependChild (doctype);

			return doc;
		}
Example #3
0
		public static XmlDocument XslExportTransform (XmlDocument doc)
		{
			StringWriter sw = new StringWriter ();
			XmlWriter xw = XmlWriter.Create (sw);
			Registry.GladeExportXsl.Transform (doc, xw);
			XmlReader reader = XmlReader.Create (sw.ToString ());
			doc = new XmlDocument ();
			doc.PreserveWhitespace = true;
			doc.Load (reader);

			XmlDocumentType doctype = doc.CreateDocumentType ("glade-interface", null, Glade20SystemId, null);
			doc.PrependChild (doctype);

			return doc;
		}
        public XmlDocument Serialize(DataTable table)
        {
            if (table == null)
            {
                throw new ArgumentNullException("table");
            }

            if (table.Columns.Count == 0)
            {
                throw new ArgumentOutOfRangeException("table", "DataTable specified contains no columns");
            }

            var doc = new XmlDocument();
            var xmlDeclaration = doc.CreateXmlDeclaration("1.0", "utf-8", null);

            doc.PrependChild(xmlDeclaration);

            var root = doc.CreateElement(ColumnCollectionElementName);
            doc.AppendChild(root);

            foreach (var dataCol in table.Columns)
            {
                var col = (DataColumn)dataCol;
                var el = doc.CreateElement(ColumnElementName);

                el.SetAttribute(AttributeNames.Name, col.ColumnName);
                el.SetAttribute(AttributeNames.Type, col.DataType.FullName);
                el.SetAttribute(AttributeNames.Nullable, col.AllowDBNull.ToString(CultureInfo.InvariantCulture));

                // MaxLength only relevant for strings
                if (col.DataType == typeof(string))
                {
                    el.SetAttribute(AttributeNames.Length, col.MaxLength.ToString(CultureInfo.InvariantCulture));
                }

                root.AppendChild(el);
            }

            return doc;
        }
Example #5
0
        /// <summary>
        /// return a KML document
        /// </summary>
        /// <returns></returns>
        private XmlDocument getKmlDocument()
        {
            // Create the document.
            XmlDocument doc = new XmlDocument();

            // Insert the xml processing instruction and the root node
            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "ISO-8859-1", null);
            doc.PrependChild(dec);

            XmlNode commentnode = doc.CreateComment("Sentience 3D Perception System KML interface");
            doc.AppendChild(commentnode);

            XmlElement nodeKml = doc.CreateElement("kml");
            nodeKml.SetAttribute("xmlns", "http://earth.google.com/kml/2.1");
            doc.AppendChild(nodeKml);

            XmlElement elem = getXml(doc);
            nodeKml.AppendChild(elem);

            return (doc);
        }
        /// <summary>
        /// Return a string containing the metadata XML based on the settings added to this instance.
        /// The resulting XML will be signed, if the AsymmetricAlgoritm property has been set.
        /// </summary>
        public string ToXml(Encoding enc)
        {
            XmlDocument doc = new XmlDocument();
            doc.PreserveWhitespace = true;

            doc.LoadXml( Serialization.SerializeToXmlString(_entity));

            // Add the correct encoding to the head element.
            if (doc.FirstChild is XmlDeclaration)
                ((XmlDeclaration) doc.FirstChild).Encoding = enc.WebName;
            else
                doc.PrependChild(doc.CreateXmlDeclaration("1.0", enc.WebName, null));

            if (Sign)
                SignDocument(doc);

            return doc.OuterXml;
        }
        // ---------------------------------------------------------------------------------------------------
        // Serialize
        //
        // Param assemblyPath: The full path + name of the assembly to be serialized
        // ---------------------------------------------------------------------------------------------------
        public static string Serialize(string assemblyPath)
        {
            Assembly assembly;

            // load the assembly
            try {
                //assembly = Assembly.ReflectionOnlyLoadFrom(assemblyPath);
                assembly = Assembly.LoadFrom(assemblyPath);
            }
            catch (Exception exc) {
                throw exc;
            }

            // extract the assembly name which is used as the XML parent node
            string sAssemblyName = assembly.FullName.Split(',')[0];

            // create a new XML Document
            XmlDocument xmlDoc = new XmlDocument();

            XmlNamespaceManager ns = new XmlNamespaceManager(xmlDoc.NameTable);
            ns.AddNamespace("msdata", "urn:schemas-microsoft-com:xml-msdata");
            ns.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema");

            XmlDeclaration xmlDec = xmlDoc.CreateXmlDeclaration("1.0", "utf-8", String.Empty);
            xmlDoc.PrependChild(xmlDec);

            // create parent node
            System.Xml.XmlElement elemRoot = xmlDoc.CreateElement(sAssemblyName);
            xmlDoc.AppendChild(elemRoot);

            // create longer static XML node using a string
            string sSchemaNode = "<xs:schema id=\"" + sAssemblyName + "\" xmlns=\"\" ";
                sSchemaNode += "xmlns:xs=\"http://www.w3.org/2001/XMLSchema\" ";
                sSchemaNode += "xmlns:msdata=\"urn:schemas-microsoft-com:xml-msdata\">";
                sSchemaNode += "<xs:element name=\"" + sAssemblyName + "\" msdata:IsDataSet=\"true\" msdata:Locale=\"en-US\">";
                sSchemaNode += "<xs:complexType><xs:choice minOccurs=\"0\" maxOccurs=\"unbounded\">";
                sSchemaNode += "</xs:choice></xs:complexType></xs:element></xs:schema>";

            XmlDocumentFragment xmlDocFragment = xmlDoc.CreateDocumentFragment();
            xmlDocFragment.InnerXml = sSchemaNode;
            elemRoot.AppendChild(xmlDocFragment);

            // select the "choice" node to include member types
            XmlNode choiceNode = xmlDoc.SelectSingleNode("/descendant::xs:choice[1]", ns);

            // list of all assembly types and relations
            Type[] assemblyTypes = assembly.GetTypes();

            // remove duplicates
            assemblyTypes = assemblyTypes.GroupBy(x => x.Name).Select(y => y.First()).ToArray();

            List<System.Xml.XmlElement> listAnnotations = new List<System.Xml.XmlElement>();
            
            // loop through all classes in assembly
            foreach (Type type in assemblyTypes)
            {
                List<string> listMemberNames = new List<string>();

                if (ContainsSpecialCharacters(type.Name))
                    continue;

                // create XML entries for the classes
                System.Xml.XmlElement typeElement = 
                    xmlDoc.CreateElement("xs", "element", "http://www.w3.org/2001/XMLSchema");
                typeElement.SetAttribute("name", type.Name);
                choiceNode.AppendChild(typeElement);

                System.Xml.XmlElement complexTypeElement = 
                    xmlDoc.CreateElement("xs", "complexType", "http://www.w3.org/2001/XMLSchema");
                typeElement.AppendChild(complexTypeElement);

                System.Xml.XmlElement sequenceElement = 
                    xmlDoc.CreateElement("xs", "sequence", "http://www.w3.org/2001/XMLSchema");
                complexTypeElement.AppendChild(sequenceElement);

                // loop through all properties and create XML nodes for return types
                foreach (PropertyInfo property in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
                {
                    if (ContainsSpecialCharacters(property.Name) |
                        listMemberNames.Contains(property.Name) |
                        property.GetMethod == null)
                        continue;

                    if (assemblyTypes.Contains(property.GetMethod.ReturnType))
                    {
                        System.Xml.XmlElement newAnnotationElement = 
                            CreateAnnotationElement(xmlDoc, type.Name, property.GetMethod.ReturnType.Name);
                        if (newAnnotationElement != null)
                            listAnnotations.Add(newAnnotationElement);
                    }

                    // add the member information as XML element
                    sequenceElement.AppendChild(CreateMemberElement(xmlDoc, property.Name, property.GetMethod.ReturnType));
                    listMemberNames.Add(property.Name);
                }

                // loop through all methods and create XML nodes for return types
                foreach (MethodInfo method in type.GetMethods(
                    BindingFlags.Public | BindingFlags.Instance)
                    .Where(y => y.IsSpecialName == false))
                {
                    if (ContainsSpecialCharacters(method.Name) | listMemberNames.Contains(method.Name))
                        continue;

                    if (assemblyTypes.Contains(method.ReturnType))
                        {
                            System.Xml.XmlElement newAnnotationElement = 
                                CreateAnnotationElement(xmlDoc, type.Name, method.ReturnType.Name);
                            if(newAnnotationElement != null)
                                listAnnotations.Add(newAnnotationElement);
                        }

                    // add the member information as XML element
                    sequenceElement.AppendChild(CreateMemberElement(xmlDoc, method.Name, method.ReturnType));
                    listMemberNames.Add(method.Name);
                }

                // write all relations as annotation tags
                foreach (System.Xml.XmlElement element in listAnnotations)
                {
                    xmlDoc.SelectSingleNode(sAssemblyName).FirstChild.AppendChild(element);
                }

                // add an internal id to all classes for relations
                sequenceElement.AppendChild(CreateMemberElement(xmlDoc, "TXID_" + type.Name, typeof(Int32)));
            }

            return xmlDoc.InnerXml;
        }
 private string ParseOptionsControls()
 {
     XmlDocument xDoc = new XmlDocument();
     XmlElement options = xDoc.CreateElement("options");
     xDoc.AppendChild(options);
     XmlElement settings = xDoc.CreateElement("settings");
     options.AppendChild(settings);
     foreach (TreeNode tn in topLevel.Nodes)
     {
         if (tn.Tag != null && typeof(TableLayoutPanel).IsInstanceOfType(tn.Tag))
         {
             XmlElement panel = xDoc.CreateElement("panel");
             panel.SetAttribute("name", tn.Text);
             settings.AppendChild(panel);
             XmlElement controls = xDoc.CreateElement("controls");
             panel.AppendChild(controls);
             foreach (Control c in ((TableLayoutPanel)tn.Tag).Controls)
             {
                 if (!typeof(Label).IsInstanceOfType(c))
                 {
                     int firstPos = c.ToString().IndexOf(',');
                     int lastPos = c.ToString().Substring(0, firstPos).LastIndexOf('.');
                     string ctrlType = c.ToString().Substring(0, firstPos).Substring(lastPos + 1).Trim();
                     string ctrlValue = string.Empty;
                     if (ctrlType.ToLower().Equals("textbox"))
                     {
                         ctrlValue = "Text: " + c.Text;
                     }
                     else
                     {
                         ctrlValue = c.ToString().Substring(firstPos + 1).Trim();
                     }
                     XmlElement ctrl = xDoc.CreateElement("control");
                     ctrl.SetAttribute("name", c.Name);
                     ctrl.SetAttribute("type", ctrlType);
                     ctrl.InnerText = ctrlValue;
                     controls.AppendChild(ctrl);
                 }
             }
         }
     }
     XmlDeclaration declare = xDoc.CreateXmlDeclaration("1.0", "UTF-8", "yes");
     xDoc.PrependChild(declare);
     _values = xDoc.OuterXml;
     return _values;
 }
Example #9
0
        static public void XmlFromDataTable(System.Data.DataTable dt, 
                                                                      string file,
                                                                      string senderID)
        {
            XmlDocument doc = new XmlDocument();
            doc.PrependChild(doc.CreateXmlDeclaration("1.0", "utf-8", null));
            XmlElement element = doc.CreateElement("Data");
            element.SetAttribute("reportDate", DateTime.Now.ToString("MM/dd/yy HH:mm"));
            element.SetAttribute("senderID", senderID);
            doc.AppendChild(element);

            XmlElement devices = doc.CreateElement("Devices");
            element.AppendChild(devices);

            foreach (DataRow r in dt.Rows)
            {
                XmlElement device = doc.CreateElement("Device");

                // add each row's cell data...
                foreach (DataColumn c in dt.Columns)
                {
                   insertElement(doc, device, c.ColumnName.Trim(), r[c.ColumnName].ToString().Trim());
                 }
                devices.AppendChild(device);
            }
            doc.Save(file);
        }
Example #10
0
        /// <summary>
        /// Inspect an XML document.
        /// </summary>
        /// <param name="doc">The XML document to inspect.</param>
        private void InspectDocument(XmlDocument doc)
        {
            // inspect the declaration
            if (XmlNodeType.XmlDeclaration == doc.FirstChild.NodeType)
            {
                XmlDeclaration declaration = (XmlDeclaration)doc.FirstChild;

                if (!String.Equals("utf-8", declaration.Encoding, StringComparison.OrdinalIgnoreCase))
                {
                    if (this.OnError(InspectorTestType.DeclarationEncodingWrong, declaration, "The XML declaration encoding is not properly set to 'utf-8'."))
                    {
                        declaration.Encoding = "utf-8";
                    }
                }
            }
            else // missing declaration
            {
                if (this.OnError(InspectorTestType.DeclarationMissing, null, "This file is missing an XML declaration on the first line."))
                {
                    doc.PrependChild(doc.CreateXmlDeclaration("1.0", "utf-8", null));
                }
            }

            // start inspecting the nodes at the document element
            this.InspectNode(doc.DocumentElement, 0);
        }
Example #11
0
        /// <summary>
        /// return an Xml document containing metagridBuffer
        /// </summary>
        /// <returns></returns>
        private XmlDocument getXmlDocument()
        {
            // Create the document.
            XmlDocument doc = new XmlDocument();

            // Insert the xml processing instruction and the root node
            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "ISO-8859-1", null);
            doc.PrependChild(dec);

            XmlElement nodeGeom = doc.CreateElement("OccupancyGrids");
            doc.AppendChild(nodeGeom);
			
            nodeGeom.AppendChild(
			    getXml(doc, nodeGeom));

            return (doc);
        }
Example #12
0
        /// <summary>
        /// return an Xml document containing the status of the given list of devices
        /// </summary>
        /// <returns></returns>
        protected static XmlDocument GetDeviceStatus(
            ArrayList devs, 
            string status_type)
        {
            XmlDocument doc = new XmlDocument();

            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", XML_ENCODING, null);
            doc.PrependChild(dec);

            XmlElement statusreply = doc.CreateElement(status_type);
            doc.AppendChild(statusreply);

            for (int i = 0; i < devs.Count; i += 2)
            {
                string Id = (string)devs[i];
                List<string> required_properties = (List<string>)devs[i + 1];
                XmlElement status = GetDeviceStatus(Id, doc, statusreply, required_properties);
                if (status != null) statusreply.AppendChild(status);
            }

            //doc.Save("DeviceStatus.xml");

            return (doc);
        }
        private static XmlDocument ConstructXMLRequest(BaseRequest request, RequestTypeEnum requestType)
        {
            var xmlDoc = new XmlDocument();
            try
            {

                xmlDoc.LoadXml("<Request xmlns=\"urn:sbx:apis:SbxBaseComponents\"><RequesterCredentials><ApiUserToken>"
                            + request.ApiUserToken + "</ApiUserToken><SbxUserToken>" + request.SbxUserToken +
                            "</SbxUserToken></RequesterCredentials></Request>");
                xmlDoc.PrependChild(xmlDoc.CreateXmlDeclaration("1.0", "UTF-8", null));

                var xmlRequestNode = xmlDoc.GetElementsByTagName("Request").Item(0);

                var xmlGetRequestTypeCallNode = xmlDoc.CreateElement(requestType.ToString());
                xmlGetRequestTypeCallNode.SetAttribute("xmlns", "urn:sbx:apis:SbxBaseComponents");
                xmlRequestNode.AppendChild(xmlGetRequestTypeCallNode);

                ConstructXMLCallNode(xmlDoc, request, requestType, xmlGetRequestTypeCallNode);
            }
            catch
            {
                throw new Exception("Error in Service.");
            }

            return xmlDoc;
        }
Example #14
0
        /// <summary>
        /// return an Xml document containing camera calibration parameters
        /// </summary>
        /// <param name="device_name"></param>
        /// <param name="part_number"></param>
        /// <param name="serial_number"></param>
        /// <param name="focal_length_pixels"></param>
        /// <param name="focal_length_mm"></param>
        /// <param name="baseline_mm"></param>
        /// <param name="fov_degrees"></param>
        /// <param name="image_width"></param>
        /// <param name="image_height"></param>
        /// <param name="lens_distortion_curve"></param>
        /// <param name="centre_of_distortion_x"></param>
        /// <param name="centre_of_distortion_y"></param>
        /// <param name="minimum_rms_error"></param>
        /// <param name="rotation"></param>
        /// <param name="scale"></param>
        /// <param name="offset_x"></param>
        /// <param name="offset_y"></param>
        /// <returns></returns>
        protected static XmlDocument getXmlDocument(
            string device_name,
            string part_number,
            string serial_number,
            float focal_length_pixels,
            float focal_length_mm,
            float baseline_mm,
            float fov_degrees,
            int image_width, int image_height,
            polynomial[] lens_distortion_curve,
            float[] centre_of_distortion_x, float[] centre_of_distortion_y,
            float[] minimum_rms_error,
            float rotation, float scale,
            float offset_x, float offset_y,
            bool disable_rectification,
            bool disable_radial_correction,
            bool flip_left_image,
            bool flip_right_image)
        {
            //usage.Update("Get xml document, BaseVisionStereo, GetXmlDocument");
            
            // Create the document.
            XmlDocument doc = new XmlDocument();

            // Insert the xml processing instruction and the root node
            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "ISO-8859-1", null);
            doc.PrependChild(dec);

            XmlNode commentnode = doc.CreateComment("Sentience 3D Perception System");
            doc.AppendChild(commentnode);

            XmlElement nodeCalibration = doc.CreateElement("Sentience");
            doc.AppendChild(nodeCalibration);

            XmlElement elem = getXml(doc, nodeCalibration,
                device_name,
                part_number,
                serial_number,
                focal_length_pixels,
                focal_length_mm,
                baseline_mm,
                fov_degrees,
                image_width, image_height,
                lens_distortion_curve,
                centre_of_distortion_x, centre_of_distortion_y,
                minimum_rms_error,
                rotation, scale,
                offset_x, offset_y,
                disable_rectification,
                disable_radial_correction,
                flip_left_image,
                flip_right_image);
            doc.DocumentElement.AppendChild(elem);

            return (doc);
        }
Example #15
0
        /// <summary>
        /// <c>CreateXMLFileForStoringUserOptions</c>
        /// creates xml file to store UserOptions either to select AutoDelete Emails after  uploading or not
        /// </summary>
        /// <param name="xLogOptions"></param>
        /// <returns></returns>
        public static bool CreateXMLFileForStoringUserOptions(XMLLogOptions xLogOptions)
        {
            try
            {
                //, Folder name, site url, authentication mode and credentials.
                XmlDocument xmlDoc = new XmlDocument();
                XmlElement elemRoot = null, elem = null;
                XmlNode root = null;
                bool isNewXMlFile = true;

                UserLogManagerUtility.CheckItopiaDirectoryExits();

                //Check file is existed or not
                if (System.IO.File.Exists(UserLogManagerUtility.XMLOptionsFilePath) == true)
                {
                    //Save the details in Xml file
                    xmlDoc.Load(UserLogManagerUtility.XMLOptionsFilePath);
                    xmlDoc.RemoveAll();
                }

                XmlDeclaration xmlDec = xmlDoc.CreateXmlDeclaration("1.0", "utf-8", String.Empty);
                xmlDoc.PrependChild(xmlDec);
                XmlElement docRoot = xmlDoc.CreateElement("UserOptionsLog");
                xmlDoc.AppendChild(docRoot);

                //Create root node
                elemRoot = xmlDoc.CreateElement("Options");
                docRoot.AppendChild(elemRoot);

                elem = xmlDoc.CreateElement("AutoDeleteEmails");
                elem.InnerText = Convert.ToString(xLogOptions.AutoDeleteEmails);
                elemRoot.AppendChild(elem);

                if (isNewXMlFile == false)
                {
                    //XML file already existed add the node to xml file
                    root.InsertBefore(elemRoot, root.FirstChild);
                }
                //Save xml file
                xmlDoc.Save(UserLogManagerUtility.XMLOptionsFilePath);

                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return false;
        }
Example #16
0
        /// <summary>
        /// <c>CreateXMLFileForStoringUserCredentials</c>
        /// Method to save user credentionals
        /// </summary>
        /// <param name="xLogproperties"></param>
        /// <returns></returns>
        public static bool CreateXMLFileForStoringUserCredentials(XMLLogProperties xLogproperties)
        {
            try
            {
                //, Folder name, site url, authentication mode and credentials.
                xLogproperties.UserName = EncodingAndDecoding.Base64Encode(xLogproperties.UserName);
                xLogproperties.Password = EncodingAndDecoding.Base64Encode(xLogproperties.Password);
                XmlDocument xmlDoc = new XmlDocument();
                XmlElement elemRoot = null, elem = null;
                XmlNode root = null;
                bool isNewXMlFile = true;

                UserLogManagerUtility.CheckItopiaDirectoryExits();

                //Check file is existed or not
                if (System.IO.File.Exists(UserLogManagerUtility.XMLFilePath) == true)
                {
                    //Save the details in Xml file
                    xmlDoc.Load(UserLogManagerUtility.XMLFilePath);
                    //Get the root Elemet
                    root = xmlDoc.DocumentElement;
                    elemRoot = xmlDoc.CreateElement("Folder");
                    isNewXMlFile = false;
                }
                else
                {
                    XmlDeclaration xmlDec = xmlDoc.CreateXmlDeclaration("1.0", "utf-8", String.Empty);
                    xmlDoc.PrependChild(xmlDec);
                    XmlElement docRoot = xmlDoc.CreateElement("UserCredentialsLog");
                    xmlDoc.AppendChild(docRoot);

                    //Create root node
                    elemRoot = xmlDoc.CreateElement("Folder");
                    docRoot.AppendChild(elemRoot);
                }
                elem = xmlDoc.CreateElement("UserName");
                elem.InnerText = xLogproperties.UserName;
                elemRoot.AppendChild(elem);

                elem = xmlDoc.CreateElement("Password");
                elem.InnerText = xLogproperties.Password;
                elemRoot.AppendChild(elem);
                //string strFolderName,string strSiteURL,string strAuthenticationType)
                elem = xmlDoc.CreateElement("DisplayName");
                elem.InnerText = xLogproperties.DisplayFolderName;
                elemRoot.AppendChild(elem);

                elem = xmlDoc.CreateElement("DocLibName");
                elem.InnerText = xLogproperties.DocumentLibraryName;
                elemRoot.AppendChild(elem);

                elem = xmlDoc.CreateElement("URL");
                elem.InnerText = xLogproperties.SiteURL;
                elemRoot.AppendChild(elem);
                elem = xmlDoc.CreateElement("AuthenticationType");
                if (xLogproperties.FolderAuthenticationType == AuthenticationType.Domain)
                {
                    elem.InnerText = "Domain Credentials";
                }
                else
                {
                    elem.InnerText = "Manually Specified";
                }
                elemRoot.AppendChild(elem);

                elem = xmlDoc.CreateElement("Status");
                if (xLogproperties.UsersStatus == UserStatus.Active)
                {
                    elem.InnerText = "Active";
                }
                else
                {
                    elem.InnerText = "Removed";
                }
                elemRoot.AppendChild(elem);

                //this will used to check the folder already existed or not
                elem = xmlDoc.CreateElement("FolderNameToCompare");
                elem.InnerText = xLogproperties.DisplayFolderName.ToUpper();
                elemRoot.AppendChild(elem);

                elem = xmlDoc.CreateElement("OutlookLocation");
                xLogproperties.OutlookFolderLocation = xLogproperties.OutlookFolderLocation.Replace("\\\\", "");
                elem.InnerText = xLogproperties.OutlookFolderLocation;
                elemRoot.AppendChild(elem);

                elem = xmlDoc.CreateElement("DateAdded");
                elem.InnerText = System.DateTime.Now.ToString();
                elemRoot.AppendChild(elem);

                elem = xmlDoc.CreateElement("LastUpload");
                elem.InnerText = System.DateTime.Now.ToString();
                elemRoot.AppendChild(elem);

                elem = xmlDoc.CreateElement("URLType");
                elem.InnerText = xLogproperties.DroppedURLType;
                elemRoot.AppendChild(elem);

                elem = xmlDoc.CreateElement("SPSiteVersion");
                elem.InnerText = xLogproperties.SPSiteVersion;
                elemRoot.AppendChild(elem);

                if (isNewXMlFile == false)
                {
                    //XML file already existed add the node to xml file
                    root.InsertBefore(elemRoot, root.FirstChild);
                }
                //Save xml file
                xmlDoc.Save(UserLogManagerUtility.XMLFilePath);

                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return false;
        }
Example #17
0
        /// <summary>
        /// return an Xml document used as a reply to the client after an update of parameters has been received and carried out
        /// </summary>
        /// <returns>reply xml document</returns>
        protected static XmlDocument GetDeviceUpdateReply()
        {
            XmlDocument doc = new XmlDocument();

            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", XML_ENCODING, null);
            doc.PrependChild(dec);

            XmlElement statusreply = doc.CreateElement(STATUS_REPLY);
            doc.AppendChild(statusreply);
            
            //doc.Save("DeviceUpdateReply.xml");

            return (doc);
        }
Example #18
0
        /// <summary>
        /// return an Xml document containing sensor models
        /// </summary>
        /// <returns></returns>
        private XmlDocument getXmlDocumentSensorModels()
        {
            // Create the document.
            XmlDocument doc = new XmlDocument();

            // Insert the xml processing instruction and the root node
            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "ISO-8859-1", null);
            doc.PrependChild(dec);

            XmlElement nodeSensors = doc.CreateElement("Sensors");
            doc.AppendChild(nodeSensors);
			
            nodeSensors.AppendChild(
			    getXmlSensorModels(doc, nodeSensors));

            return (doc);
        }
Example #19
0
        /// <summary>
        /// return an Xml document containing camera calibration parameters
        /// </summary>
        /// <returns></returns>
        private XmlDocument getXmlDocument()
        {
            // Create the document.
            XmlDocument doc = new XmlDocument();

            // Insert the xml processing instruction and the root node
            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "ISO-8859-1", null);
            doc.PrependChild(dec);

            XmlNode commentnode = doc.CreateComment("Sentience 3D Perception System");
            doc.AppendChild(commentnode);

            XmlElement nodeCalibration = doc.CreateElement("Sentience");
            doc.AppendChild(nodeCalibration);

            xml.AddComment(doc, nodeCalibration, "Calibration apparatus setup parameters");

            XmlElement nodeCalibSetup = doc.CreateElement("CalibrationSetup");
            nodeCalibration.AppendChild(nodeCalibSetup);

            xml.AddComment(doc, nodeCalibSetup, "Horizontal field of view of the camera in degrees");
            xml.AddTextElement(doc, nodeCalibSetup, "FieldOfViewDegrees", txtFOV.Text);
            xml.AddComment(doc, nodeCalibSetup, "Position of the centre spot relative to the centre of the calibration pattern");
            xml.AddComment(doc, nodeCalibSetup, "0 - North West");
            xml.AddComment(doc, nodeCalibSetup, "1 - North East");
            xml.AddComment(doc, nodeCalibSetup, "2 - South East");
            xml.AddComment(doc, nodeCalibSetup, "3 - South West");
            xml.AddTextElement(doc, nodeCalibSetup, "CentreSpotPosition", Convert.ToString(cmbCentreSpotPosition.SelectedIndex));
            xml.AddComment(doc, nodeCalibSetup, "Distance from the camera to the centre of the calibration pattern along the ground in mm");
            xml.AddTextElement(doc, nodeCalibSetup, "DistToCentreMillimetres", txtDistToCentre.Text);
            xml.AddComment(doc, nodeCalibSetup, "height of the camera above the ground in mm");
            xml.AddTextElement(doc, nodeCalibSetup, "CameraHeightMillimetres", txtCameraHeight.Text);
            xml.AddComment(doc, nodeCalibSetup, "Calibration pattern spacing in mm");
            xml.AddTextElement(doc, nodeCalibSetup, "PatternSpacingMillimetres", txtPatternSpacing.Text);
            xml.AddComment(doc, nodeCalibSetup, "Baseline Distance mm");
            xml.AddTextElement(doc, nodeCalibSetup, "BaselineMillimetres", txtBaseline.Text);
            if (cam.leftcam.ROI != null)
            {
                xml.AddComment(doc, nodeCalibSetup, "Region of interest in the left image");
                xml.AddTextElement(doc, nodeCalibSetup, "LeftROI", Convert.ToString(cam.leftcam.ROI.tx) + "," +
                                                                    Convert.ToString(cam.leftcam.ROI.ty) + "," +
                                                                    Convert.ToString(cam.leftcam.ROI.bx) + "," +
                                                                    Convert.ToString(cam.leftcam.ROI.by));
            }
            if (cam.rightcam.ROI != null)
            {
                xml.AddComment(doc, nodeCalibSetup, "Region of interest in the right image");
                xml.AddTextElement(doc, nodeCalibSetup, "RightROI", Convert.ToString(cam.rightcam.ROI.tx) + "," +
                                                                    Convert.ToString(cam.rightcam.ROI.ty) + "," +
                                                                    Convert.ToString(cam.rightcam.ROI.bx) + "," +
                                                                    Convert.ToString(cam.rightcam.ROI.by));
            }

            return (doc);
        }
Example #20
0
        /// <summary>
        /// return an Xml document containing camera calibration parameters
        /// </summary>
        /// <returns></returns>
        private XmlDocument getXmlDocument()
        {
            // Create the document.
            XmlDocument doc = new XmlDocument();

            // Insert the xml processing instruction and the root node
            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "ISO-8859-1", null);
            doc.PrependChild(dec);

            XmlNode commentnode = doc.CreateComment("Sentience 3D Perception System");
            doc.AppendChild(commentnode);

            XmlElement nodeCalibration = doc.CreateElement("Sentience");
            doc.AppendChild(nodeCalibration);

            xml.AddComment(doc, nodeCalibration, "Camera calibration data");

            XmlElement elem = getXml(doc);
            doc.DocumentElement.AppendChild(elem);

            return (doc);
        }
Example #21
0
        /// <summary>
        /// returns the status of all devices as a string
        /// </summary>
        /// <param name="Devices"></param>
        /// <param name="usage"></param>
        /// <returns></returns>
        protected static string getDeviceStatusAll()
        {
            XmlDocument doc = new XmlDocument();

            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", XML_ENCODING, null);
            doc.PrependChild(dec);

            XmlElement bridgeware = doc.CreateElement(STATUS_REPLY);
            doc.AppendChild(bridgeware);

            XmlElement status = GetDeviceStatusAll(doc, bridgeware);
            bridgeware.AppendChild(status);

            string statusStr = doc.InnerXml;

            //doc.Save("StatusAll.xml");

            return (statusStr);
        }
        /// <summary>
        /// Return a string containing the metadata XML based on the settings added to this instance.
        /// The resulting XML will be signed, if the AsymmetricAlgorithm property has been set.
        /// </summary>
        /// <param name="encoding">The encoding.</param>
        /// <returns>The XML.</returns>
        public string ToXml(Encoding encoding)
        {
            var doc = new XmlDocument { PreserveWhitespace = true };
            doc.LoadXml(Serialization.SerializeToXmlString(Entity));

            // Add the correct encoding to the head element.
            if (doc.FirstChild is XmlDeclaration)
            {
                ((XmlDeclaration)doc.FirstChild).Encoding = encoding.WebName;
            }
            else
            {
                doc.PrependChild(doc.CreateXmlDeclaration("1.0", encoding.WebName, null));
            }

            if (Sign)
            {
                SignDocument(doc);
            }

            return doc.OuterXml;
        }
Example #23
0
        XmlDocument createXmlConfig()
        {
            XmlDocument doc = new XmlDocument();
            doc.LoadXml("<config></config>");
            doc.PrependChild(doc.CreateXmlDeclaration("1.0", "UTF-8", ""));

            //XmlNode config = doc.CreateElement("config");
            //doc.AppendChild(config);
            XmlNode config = doc.GetElementsByTagName("config")[0];

            XmlElement AVR = doc.CreateElement("AVR");
            config.AppendChild(AVR);
            XmlElement COM = doc.CreateElement("COM");
            AVR.AppendChild(COM);
            XmlElement baud = doc.CreateElement("Baudrate");
            AVR.AppendChild(baud);
            XmlElement databits = doc.CreateElement("Databits");
            AVR.AppendChild(databits);
            XmlElement stopbit = doc.CreateElement("Stopbits");
            AVR.AppendChild(stopbit);
            XmlElement parity = doc.CreateElement("Parity");
            AVR.AppendChild(parity);
            XmlElement handshake = doc.CreateElement("Handshake");
            AVR.AppendChild(handshake);
            XmlElement arduitoBootloader = doc.CreateElement("Arduino_Bootloader");
            AVR.AppendChild(arduitoBootloader);
            XmlElement bootloaderCOM = doc.CreateElement("Arduino_Bootloader_COM");
            AVR.AppendChild(bootloaderCOM);

            XmlElement lang = doc.CreateElement("Language");
            config.AppendChild(lang);

            XmlElement dome = doc.CreateElement("Dome");
            config.AppendChild(dome);
            XmlElement accel = doc.CreateElement("accel_time");
            dome.AppendChild(accel);
            XmlElement speed = doc.CreateElement("angular_speed_rpm");
            dome.AppendChild(speed);
            XmlElement thsld = doc.CreateElement("Threshold");
            dome.AppendChild(thsld);

            XmlElement encoder = doc.CreateElement("Encoder");
            config.AppendChild(encoder);
            XmlElement type = doc.CreateElement("type");
            encoder.AppendChild(type);
            XmlElement res = doc.CreateElement("resolution");
            encoder.AppendChild(res);
            XmlElement gearRatio = doc.CreateElement("gear_ratio");
            encoder.AppendChild(gearRatio);
            XmlElement pos = doc.CreateElement("LastPosition");
            encoder.AppendChild(pos);

            COM.InnerText = AVR_COM_Name;
            baud.InnerText = AVR_COM_Baudrate.ToString();
            databits.InnerText = AVR_COM_Databits.ToString();
            stopbit.InnerText = AVR_COM_Stopbits.ToString();
            parity.InnerText = AVR_COM_Parity.ToString();
            handshake.InnerText = AVR_COM_Handshake.ToString();
            arduitoBootloader.InnerText = isArduinoBootloader.ToString();
            bootloaderCOM.InnerText = AVRBootLoader_COM;

            lang.InnerText = language;

            type.InnerText = "Incremental";
            res.InnerText = this.EncoderRes.Value.ToString();
            gearRatio.InnerText = this.GearRatio.Value.ToString();
            pos.InnerText = _dome.Azimuth.ToString();
            accel.InnerText = MotorAccelleration.Value.ToString();
            speed.InnerText = MotorSpeed.Value.ToString();
            thsld.InnerText = this.Threshold.Value.ToString();

            return doc;
        }
Example #24
0
        /// <summary>
        /// Inspect an XML document.
        /// </summary>
        /// <param name="doc">The XML document to inspect.</param>
        private void InspectDocument(XmlDocument doc)
        {
            // inspect the declaration
            if (XmlNodeType.XmlDeclaration == doc.FirstChild.NodeType)
            {
                XmlDeclaration declaration = (XmlDeclaration)doc.FirstChild;

                if ("UTF-8" != declaration.Encoding)
                {
                    this.OnError(InspectorTestType.DeclarationEncodingWrong, declaration, "The XML declaration encoding is not properly set to 'UTF-8'.");
                    declaration.Encoding = "UTF-8";
                }
            }
            else // missing declaration
            {
                this.OnError(InspectorTestType.DeclarationMissing, null, "This file is missing an XML declaration on the first line.");
                doc.PrependChild(doc.CreateXmlDeclaration("1.0", "UTF-8", null));
            }

            // start inspecting the nodes at the document element
            this.InspectNode(doc.DocumentElement, 0);
        }
Example #25
0
        /// <summary>
        /// return an Xml document containing camera calibration parameters
        /// </summary>
        /// <returns></returns>
        private XmlDocument getXmlDocument()
        {
            // Create the document.
            XmlDocument doc = new XmlDocument();

            // Insert the xml processing instruction and the root node
            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "ISO-8859-1", null);
            doc.PrependChild(dec);

            XmlNode commentnode = doc.CreateComment("Sentience 3D Perception System");
            doc.AppendChild(commentnode);

            XmlElement nodeSentience = doc.CreateElement("Sentience");
            doc.AppendChild(nodeSentience);

            nodeSentience.AppendChild(getXml(doc, nodeSentience));

            return (doc);
        }
Example #26
0
        /// <summary>
        /// return an Xml document containing camera calibration parameters
        /// </summary>
        /// <param name="device_name"></param>
        /// <param name="focal_length_pixels"></param>
        /// <param name="baseline_mm"></param>
        /// <param name="fov_degrees"></param>
        /// <param name="image_width"></param>
        /// <param name="image_height"></param>
        /// <param name="lens_distortion_curve"></param>
        /// <param name="centre_of_distortion_x"></param>
        /// <param name="centre_of_distortion_y"></param>
        /// <param name="rotation"></param>
        /// <param name="scale"></param>
        /// <param name="lens_distortion_image_filename"></param>
        /// <param name="curve_fit_image_filename"></param>
        /// <param name="offset_x"></param>
        /// <param name="offset_y"></param>
        /// <param name="pan_curve"></param>
        /// <param name="pan_offset_x"></param>
        /// <param name="pan_offset_y"></param>
        /// <param name="tilt_curve"></param>
        /// <param name="tilt_offset_x"></param>
        /// <param name="tilt_offset_y"></param>
        /// <returns></returns>
        private static XmlDocument getXmlDocument(
            string device_name,
            float focal_length_pixels,
            float baseline_mm,
            float fov_degrees,
            int image_width, int image_height,
            polynomial[] lens_distortion_curve,
            double[] centre_of_distortion_x, double[] centre_of_distortion_y,
            double[] rotation, double[] scale,
            string[] lens_distortion_image_filename,
            string[] curve_fit_image_filename,
            float offset_x, float offset_y,
            polynomial pan_curve, float pan_offset_x, float pan_offset_y,
            polynomial tilt_curve, float tilt_offset_x, float tilt_offset_y)
        {
            // Create the document.
            XmlDocument doc = new XmlDocument();

            // Insert the xml processing instruction and the root node
            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "ISO-8859-1", null);
            doc.PrependChild(dec);

            XmlNode commentnode = doc.CreateComment("Sentience 3D Perception System");
            doc.AppendChild(commentnode);

            XmlElement nodeCalibration = doc.CreateElement("Sentience");
            doc.AppendChild(nodeCalibration);

            xml.AddComment(doc, nodeCalibration, "Sentience");

            XmlElement elem = getXml(doc, nodeCalibration,
                device_name,
                focal_length_pixels,
                baseline_mm,
                fov_degrees,
                image_width, image_height,
                lens_distortion_curve,
                centre_of_distortion_x, centre_of_distortion_y,
                rotation, scale,
                lens_distortion_image_filename,
                curve_fit_image_filename,
                offset_x, offset_y,
                pan_curve, pan_offset_x, pan_offset_y,
                tilt_curve, tilt_offset_x, tilt_offset_y);
            doc.DocumentElement.AppendChild(elem);

            return (doc);
        }
Example #27
0
        public XmlDocument getXML()
        {
            // Create the document.
            XmlDocument doc = new XmlDocument();

            // Insert the xml processing instruction and the root node
            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "ISO-8859-1", null);
            doc.PrependChild(dec);

            XmlElement nodeSociety = doc.CreateElement("Society");
            doc.AppendChild(nodeSociety);

            if (locations.Count > 0)
            {
                XmlElement nodeGeography = doc.CreateElement("Geography");
                nodeSociety.AppendChild(nodeGeography);

                // locations
                for (int i = 0; i < locations.Count; i++)
                {
                    location loc = (location)locations[i];
                    XmlElement elem = loc.getXML(doc);
                    nodeGeography.AppendChild(elem);
                }
            }

            if (personalities.Count > 0)
            {
                XmlElement nodePopulation = doc.CreateElement("Population");
                nodeSociety.AppendChild(nodePopulation);

                // people
                for (int i = 0; i < personalities.Count; i++)
                {
                    personality p = (personality)personalities[i];
                    XmlElement elem = p.getXML(doc);
                    nodePopulation.AppendChild(elem);
                }
            }

            if (events.Count > 0)
            {
                XmlElement nodeEvents = doc.CreateElement("Events");
                nodeSociety.AppendChild(nodeEvents);

                // events
                for (int i = 0; i < events.Count; i++)
                {
                    societyevent e = (societyevent)events[i];
                    XmlElement elem = e.getXML(doc);
                    nodeEvents.AppendChild(elem);
                }
            }

            return (doc);
        }