void WriteBytes(string name, Type type, byte[] value, int offset, int length, string comment)
{
writer.WriteStartElement("data");
writer.WriteAttributeString("name", name);
if (type != null)
{
writer.WriteAttributeString("type", type.AssemblyQualifiedName);
// byte[] should never get a mimetype, otherwise MS.NET won't be able
// to parse the data.
if (type != typeof(byte[]))
{
writer.WriteAttributeString("mimetype", ByteArraySerializedObjectMimeType);
}
writer.WriteStartElement("value");
WriteNiceBase64(value, offset, length);
}
else
{
writer.WriteAttributeString("mimetype", BinSerializedObjectMimeType);
writer.WriteStartElement("value");
writer.WriteBase64(value, offset, length);
}
writer.WriteEndElement();
if (!(comment == null || comment.Equals(String.Empty)))
{
writer.WriteStartElement("comment");
writer.WriteString(comment);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
public void AddValue(string name, System.IO.MemoryStream stream)
{
m_Writer.WriteStartElement(name);
if (stream == null)
{
m_Writer.WriteAttributeString("Length", XmlConvert.ToString(0));
}
else
{
byte[] buffer = stream.ToArray();
m_Writer.WriteAttributeString("Length", XmlConvert.ToString(buffer.Length));
m_Writer.WriteBase64(buffer, 0, buffer.Length);
}
m_Writer.WriteEndElement();
}
static void Main(string[] args)
{
// Dateinamen ermitteln
string imageFileName = Path.Combine(Application.StartupPath, "hitchhiker.jpg");
string xmlFileName = Path.Combine(Application.StartupPath, "hitchhiker.xml");
// FileStream-Instanz erzeugen
FileInfo fi = new FileInfo(imageFileName);
FileStream fs = fi.OpenRead();
// Byte-Puffer erzeugen und die Datei in diesen einlesen
byte[] buffer = new Byte[fi.Length];
fs.Read(buffer, 0, buffer.Length);
// Die eingelesenen Daten Base-64-codiert in eine XML-Datei schreiben
XmlTextWriter xmlWriter = new XmlTextWriter(xmlFileName, Encoding.UTF8);
xmlWriter.WriteStartDocument(true);
xmlWriter.WriteStartElement("applicationData");
xmlWriter.WriteStartElement("splashImage");
xmlWriter.WriteBase64(buffer, 0, buffer.Length);
xmlWriter.WriteEndElement();
xmlWriter.WriteEndElement();
// XML-Datei schließen
xmlWriter.Close();
// FileStream schließen
fs.Close();
Console.WriteLine("Fertig");
Console.WriteLine("Beenden mit Return");
Console.ReadLine();
}
void SavePictureToFile(XmlTextWriter xmlOut)
{
ImageControl.Cursor = Cursors.Wait;
try
{
xmlOut.WriteStartElement("PhotoPicture");
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
encoder.QualityLevel = CompressionRate;
encoder.Frames.Add(BitmapFrame.Create(bitmapImage));
MemoryStream memory = new MemoryStream(1000000);
encoder.Save(memory);
memory.Seek(0, SeekOrigin.Begin);
BinaryReader br = new BinaryReader(memory);
int bufferSize = 1000;
byte[] buffer = new byte[bufferSize];
int readBytes = 0;
do
{
readBytes = br.Read(buffer, 0, bufferSize);
xmlOut.WriteBase64(buffer, 0, readBytes);
} while (bufferSize <= readBytes);
br.Close();
xmlOut.WriteEndElement();
}
finally
{
ImageControl.Cursor = Cursors.Arrow;
}
}
/// <summary>
/// Only subscribed keys in the same namespace are saved.
/// </summary>
/// <param name="dict"></param>
/// <returns>XML file</returns>
public static MemoryStream Save(P2PDictionary dict)
{
MemoryStream writeStream = new MemoryStream();
System.Xml.XmlTextWriter writer = new XmlTextWriter(writeStream, Encoding.UTF8);
ICollection <string> keys = dict.Keys;
writer.WriteStartDocument();
writer.WriteStartElement("p2pdictionary");
writer.WriteStartElement("namespace");
writer.WriteAttributeString("name", dict.Namespace);
writer.WriteAttributeString("description", dict.Description);
IFormatter formatter = new BinaryFormatter();
foreach (string k in keys)
{
writer.WriteStartElement("entry");
writer.WriteAttributeString("key", k);
using (MemoryStream contents = new MemoryStream())
{
formatter.Serialize(contents, dict[k]);
writer.WriteBase64(contents.GetBuffer(), 0, (int)contents.Length);
}
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndElement();
writer.Flush();
return(writeStream);
}
private void button1_Click(object sender, EventArgs e)
{
if (!System.IO.File.Exists(textBox1.Text))
{
MessageBox.Show("Invalid image file name");
return;
}
if (!System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(textBox2.Text)))
{
MessageBox.Show("Invalid destination directory");
return;
}
XmlTextWriter writer = new XmlTextWriter(textBox2.Text, null);
FileStream fs = File.OpenRead(textBox1.Text);
byte[] data = new byte[fs.Length];
fs.Position = 0;
fs.Read(data, 0, data.Length);
fs.Close();
writer.WriteStartDocument();
writer.WriteStartElement("imagefile");
writer.WriteAttributeString("filename", textBox1.Text);
writer.WriteAttributeString("size", data.Length.ToString());
writer.WriteBase64(data, 0, data.Length);
writer.WriteEndElement();
writer.Close();
}
public static void Save(string filename, object options)
{
Byte[] buffer = new Byte[80];
MemoryStream ms;
BinaryFormatter bf = new BinaryFormatter();
System.Xml.XmlTextWriter xmlwriter =
new XmlTextWriter(filename, System.Text.Encoding.Default);
xmlwriter.Formatting = Formatting.Indented;
xmlwriter.WriteStartDocument();
xmlwriter.WriteComment("Option File. Do not edit! [email protected]");
xmlwriter.WriteStartElement(options.ToString());
PropertyInfo[] props = options.GetType().GetProperties(
BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.SetField);
foreach (PropertyInfo prop in props)
{
xmlwriter.WriteStartElement(prop.Name);
object da = prop.GetValue(options, null);
if (da != null)
{
xmlwriter.WriteAttributeString("Value", da.ToString());
ms = new MemoryStream();
try
{
bf.Serialize(ms, da);
ms.Position = 0;
int count = 0;
do
{
count = ms.Read(buffer, 0, buffer.Length);
xmlwriter.WriteBase64(buffer, 0, count);
}while (count == buffer.Length);
} //end try
catch (System.Runtime.Serialization.SerializationException)
{
System.Diagnostics.Trace.WriteLine("SERIALIZATION FAILED: {0}", prop.Name);
} //end catch
} //end if
else
{
xmlwriter.WriteAttributeString("Value", "null");
}
xmlwriter.WriteEndElement();
} //end foreach
xmlwriter.WriteEndElement();
xmlwriter.WriteEndDocument();
xmlwriter.Flush();
xmlwriter.Close();
} //end Save
/// <summary>
/// Handle the reception of a RTStroke object.
/// </summary>
/// <param name="rtStroke">Stroke received</param>
private void RTStrokeReceived(RTStroke rtStroke)
{
Page pg = rtDoc.Resources.Pages[rtStroke.PageIdentifier];
if (pg == null) // if the page is missing, ignore the stroke :(
{
return;
}
SizeF imageSize = GetSlideSize(pg.Image);
// Resize the received stroke
float xRatio = (imageSize.Width / constWidthPageSend) * inkSpaceToPixel;
float yRatio = (imageSize.Height / constHeightPageSend) * inkSpaceToPixel;
Rectangle bounds = rtStroke.Stroke.GetBoundingBox();
RectangleF newBounds = new RectangleF(bounds.X * xRatio, bounds.Y * yRatio,
bounds.Width * xRatio, bounds.Height * yRatio);
// Add the stroke to the page
StringBuilder importData = new StringBuilder(2000);
XmlTextWriter xml = CreateInitdXml(importData);
xml.WriteStartElement("PlaceObjects");
xml.WriteAttributeString("pagePath", crntONFile);
xml.WriteAttributeString("pageGuid", rtStroke.PageIdentifier.ToString("B"));
xml.WriteStartElement("Object");
xml.WriteAttributeString("guid", rtStroke.StrokeIdentifier.ToString("B"));
xml.WriteStartElement("Position");
xml.WriteAttributeString("x", newBounds.X.ToString());
xml.WriteAttributeString("y", newBounds.Y.ToString());
xml.WriteEndElement(); // end Position
xml.WriteStartElement("Ink");
xml.WriteAttributeString("width", newBounds.Width.ToString());
xml.WriteAttributeString("height", newBounds.Height.ToString());
Ink ink = new Ink();
ink.AddStrokesAtRectangle(rtStroke.Strokes, rtStroke.Strokes.GetBoundingBox());
byte[] base64ISF_bytes = ink.Save(PersistenceFormat.Base64InkSerializedFormat);
xml.WriteStartElement("Data");
xml.WriteBase64(base64ISF_bytes, 0, base64ISF_bytes.Length);
xml.WriteEndElement(); // end Data
xml.WriteEndDocument();
string finalData = importData.ToString();
LogAsLastCommand(finalData);
importer.Import(finalData);
// prevents ink & objects from getting inserted too quickly after a page
System.Threading.Thread.Sleep(50);
// Store the stroke ID in strokesPerPage
((ArrayList)strokesPerPage[rtStroke.PageIdentifier]).Add(rtStroke.StrokeIdentifier);
}
public void ToXml(XmlTextWriter writer)
{
writer.WriteStartElement("Plugin");
writer.WriteElementString("FileName", _fileName);
writer.WriteStartElement("Data");
writer.WriteBase64(_serializedData, 0, _serializedData.Length);
writer.WriteEndElement();
writer.WriteEndElement();
}
public override string ToString()
{
StringWriter sw = new StringWriter();
XmlTextWriter tw = new XmlTextWriter(sw);
tw.WriteBase64(BinaryValue, 0, BinaryValue.Length);
tw.Close();
return(sw.ToString());
}
internal static void WriteMeshGeometryXml(XmlTextWriter x, Point3DCollection polyline)
{
using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
{
WriteDatStream(polyline, ms);
ms.Flush();
byte[] data = ms.GetBuffer();
x.WriteBase64(data, 0, data.Length);
}
}
protected override void writeCustomXml(XmlTextWriter writer)
{
writer.WriteStartElement("image");
string fileName = Path.GetTempPath() + "mazioPictureShape.png";
PngFormat format = new PngFormat();
Img.Save(fileName, format.getCodecInfo(), format.getParameters());
byte[] bytes = File.ReadAllBytes(fileName);
writer.WriteBase64(bytes, 0, bytes.Length);
writer.WriteEndElement();
}
private void savePrivateKey(User user)
{
XmlTextWriter writer = new XmlTextWriter(Path.Combine(privateKeyPath, user.name + ".private"), Encoding.ASCII);
writer.WriteStartDocument(true);
writer.Formatting = Formatting.Indented;
writer.Indentation = 2;
writer.WriteStartElement("RSA");
form.writeElement("D", user.privateKey.D, writer);
form.writeElement("DP", user.privateKey.DP, writer);
form.writeElement("DQ", user.privateKey.DQ, writer);
form.writeElement("Exponent", user.privateKey.Exponent, writer);
form.writeElement("InverseQ", user.privateKey.InverseQ, writer);
form.writeElement("Modulus", user.privateKey.Modulus, writer);
form.writeElement("P", user.privateKey.P, writer);
form.writeElement("Q", user.privateKey.Q, writer);
writer.WriteEndElement();
writer.Close();
String path = Path.Combine(privateKeyPath, nazwaUzytkownikaTextBox.Text + ".private");
CryptoService service = new CryptoService();
AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
byte[] file = File.ReadAllBytes(path);
List <byte[]> message = new List <byte[]>();
byte[] encryptedMessage = { };
byte[] blockOfFile = { };
int readedByte = 0;
int sizeOfBlock = 256;
aes.GenerateIV();
while (readedByte < file.Length - sizeOfBlock)
{
blockOfFile = file.Skip(readedByte).Take(sizeOfBlock).ToArray <byte>();
readedByte += sizeOfBlock;
message.Add(service.aesEncoding(service.createSha512Hash(hasloUzytkownikaTextBox.Text, 16), "ECB", 128, blockOfFile, aes.IV));
}
blockOfFile = file.Skip(readedByte).Take(file.Length - readedByte).ToArray <byte>();
message.Add(service.aesEncoding(service.createSha512Hash(hasloUzytkownikaTextBox.Text, 16), "ECB", 128, blockOfFile, aes.IV));
XmlTextWriter writer2 = new XmlTextWriter(path, Encoding.UTF8);
foreach (byte[] block in message)
{
writer2.WriteBase64(block, 0, block.Length);
writer2.WriteWhitespace("\n");
}
writer2.Close();
}
/// <summary>
/// Returns an xml representation of an Attachment
/// </summary>
/// <returns></returns>
public string ToXml()
{
StringWriter sw = new StringWriter();
XmlTextWriter xtw = new XmlTextWriter(sw);
xtw.WriteStartElement("Attachment");
xtw.WriteAttributeString("Name", _fullName);
byte[] data = this.GetBytes();
xtw.WriteBase64(data, 0, data.Length);
xtw.WriteEndElement();
return(sw.ToString());
}
/// <summary>
/// Takes an image and writes it as an Image element to the Xml stream provided.
/// </summary>
private void GetImageAsXml(Image img, XmlTextWriter xml)
{
xml.WriteStartElement("Object");
xml.WriteAttributeString("guid", Guid.NewGuid().ToString("B"));
xml.WriteStartElement("Position");
xml.WriteAttributeString("x", "0");
xml.WriteAttributeString("y", "0");
xml.WriteEndElement(); // end Position
xml.WriteStartElement("Image");
xml.WriteAttributeString("backgroundImage", "true");
// Set size of image
SizeF imageSize = GetSlideSize(img);
xml.WriteAttributeString("width", (imageSize.Width).ToString());
xml.WriteAttributeString("height", (imageSize.Height).ToString());
// Write the image in the xml as Base64
xml.WriteStartElement("Data");
byte[] bits;
if (img.RawFormat.Equals(ImageFormat.Emf) || img.RawFormat.Equals(ImageFormat.Wmf))
{
// The image goes bad during serialization, so we have to clone it.
Metafile mf = (Metafile)((Metafile)img).Clone();
IntPtr ptr = mf.GetHenhmetafile();
Debug.Assert(ptr != IntPtr.Zero, "Failed to get pointer to image.");
uint size = GetEnhMetaFileBits(ptr, 0, null);
bits = new byte[size];
uint numBits = GetEnhMetaFileBits(ptr, size, bits);
mf.Dispose();
Debug.Assert(size == numBits, "Improper serialization of metafile!");
}
else
{
MemoryStream imgMS = new MemoryStream();
img.Save(imgMS, System.Drawing.Imaging.ImageFormat.Jpeg);
bits = imgMS.ToArray();
}
xml.WriteBase64(bits, 0, bits.Length);
xml.WriteEndElement(); // end Data
xml.WriteEndElement(); // end Image
xml.WriteEndElement(); // end Object
}
private void WriteValue(XmlTextWriter writer, object value)
{
TypeConverter c = TypeDescriptor.GetConverter(value.GetType());
if (c.CanConvertTo(typeof(System.Byte[])))
{
byte[] bs = c.ConvertTo(value, typeof(System.Byte[])) as byte[];
writer.WriteBase64(bs, 0, bs.Length);
}
else
{
writer.WriteAttributeString(XN_AT_VALUE, value.ToString());
}
}
public static string ImageToString(Image image)
{
MemoryStream memoryStream = new MemoryStream();
image.Save(memoryStream, ImageFormat.Png);
memoryStream.Seek(0L, SeekOrigin.Begin);
StringBuilder stringBuilder = new StringBuilder();
XmlTextWriter xmlTextWriter = new XmlTextWriter(new StringWriter(stringBuilder, CultureInfo.InvariantCulture));
byte[] array = memoryStream.ToArray();
xmlTextWriter.WriteBase64(array, 0, array.Length);
xmlTextWriter.Close();
memoryStream.Close();
return(stringBuilder.ToString());
}
static void WriteBytes(XmlTextWriter writer, string name, byte[] data)
{
writer.WriteStartElement(name);
byte[] d;
if (data != null)
{
d = data;
}
else
{
d = Utils.EmptyBytes;
}
writer.WriteBase64(d, 0, d.Length);
writer.WriteEndElement(); // name
}
private void button1_Click(object sender, EventArgs e)
{
XmlTextWriter writer = new XmlTextWriter(textBox2.Text, null);
FileStream fs = File.OpenRead(textBox1.Text);
byte[] data = new byte[fs.Length];
fs.Position = 0;
fs.Read(data, 0, data.Length);
fs.Close();
writer.WriteStartDocument();
writer.WriteStartElement("imagefile");
writer.WriteAttributeString("filename", textBox1.Text);
writer.WriteAttributeString("size", data.Length.ToString());
writer.WriteBase64(data, 0, data.Length);
writer.WriteEndElement();
writer.Close();
}
/// <summary>
/// Converts the object passed in to its XML representation.
/// The XML string is written on the XmlTextWriter.
/// </summary>
public void ToXml(object value, FieldInfo field, XmlTextWriter xml, IMarshalContext context)
{
Type type = value.GetType();
if (type.IsArray)
{
byte[] bytes = value as byte[];
context.WriteStartTag(__arrayType, field, xml);
xml.WriteBase64(bytes, 0, bytes.Length);
context.WriteEndTag(__arrayType, field, xml);
}
else
{
context.WriteStartTag(__type, field, xml);
xml.WriteString(value.ToString());
context.WriteEndTag(__type, field, xml);
}
}
//public XmlNode UpdateCase(string CreateUserName, string CreateUserDomain, string processName, string entityName, List<KeyValuePair<string, string>> request, string entityNameWithFileType, string fileName, string path)
//{
// XmlDocument requestNode = new XmlDocument();
// string filePath = string.Format("{0}\\{1}", fileName, path);
// string xmlString = "<BizAgiWSParam>";
// xmlString += "<domain>" + CreateUserDomain + "</domain>";
// xmlString += "<userName>" + CreateUserName + "</userName>";
// xmlString += "<Cases>";
// xmlString += "<Case>";
// xmlString += "<Process>" + processName + "</Process>";
// xmlString += "<Entities>";
// xmlString += "<" + entityName + ">";
// foreach (KeyValuePair<string, string> pair in request)
// {
// xmlString += Utility.FormTag(pair.Key, pair.Value);
// }
// xmlString += "<" + entityNameWithFileType + ">";
// xmlString += string.Format("<File fileName=\"{0}\">{1}</File>", fileName, ConvertToBase64(filePath));
// xmlString += "</" + entityNameWithFileType + ">";
// xmlString += "</" + entityName + ">";
// xmlString += "</Entities>";
// xmlString += "</Case>";
// xmlString += "</Cases>";
// xmlString += "</BizAgiWSParam>";
// requestNode.LoadXml(xmlString);
// return connObject.createCases(requestNode);
//}
public string ConvertToBase64(string file)
{
FileStream stream = File.Open(file, FileMode.Open, FileAccess.Read);
//The fileStream is loaded into a BinaryReader
BinaryReader binaryReader = new BinaryReader(stream);
//Read the bytes and save them in an array
byte[] oBytes = binaryReader.ReadBytes(Convert.ToInt32(stream.Length));
//Load an empty StringBuilder into an XmlWriter
System.Text.StringBuilder sb = new System.Text.StringBuilder();
TextWriter tw = new StringWriter(sb);
XmlTextWriter m_XmlWriter = new XmlTextWriter(tw);
//Transform the bytes in the StringBuilder into Base64
m_XmlWriter.WriteBase64(oBytes, 0, oBytes.Length);
stream.Close();
return(sb.ToString());
}
private void createEndFile(List <User> users, AesCryptoServiceProvider aes, string extension, List <byte[]> message)
{
XmlTextWriter writer = new XmlTextWriter(lokalizacjaSzyfrowaniaTextBox.Text + "\\" +
nazwaPlikuSzyfrowanegoTextBox.Text + ".xml", Encoding.UTF8);
CryptoService service = new CryptoService();
writer.WriteStartDocument(true);
writer.Formatting = Formatting.Indented;
writer.Indentation = 2;
writer.WriteStartElement("EncryptedFileHeader");
writeElement("Algorithm", "AES", writer);
writeElement("KeySize", dlugoscKluczaComboBox.Text, writer);
writeElement("BlockSize", "128", writer);
writeElement("Subblock", dlugoscPodblokuComboBox.Text, writer);
writeElement("Mode", trybSzyfrowaniaComboBox.Text, writer);
writeElement("IV", aes.IV, writer);
writeElement("Extension", extension, writer);
writer.WriteStartElement("ApprovedUsers");
foreach (User singleUser in users)
{
singleUser.publicKey = loadPublicKey(singleUser.name);
singleUser.sessionKey = service.rsaEncoding(singleUser.sessionKey, singleUser.publicKey);
writer.WriteStartElement("User");
writeElement("Name", singleUser.name, writer);
writeElement("sessionKey", singleUser.sessionKey, writer);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteStartElement("EnFile");
writer.WriteWhitespace("\n");
foreach (byte[] block in message)
{
writer.WriteBase64(block, 0, block.Length);
writer.WriteWhitespace("\n");
}
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Close();
}
// Use the WriteBase64 method to create an XML document. The object
// passed by the user is encoded and included in the document.
public static void EncodeXmlFile(string xmlFileName, FileStream fileOld)
{
var buffer = new byte[bufferSize];
int readByte = 0;
var xw = new XmlTextWriter(xmlFileName, Encoding.UTF8);
xw.WriteStartDocument();
xw.WriteStartElement("root");
// Create a Char writer.
var br = new BinaryReader(fileOld);
// Set the file pointer to the end.
try
{
do
{
readByte = br.Read(buffer, 0, bufferSize);
xw.WriteBase64(buffer, 0, readByte);
} while (bufferSize <= readByte);
}
catch (Exception ex)
{
var ex1 = new EndOfStreamException();
if (ex1.Equals(ex))
{
Console.WriteLine("We are at end of file");
}
else
{
Console.WriteLine(ex);
}
}
xw.WriteEndElement();
xw.WriteEndDocument();
xw.Flush();
xw.Close();
}
private void Write(byte[] binary, int length)
{
switch (binaryTextMode)
{
case BinaryTextMode.Base64:
xml.WriteBase64(binary, 0, length);
break;
case BinaryTextMode.BinHex:
xml.WriteBinHex(binary, 0, length);
break;
case BinaryTextMode.QuotedPrintable:
xml.WriteString(QuotedPrintable.Encode(binary, 0, length));
break;
case BinaryTextMode.AsciiHexSwitch:
xml.WriteString(AsciiHexSwitch.Encode(binary, 0, length));
break;
}
}
public static string wrapsignature(byte[] A_0)
{
UTF8Encoding utF8Encoding = new UTF8Encoding();
using (MemoryStream memoryStream = new MemoryStream())
{
XmlTextWriter xmlTextWriter = new XmlTextWriter((Stream)memoryStream, (Encoding)utF8Encoding);
xmlTextWriter.Formatting = Formatting.Indented;
xmlTextWriter.Indentation = 3;
xmlTextWriter.WriteStartDocument();
string localName = "Base64";
xmlTextWriter.WriteStartElement(localName);
byte[] buffer = A_0;
int index = 0;
int length = A_0.Length;
xmlTextWriter.WriteBase64(buffer, index, length);
xmlTextWriter.WriteEndElement();
xmlTextWriter.WriteEndDocument();
xmlTextWriter.Flush();
xmlTextWriter.Close();
byte[] array = memoryStream.ToArray();
return(utF8Encoding.GetString(array));
}
}
private void xmlWriterBtn_Click(object sender, EventArgs e)
{
Bitmap image = new Bitmap(path);
using (MemoryStream ms = new MemoryStream())
{
image.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
using (FileStream fm = new FileStream(Path.GetDirectoryName(Application.ExecutablePath) + "/test.xml", FileMode.Create, FileAccess.ReadWrite))
{
XmlTextWriter writer = new XmlTextWriter(fm, Encoding.UTF8);
writer.WriteStartDocument();
writer.WriteStartElement("Im");
writer.WriteElementString("Name", Path.GetFileNameWithoutExtension(this.path));
writer.WriteElementString("Number", "1");
writer.WriteElementString("Type", Path.GetExtension(this.path).Substring(1));
writer.WriteStartElement("Data");
writer.WriteBase64(ms.ToArray(), 0, ms.ToArray().Length);
writer.WriteEndElement();
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
writer.Close();
}
}
}
void TrySerialize(XmlTextWriter xtw, object targetObject, ArrayList nestedObjs)
{
xtw.WriteStartElement("", "value", "");
var xType = XmlRpcServiceInfo.GetXmlRpcType(targetObject.GetType());
if (xType == XmlRpcType.Array)
{
xtw.WriteStartElement("", "array", "");
xtw.WriteStartElement("", "data", "");
foreach (var aobj in (Array)targetObject)
{
if (aobj == null)
{
throw new XmlRpcMappingSerializeException($"Items in array cannot be null ({targetObject.GetType().GetElementType()}[]).");
}
Serialize(xtw, aobj, nestedObjs);
}
xtw.WriteEndElement();
xtw.WriteEndElement();
}
else if (xType == XmlRpcType.MultiDimArray)
{
var mda = (Array)targetObject;
var indices = new int[mda.Rank];
BuildArrayXml(xtw, mda, 0, indices, nestedObjs);
}
else if (xType == XmlRpcType.Base64)
{
var buf = (byte[])targetObject;
xtw.WriteStartElement("", "base64", "");
xtw.WriteBase64(buf, 0, buf.Length);
xtw.WriteEndElement();
}
else if (xType == XmlRpcType.Boolean)
{
bool boolVal;
if (targetObject is bool)
{
boolVal = (bool)targetObject;
}
else
{
boolVal = (XmlRpcBoolean)targetObject;
}
if (boolVal)
{
xtw.WriteElementString("boolean", "1");
}
else
{
xtw.WriteElementString("boolean", "0");
}
}
else if (xType == XmlRpcType.DateTime)
{
DateTime dt;
if (targetObject is DateTime)
{
dt = (DateTime)targetObject;
}
else
{
dt = (XmlRpcDateTime)targetObject;
}
var sdt = dt.ToString("yyyyMMdd'T'HH':'mm':'ss", DateTimeFormatInfo.InvariantInfo);
xtw.WriteElementString("dateTime.iso8601", sdt);
}
else if (xType == XmlRpcType.Double)
{
double doubleVal;
if (targetObject is double)
{
doubleVal = (double)targetObject;
}
else
{
doubleVal = (XmlRpcDouble)targetObject;
}
xtw.WriteElementString("double", doubleVal.ToString(null, CultureInfo.InvariantCulture));
}
else if (xType == XmlRpcType.Hashtable)
{
xtw.WriteStartElement("", "struct", "");
var xrs = targetObject as XmlRpcStruct;
foreach (object obj in xrs.Keys)
{
var skey = obj as string;
xtw.WriteStartElement("", "member", "");
xtw.WriteElementString("name", skey);
Serialize(xtw, xrs[skey], nestedObjs);
xtw.WriteEndElement();
}
xtw.WriteEndElement();
}
else if (xType == XmlRpcType.Int32)
{
if (Configuration.UseIntTag)
{
xtw.WriteElementString("int", targetObject.ToString());
}
else
{
xtw.WriteElementString("i4", targetObject.ToString());
}
}
else if (xType == XmlRpcType.Int64)
{
xtw.WriteElementString("i8", targetObject.ToString());
}
else if (xType == XmlRpcType.String)
{
if (Configuration.UseStringTag)
{
xtw.WriteElementString("string", (string)targetObject);
}
else
{
xtw.WriteString((string)targetObject);
}
}
else if (xType == XmlRpcType.Struct)
{
xtw.WriteStartElement("", "struct", "");
var mis = targetObject.GetType().GetMembers();
var structAction = AttributeHelper.StructMappingAction(targetObject.GetType(), Configuration.MappingAction);
foreach (var mi in mis)
{
if (Attribute.IsDefined(mi, typeof(NonSerializedAttribute)))
{
continue;
}
if (mi.MemberType == MemberTypes.Field)
{
var fi = (FieldInfo)mi;
var member = fi.Name;
var attrchk = Attribute.GetCustomAttribute(fi, typeof(XmlRpcMemberAttribute));
if (attrchk != null && attrchk is XmlRpcMemberAttribute)
{
var mmbr = ((XmlRpcMemberAttribute)attrchk).Member;
if (mmbr != "")
{
member = mmbr;
}
}
if (fi.GetValue(targetObject) == null)
{
var memberAction = AttributeHelper.MemberMappingAction(targetObject.GetType(), fi.Name, structAction);
if (memberAction == MappingAction.Ignore)
{
continue;
}
throw new XmlRpcMappingSerializeException(@"Member """ + member + @""" of class """ + targetObject.GetType().Name + @""" cannot be null.");
}
xtw.WriteStartElement("", "member", "");
xtw.WriteElementString("name", member);
Serialize(xtw, fi.GetValue(targetObject), nestedObjs);
xtw.WriteEndElement();
}
else if (mi.MemberType == MemberTypes.Property)
{
var pi = (PropertyInfo)mi;
var member = pi.Name;
var attrchk = Attribute.GetCustomAttribute(pi, typeof(XmlRpcMemberAttribute));
if (attrchk != null && attrchk is XmlRpcMemberAttribute)
{
var mmbr = ((XmlRpcMemberAttribute)attrchk).Member;
if (mmbr != "")
{
member = mmbr;
}
}
if (pi.GetValue(targetObject) == null)
{
var memberAction = AttributeHelper.MemberMappingAction(targetObject.GetType(), pi.Name, structAction);
if (memberAction == MappingAction.Ignore)
{
continue;
}
}
xtw.WriteStartElement("", "member", "");
xtw.WriteElementString("name", member);
Serialize(xtw, pi.GetValue(targetObject, null), nestedObjs);
xtw.WriteEndElement();
}
}
xtw.WriteEndElement();
}
else if (xType == XmlRpcType.Void)
{
xtw.WriteElementString("string", "");
}
else
{
throw new XmlRpcUnsupportedTypeException(targetObject.GetType());
}
xtw.WriteEndElement();
}
/// <remarks>Serialize the object to the output stream.</remarks>
/// <param name="output">An <c>XmlTextWriter</c> stream to write data to.</param>
/// <param name="obj">An <c>Object</c> to serialize.</param>
public void SerializeObject(XmlTextWriter output, Object obj)
{
if (obj == null)
{
return;
}
if (obj is byte[])
{
byte[] ba = (byte[])obj;
output.WriteStartElement(BASE64);
output.WriteBase64(ba, 0, ba.Length);
output.WriteEndElement();
}
else if (obj is String)
{
output.WriteElementString(STRING, obj.ToString());
}
else if (obj is Int32)
{
output.WriteElementString(INT, obj.ToString());
}
else if (obj is DateTime)
{
output.WriteElementString(DATETIME, ((DateTime)obj).ToString(ISO_DATETIME));
}
else if (obj is Double)
{
output.WriteElementString(DOUBLE, obj.ToString());
}
else if (obj is Boolean)
{
output.WriteElementString(BOOLEAN, ((((Boolean)obj) == true)?"1":"0"));
}
else if (obj is IList)
{
output.WriteStartElement(ARRAY);
output.WriteStartElement(DATA);
if (((ArrayList)obj).Count > 0)
{
foreach (Object member in ((IList)obj))
{
output.WriteStartElement(VALUE);
SerializeObject(output, member);
output.WriteEndElement();
}
}
output.WriteEndElement();
output.WriteEndElement();
}
else if (obj is IDictionary)
{
IDictionary h = (IDictionary)obj;
output.WriteStartElement(STRUCT);
foreach (String key in h.Keys)
{
output.WriteStartElement(MEMBER);
output.WriteElementString(NAME, key);
output.WriteStartElement(VALUE);
SerializeObject(output, h[key]);
output.WriteEndElement();
output.WriteEndElement();
}
output.WriteEndElement();
}
}
private string Content()
{
int iStubID;
int iCurrentStubVersion = Root.GetStubsVersion(currentUserID);
StringBuilder sb = new StringBuilder();
StringWriter stringWriter = new StringWriter(sb);
XmlTextWriter writer = new XmlTextWriter(stringWriter);
writer.WriteStartElement("options");
writer.WriteAttributeString("xmlns", "dt", null, "urn:schemas-microsoft-com:datatypes");
// Stubs
int iGroupId = Root.GetGroupByUser(currentUserID);
if (iStubsVersion != iCurrentStubVersion && iCurrentStubVersion >= 0)
{
writer.WriteStartElement("stubs");
writer.WriteAttributeString("version", iCurrentStubVersion.ToString());
using (IDataReader reader = Root.GetAllStubsForUser(currentUserID))
{
while (reader.Read())
{
writer.WriteStartElement("stub");
iStubID = Convert.ToInt32(reader["StubId"]);
writer.WriteElementString("stub_id", iStubID.ToString());
writer.WriteElementString("stub_name", reader["Abbreviation"].ToString());
writer.WriteElementString("tooltip", reader["ToolTip"].ToString());
writer.WriteElementString("url", reader["Url"].ToString());
writer.WriteElementString("open_window", reader["OpenInBrowser"].ToString());
byte[] bit_icon = null;
using (IDataReader reader_for_BLOB = Root.GetBinaryStubIcon(iStubID))
{
if (reader_for_BLOB.Read())
{
try
{
bit_icon = (byte[])reader_for_BLOB["Icon"];
}
catch { }
}
}
if (bit_icon != null)
{
writer.WriteStartElement("icon");
writer.WriteAttributeString("dt:dt", "bin.base64");
writer.WriteBase64(bit_icon, 0, bit_icon.Length);
writer.WriteEndElement(); //icon
}
else
{
writer.WriteElementString("icon", "");
}
writer.WriteEndElement(); //stub
}
}
writer.WriteEndElement(); //stubs
}
// Versions
int iMaxBuild = -1; // CManage.GetMaxBuild(sProdGUID);
if (iMaxBuild > iBuild)
{
writer.WriteStartElement("versions");
writer.WriteAttributeString("latest", iMaxBuild.ToString());
writer.WriteAttributeString("url", "Download/IBN Client.msi");
writer.WriteAttributeString("mcupdate", "Download/McUpdate.exe#1.1.25.0");
//DateTime dt;
//using (IDataReader reader = CManage.GetHightVersions(iBuild, sProdGUID))
//{
// while (reader.Read())
// {
// writer.WriteStartElement("version");
// writer.WriteAttributeString("build", reader["build"].ToString());
// dt = Convert.ToDateTime(reader["date"].ToString());
// writer.WriteAttributeString("date", dt.ToString("d", DateTimeFormatInfo.InvariantInfo));
// writer.WriteAttributeString("description", reader["description"].ToString());
// writer.WriteEndElement(); //version
// }
//}
writer.WriteEndElement(); //versions
}
// Logos
using (IDataReader reader = Root.GetLogoByGroup(iGroupId))
{
if (reader.Read())
{
int iLogoGroupVersion = Convert.ToInt32(reader["logo_version"]);
// Write color and encoded image
if (iLogoVersion != iLogoGroupVersion)
{
try
{
string version = iLogoGroupVersion.ToString();
string color = reader["color"].ToString();
byte[] bit_logo = null;
using (IDataReader reader_for_BLOB = Root.GetBinaryClientLogo(iGroupId))
{
try
{
if (reader_for_BLOB.Read())
{
bit_logo = (byte[])reader_for_BLOB["client_logo"];
}
}
catch { }
}
writer.WriteStartElement("logos");
writer.WriteAttributeString("version", version);
writer.WriteStartElement("logo");
writer.WriteElementString("color", color);
if (bit_logo != null)
{
writer.WriteStartElement("client_logo");
writer.WriteAttributeString("dt:dt", "bin.base64");
writer.WriteBase64(bit_logo, 0, bit_logo.Length);
writer.WriteEndElement(); // client_logo
}
writer.WriteEndElement(); // logo
writer.WriteEndElement(); // logos
}
catch { }
}
}
}
writer.WriteEndElement(); // options
return(sb.ToString());
}
private void WriteButtonDetails(XmlTextWriter xwriter, HerbiSpeaksButton btn)
{
xwriter.WriteAttributeString("CenterX", btn.CenterX.ToString());
xwriter.WriteAttributeString("CenterY", btn.CenterY.ToString());
xwriter.WriteAttributeString("Width", btn.Size.Width.ToString());
xwriter.WriteAttributeString("Height", btn.Size.Height.ToString());
xwriter.WriteAttributeString("IsPictureButton", btn.IsPictureButton.ToString());
xwriter.WriteAttributeString("BoardLink", btn.BoardLink);
xwriter.WriteAttributeString("BoardLinkSpoken", btn.BoardLinkSpoken.ToString());
string text = btn.Text;
if (text == "")
{
text = btn.AccessibleName;
xwriter.WriteAttributeString("ShowText", false.ToString());
}
xwriter.WriteAttributeString("Text", text);
// Always write out the button's font name, font size and text colour, even
// if any of those things are the same as the app's current default settings.
xwriter.WriteAttributeString("TextColour", btn.ForeColor.ToArgb().ToString());
xwriter.WriteAttributeString("FontName", btn.Font.Name);
xwriter.WriteAttributeString("FontSize", ((int)btn.Font.Size).ToString());
xwriter.WriteAttributeString("ButtonTransparent", ((bool)btn.ButtonTransparent).ToString());
xwriter.WriteAttributeString("ButtonTransparentOnHover", ((bool)btn.ButtonTransparentOnHover).ToString());
if ((btn.Media != null) && (btn.Media != ""))
{
xwriter.WriteAttributeString("Media", btn.Media);
}
xwriter.WriteAttributeString("ButtonTextSpokenBeforeMedia",
btn.ButtonTextSpokenBeforeMedia.ToString());
xwriter.WriteAttributeString("AutoPlayMedia",
btn.AutoPlayMedia.ToString());
xwriter.WriteAttributeString("TextPosition", btn.TextPosition);
// Always stream out the full image. We don't care here how the image
// happens to be presented on the button at the moment.
if (btn.ImageFull != null)
{
MemoryStream stream = new MemoryStream();
btn.ImageFull.Save(stream, ImageFormat.Png);
byte[] bytes = stream.ToArray();
xwriter.WriteStartElement("PictureData");
xwriter.WriteAttributeString("Length", bytes.Length.ToString());
xwriter.WriteBase64(stream.ToArray(), 0, bytes.Length);
xwriter.WriteEndElement();
}
if (btn.ImageHoverFull != null)
{
MemoryStream stream = new MemoryStream();
btn.ImageHoverFull.Save(stream, ImageFormat.Png);
byte[] bytes = stream.ToArray();
xwriter.WriteStartElement("HoverPictureData");
xwriter.WriteAttributeString("Length", bytes.Length.ToString());
xwriter.WriteBase64(stream.ToArray(), 0, bytes.Length);
xwriter.WriteEndElement();
}
}
