private void Init()
{
try {
string basepath = System.Reflection.Assembly.GetExecutingAssembly().CodeBase.Replace("file:///", "").Replace("/", @"\");
basepath = System.IO.Path.GetDirectoryName(basepath) + @"\";
GameCatalogSerializer gcs = new GameCatalogSerializer();
XmlDocument doc = gcs.Serialize(games);
System.Xml.XPath.XPathNavigator nav = doc.CreateNavigator();
System.Xml.Xsl.XslTransform xt = new System.Xml.Xsl.XslTransform();
System.Xml.XmlResolver res = new System.Xml.XmlUrlResolver();
System.IO.StringWriter writer = new System.IO.StringWriter();
System.Xml.Xsl.XsltArgumentList args = new System.Xml.Xsl.XsltArgumentList();
System.Xml.XmlNameTable xnt = new System.Xml.NameTable();
System.Xml.XmlReader xslt = new System.Xml.XmlTextReader(new System.IO.StreamReader(basepath + "GameList.xslt"), xnt);
xt.Load(xslt, res, new System.Security.Policy.Evidence());
xt.Transform(nav, args, writer, res);
string html = writer.ToString();
WriteHTML(html);
} catch (Exception ex) {
string error = "There was an error generating HTML";
Exception xe = ex;
while (xe != null)
{
error += "<p><b>" + xe.Message + "</b><br><pre>" + xe.StackTrace + "</pre></p>\r\n";
}
WriteHTML(error);
}
}
public void BuildNavigator(string modelFilePath)
{
XmlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
XmlTextReader tr = new XmlTextReader(modelFilePath);
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "ModelTree.xsl",null,resolver);
XmlTextWriter tw = new XmlTextWriter(this.htmlFilesPath + Path.DirectorySeparatorChar + "ModelTree.htm", Encoding.UTF8);
XsltArgumentList al = new XsltArgumentList();
al.AddParam("modelBrowser","",this.localizer.GetValue("Globals","ModelBrowser"));
al.AddParam("glossary","",this.localizer.GetValue("Globals","Glossary"));
al.AddParam("stakeholders", "", this.localizer.GetValue("Globals", "Stakeholders"));
transform.Transform(tr,al,tw,null);
tw.Close();
tr.Close();
tr = new XmlTextReader(modelFilePath);
transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "HomePage.xsl",null,resolver);
tw = new XmlTextWriter(this.htmlFilesPath + Path.DirectorySeparatorChar + "main.htm",Encoding.UTF8);
al = new XsltArgumentList();
AssemblyName an = this.GetType().Assembly.GetName();
al.AddParam("version","",an.Version.ToString(3));
al.AddParam("model", "", this.localizer.GetValue("Globals", "Model"));
al.AddParam("author", "", this.localizer.GetValue("Globals", "Author"));
al.AddParam("company", "", this.localizer.GetValue("Globals", "Company"));
al.AddParam("creationDate", "", this.localizer.GetValue("Globals", "CreationDate"));
al.AddParam("exportPrintDate", "", this.localizer.GetValue("Globals", "ExportPrintDate"));
al.AddParam("now", "", Convert.ToString(DateTime.Now, DateTimeFormatInfo.InvariantInfo));
al.AddParam("release", "", this.localizer.GetValue("Globals", "Release"));
transform.Transform(tr,al,tw,null);
tw.Close();
tr.Close();
}
public DotNetCompiledTransform(string sTransformName, string sTargetLanguageCode)
: base(sTargetLanguageCode)
{
var resolver = new XmlUrlResolver();
resolver.Credentials = System.Net.CredentialCache.DefaultCredentials;
m_transformer.Load(sTransformName, XsltSettings.TrustedXslt, resolver);
}
/// <summary>
/// Initializes a new instance of the <see cref="XslCompiler">XslCompiler</see> class.
/// </summary>
public XslCompiler(string path, string assemblyFilename)
{
Path = path;
Filename = assemblyFilename;
TargetProcessor = ImageFileMachine.I386;
XsltSettings = new XsltSettings();
XmlResolver = new XmlUrlResolver();
XmlResolver.Credentials = CredentialCache.DefaultCredentials;
}
public void Transform(string modelFilePath)
{
XmlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
XmlTextReader doc = new XmlTextReader(modelFilePath);
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "XMI11Export.xsl",null,resolver);
transform.Transform(doc,null,new XmlTextWriter(this.xmiFilesPath,Encoding.UTF8),resolver);
}
public Stream ImportXmiStream(string filename)
{
XmlDocument input = GetInputFile (filename);
XmlResolver res = new XmlUrlResolver ();
XslTransform xslt = GetXslt (input, null, res);
MemoryStream output = new MemoryStream ();
xslt.Transform (input, new XsltArgumentList (), output, res);
return output;
}
public void BuildPages(string modelFilePath)
{
XmlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
XmlDocument doc = new XmlDocument();
doc.XmlResolver = resolver;
doc.Load(modelFilePath);
XmlNode modelNode = doc.SelectSingleNode("//Model");
this.RecurseNode(modelFilePath, resolver, modelNode,"Package.xsl");
}
public XmlDocument ImportXmi(string filename)
{
XmlDocument input = GetInputFile (filename);
XmlResolver res = new XmlUrlResolver ();
XslTransform xslt = GetXslt (input, null, res);
XmlReader reader = xslt.Transform (input, new XsltArgumentList (), res);
XmlDocument output = new XmlDocument ();
output.Load (reader);
return output;
}
public override object GetEntity(Uri absoluteUri, string role, Type ofObjectToReturn)
{
string name = absoluteUri.AbsoluteUri.Split(new char[] { '/' }).Last<string>();
byte[] stream = _schemas[name];
if (stream != null)
{
return new MemoryStream(stream);;
}
XmlUrlResolver resolver = new XmlUrlResolver();
return resolver.GetEntity(absoluteUri, role, ofObjectToReturn);
}
public void Transform(string modelFilePath)
{
XmlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
XmlDocument doc = new XmlDocument();
doc.XmlResolver = resolver;
doc.Load(modelFilePath);
XslTransform transform = new XslTransform();
transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "XMI11Export.xsl",resolver);
StreamWriter sw = new StreamWriter(this.xmiFilesPath,false);
transform.Transform(doc,null,sw,null);
sw.Close();
}
public static bool SendEmail(SPWeb web, string emailTo, string xslt, IDictionary xslValues)
{
XmlDocument xmlDoc;
XPathNavigator xpathNavigator;
XslCompiledTransform xslEmailTransform = new XslCompiledTransform();
XsltArgumentList xslArguments;
StringBuilder sbEmail;
XmlTextWriter xmlWriter;
XmlNode xmlNodeTitle;
XmlDocument xmlEmail;
XsltSettings settings = new XsltSettings(true, true);
XmlUrlResolver resolver = new XmlUrlResolver();
string subject = string.Empty;
try
{
xslEmailTransform.Load(new XmlTextReader(xslt, XmlNodeType.Document, null), settings, resolver);
xmlDoc = new XmlDocument();
xmlDoc.AppendChild(xmlDoc.CreateElement("DocumentRoot"));
xpathNavigator = xmlDoc.CreateNavigator();
xslArguments = new XsltArgumentList();
if (xslValues != null)
{
foreach (DictionaryEntry xslEntry in xslValues)
{
xslArguments.AddExtensionObject(xslEntry.Key.ToString(), xslEntry.Value);
}
}
sbEmail = new StringBuilder();
xmlWriter = new XmlTextWriter(new StringWriter(sbEmail));
xslEmailTransform.Transform(xpathNavigator, xslArguments, xmlWriter);
xmlEmail = new XmlDocument();
xmlEmail.LoadXml(sbEmail.ToString());
xmlNodeTitle = xmlEmail.SelectSingleNode("//title");
subject = xmlNodeTitle.InnerText;
return SendEmail(web, emailTo, subject, sbEmail.ToString());
}
catch (Exception ex)
{
Utils.LogError(ex);
return false;
}
}
private void openToolStripMenuItem_Click(object sender, EventArgs e)
{
OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter = "xml files (*.xml)|*.xml|All files (*.*)|*.*";
if (dialog.ShowDialog() == DialogResult.OK)
{
XmlDataDocument xmldoc = new XmlDataDocument();
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreWhitespace = true;
settings.ProhibitDtd = false;
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
settings.XmlResolver = resolver;
XmlReader render = XmlReader.Create(dialog.FileName, settings);
try
{
try
{
xmldoc.Load(render);
}
catch (Exception ex)
{
MessageBox.Show(this, ex.Message, "Parse Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
finally
{
render.Close();
}
GridBuilder builder = new GridBuilder();
if (xmlGrid.ShowColumnHeader)
{
GridCellGroup xmlgroup = new GridCellGroup();
xmlgroup.Flags = GroupFlags.Overlapped | GroupFlags.Expanded;
builder.ParseNodes(xmlgroup, null, xmldoc.ChildNodes);
GridCellGroup root = new GridCellGroup();
root.Table.SetBounds(1, 2);
root.Table[0, 0] = new GridHeadLabel();
root.Table[0, 0].Text = dialog.FileName;
root.Table[0, 1] = xmlgroup;
xmlGrid.Cell = root;
}
else
{
GridCellGroup root = new GridCellGroup();
builder.ParseNodes(root, null, xmldoc.ChildNodes);
xmlGrid.Cell = root;
}
}
}
private void Init (HttpContext context) {
AppSettings baseXslt = new AppSettings();
String xsltUri = context.Server.MapPath(baseXslt.GetSetting("baseTemplate"));
Uri xUri = new Uri(xsltUri);
this._Resolver = new XmlUrlResolver();
this._Resolver.Credentials = CredentialCache.DefaultCredentials;
this._TemplateStream = (Stream)this._Resolver.GetEntity(xUri, null, typeof(Stream));
this._Processor = new Processor();
this._Compiler = _Processor.NewXsltCompiler();
this._Compiler.BaseUri = xUri;
this._Template = this._Compiler.Compile(_TemplateStream);
this._IS_INITIALIZED = true;
}
/// <summary>
/// Transform data.
/// </summary>
/// <param name="xmlData"> The xml data to load.</param>
/// <param name="stylesheet"> The style sheet data to load.</param>
/// <returns> A string containing the html report.</returns>
public string TransformFromData(string xmlData, string stylesheet)
{
// new XmlDocument, adds a xml using GetXml()
XmlDocument root = new XmlDocument();
root.LoadXml(xmlData);
XPathNavigator nav = root.CreateNavigator();
// xml resolver
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials=System.Net.CredentialCache.DefaultCredentials;
// evidence
//Evidence ev = XmlSecureResolver.CreateEvidenceForUrl(stylesheet);
StringWriter output = null;
XmlTextReader reader = null;
try
{
// XmlReader
//StreamReader stm = new StreamReader(st,System.Text.Encoding.Default);
StringReader sreader = new StringReader(stylesheet);
reader = new XmlTextReader(sreader);
XslTransform xslt = new XslTransform();
output = new StringWriter();
// load
xslt.Load(reader, resolver, null);
// transform
xslt.Transform(nav,null,output,resolver);
return output.ToString();
}
catch
{
throw;
}
finally
{
if ( output != null )
output.Close();
if ( reader != null )
reader.Close();
}
}
public void ProcessRequest(HttpContext context) {
_requestMethod = context.Request.HttpMethod;
_writer = context.Response.Output;
_context = context;
_processor = (Processor)context.Application["processor"];
_compiler = (XsltCompiler)context.Application["compiler"];
_serializer = (Serializer)context.Application["serializer"];
_resolver = (XmlUrlResolver)context.Application["resolver"];
_globalXsltParams = (Hashtable)context.Application["globalXsltParams"];
_sessionXsltParams = (Hashtable)context.Application["sessionXsltParams"];
_requestXsltParams = (Hashtable)context.Application["requestXsltParams"];
Hashtable xsltParams = new Hashtable();
foreach (DictionaryEntry param in _globalXsltParams) {
xsltParams[param.Key] = param.Value;
}
foreach (DictionaryEntry param in _sessionXsltParams) {
xsltParams[param.Key] = param.Value;
}
foreach (DictionaryEntry param in _requestXsltParams) {
xsltParams[param.Key] = param.Value;
}
_transformContext = new Context(context, _processor, _compiler, _serializer, _resolver, xsltParams);
switch (_requestMethod) {
case "GET": {
new Transform().Process(_transformContext);
break;
}
case "PUT": {
new Transform().Process(_transformContext);
break;
}
case "POST": {
new Transform().Process(_transformContext);
break;
}
case "DELETE": {
new Transform().Process(_transformContext);
break;
}
default: {
new Transform().Process(_transformContext);
break;
}
}
}
public Form1()
{
InitializeComponent();
XmlUrlResolver resolver = new XmlUrlResolver();
Uri myUri = new Uri("http://dgcsc.org/goldprices.xml");
Stream s = (Stream)resolver.GetEntity(myUri, null, typeof(Stream));
// Construct a reader using the Stream object.
XmlTextReader xmlTextReader = new XmlTextReader(s);
XmlDataDocument xdoc1 = new XmlDataDocument();
xdoc1.DataSet.ReadXml(xmlTextReader, XmlReadMode.Auto);
DataSet ds = xdoc1.DataSet;
//DataTable dt = ds;
dataGridView1.DataSource = ds.Tables[1];
}
public static XmlDocument GetXmlDocument(string url, ICredentials credentials)
{
XmlUrlResolver resolver = new XmlUrlResolver
{
Credentials = credentials ?? CredentialCache.DefaultCredentials
};
XmlReaderSettings settings = new XmlReaderSettings { XmlResolver = resolver };
XmlReader reader = XmlReader.Create(url, settings);
XmlDocument document = new XmlDocument();
document.Load(reader);
return document;
}
//--- Class Methods ---
private static void Main() {
var config = Config.NewConfig(Path.Combine(Location, "config.xml"));
Console.WriteLine("BUILDING: Setting assembly name to " + ASSEMBLY_NAME);
var assembly = new AssemblyName {
Name = ASSEMBLY_NAME
};
if(config.Version != null) {
Console.WriteLine("BUILDING: Setting assembly version to " + config.Version);
assembly.Version = config.Version;
}
var assemblyFile = assembly.Name + ".dll";
var assemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(assembly, AssemblyBuilderAccess.Save);
_moduleBuilder = assemblyBuilder.DefineDynamicModule(assembly.Name, assemblyFile);
var xsltReaderSettings = new XmlReaderSettings { ProhibitDtd = false };
var resolver = new XmlUrlResolver();
foreach(var xslt in config.Xslts) {
try {
if(!string.IsNullOrEmpty(xslt.EmbedPath)) {
Console.WriteLine(string.Format("BUILDING ({0}): Embedding resources", xslt.Id));
EmbedResources(xslt);
}
var type = NAMESPACE + xslt.Type;
Console.WriteLine(string.Format("BUILDING ({0}): Defining type {1}", xslt.Id, type));
var typeBuilder = _moduleBuilder.DefineType(type, TypeAttributes.Public | TypeAttributes.Class);
var xsl = PathUtil.GetNormalizedFilename(Path.Combine(Location, xslt.XslPath));
var xsltReader = XmlReader.Create(xsl, xsltReaderSettings);
var xsltSettings = new XsltSettings { EnableDocumentFunction = true };
Console.WriteLine(string.Format("BUILDING ({0}): Compiling xslt", xslt.Id));
XslCompiledTransform.CompileToType(xsltReader, xsltSettings, resolver, false, typeBuilder, null);
} catch {
CleanUp();
throw;
}
}
Console.WriteLine("BUILDING: Setting assembly title attribute");
SetAssemblyAttribute(assemblyBuilder, typeof(AssemblyTitleAttribute), assembly.Name);
Console.WriteLine("BUILDING: Setting assembly product attribute");
SetAssemblyAttribute(assemblyBuilder, typeof(AssemblyProductAttribute), assembly.Name);
Console.WriteLine("BUILDING: Setting assembly company attribute");
SetAssemblyAttribute(assemblyBuilder, typeof(AssemblyCompanyAttribute), "MindTouch, Inc.");
Console.WriteLine("BUILDING: Setting assembly copyright attribute");
SetAssemblyAttribute(assemblyBuilder, typeof(AssemblyCopyrightAttribute), "Copyright (c) 2006-2012");
Console.WriteLine(string.Format("BUILDING: Saving assembly {0}", assemblyFile));
assemblyBuilder.Save(assemblyFile);
Console.WriteLine("BUILDING: Cleaning up");
CleanUp();
}
/// <summary>
/// Gets XmlResolver - default or custom, with user credentials or not.
/// </summary>
/// <param name="credentials">User credentials</param>
/// <param name="options">Parsed command line options</param>
public static XmlResolver GetXmlResolver(NetworkCredential credentials, NXsltOptions options, bool prohibitDTD)
{
XmlResolver resolver;
Type resolverType;
if (options.ResolverTypeName != null)
{
//Custom resolver
try
{
resolverType = TypeUtils.FindType(options, options.ResolverTypeName);
}
catch (Exception e)
{
throw new NXsltException(NXsltStrings.ErrorCreateResolver, options.ResolverTypeName, e.Message);
}
if (!typeof(XmlResolver).IsAssignableFrom(resolverType))
{
//Type is not XmlResolver
throw new NXsltException(NXsltStrings.ErrorTypeNotXmlResolver, options.ResolverTypeName);
}
try
{
resolver = (XmlResolver)Activator.CreateInstance(resolverType);
}
catch (Exception e)
{
throw new NXsltException(NXsltStrings.ErrorCreateResolver, options.ResolverTypeName, e.Message);
}
}
else
{
if (prohibitDTD)
{
resolver = new XmlUrlResolver();
}
else
{
resolver = new DTDAllowingResolver();
}
}
//Set credentials if any
if (credentials != null)
{
resolver.Credentials = credentials;
}
return resolver;
}
public static void TransformXML()
{
// Create a resolver with default credentials.
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = System.Net.CredentialCache.DefaultCredentials;
// transform the personnel.xml file to HTML
XslTransform transform = new XslTransform();
// load up the stylesheet
transform.Load(@"C:\Users\Usuario\Desktop\SVN\PDV\DLL\2.xsl", resolver);
// perform the transformation
transform.Transform(@"C:\temp\100.xml", @"C:\temp\Personnel.html", resolver);
// transform the personnel.xml file to comma delimited format
// load up the stylesheet
// transform.Load(@"..\PersonnelCSV.xsl", resolver);
// perform the transformation
// transform.Transform(@"..\Personnel.xml", @"..\Personnel.csv", resolver);
}
public void Convert(string inputfile, string outputfile)
{
// loads the input file
XmlDocument input = GetInputFile (inputfile);
// generates the output
XmlTextWriter output = outputfile==null
? new XmlTextWriter(Console.Out)
: new XmlTextWriter(
outputfile, Encoding.GetEncoding("ISO-8859-15"));
output.Formatting = Formatting.Indented;
System.Security.Policy.Evidence evidence = outputfile==null
? null : XmlSecureResolver.CreateEvidenceForUrl("file://" + outputfile);
XmlResolver res = new XmlUrlResolver ();
XslTransform xslt = GetXslt (input, evidence, res);
xslt.Transform(input, new XsltArgumentList (), output, res);
output.WriteRaw(System.Environment.NewLine);
}
public XsltTransformationManager
(
Processor processor,
Transform transform,
XmlUrlResolver resolver,
Serializer serializer,
Hashtable xsltHashtable,
Hashtable xmlSourceHashtable,
Hashtable xdmNodeHashtable,
Hashtable namedXsltHashtable,
Hashtable namedXsltETagIndex,
Hashtable xdmNodeETagIndex,
Uri baseXsltUri,
String baseXsltUriHash,
String baseXsltName
)
{
_baseXsltUri = baseXsltUri;
_baseXsltUriHash = baseXsltUriHash;
_baseXsltName = baseXsltName;
_transform = transform;
_xsltHashtable = xsltHashtable;
_processor = processor;
_compiler = _processor.NewXsltCompiler();
_sourceHashtable = xmlSourceHashtable;
_resolver = resolver;
_compiler.XmlResolver = _resolver;
_builder = _processor.NewDocumentBuilder();
_serializer = serializer;
_xdmNodeHashtable = xdmNodeHashtable;
_xdmNodeETagIndex = xdmNodeETagIndex;
_namedXsltHashtable = namedXsltHashtable;
_namedXsltETagIndex = namedXsltETagIndex;
_hashAlgorithm = HashAlgorithm.SHA1;
//NOTE: TransformEngine enum PLACEHOLDER FOR FUTURE USE
_transformEngine = TransformEngine.SAXON;
}
public void BuildNavigator(string modelFilePath)
{
XmlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
XmlDocument doc = new XmlDocument();
doc.XmlResolver = resolver;
doc.Load(modelFilePath);
XslTransform transform = new XslTransform();
transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "ModelTree.xsl",resolver);
StreamWriter sw = new StreamWriter(this.htmlFilesPath + Path.DirectorySeparatorChar + "ModelTree.htm",false);
XsltArgumentList al = new XsltArgumentList();
al.AddParam("modelBrowser","",this.localizer.GetValue("Globals","ModelBrowser"));
al.AddParam("glossary","",this.localizer.GetValue("Globals","Glossary"));
transform.Transform(doc,al,sw,null);
sw.Close();
transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "HomePage.xsl",resolver);
sw = new StreamWriter(this.htmlFilesPath + Path.DirectorySeparatorChar + "main.htm",false);
al = new XsltArgumentList();
AssemblyName an = this.GetType().Assembly.GetName();
al.AddParam("version","",an.Version.ToString(3));
transform.Transform(doc,al,sw,null);
sw.Close();
}
/// <summary>
/// Pres the process.
/// </summary>
/// <param name="input">The input.</param>
/// <param name="output">The output.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="inputUri">The input_uri.</param>
/// <returns></returns>
/// <remarks></remarks>
public PreprocessorEnvironment PreProcess(XmlReader input, XmlWriter output,
XmlUrlResolver resolver, Uri inputUri)
{
// The base URI is needed to resolve includes of relative paths, as well as to generate
// error messages.
// If none is given explicitly, try to use the XmlReader's BaseUri.
// If that doesn't exist either, use the current working directory and a fake filename.
Uri base_uri = inputUri ??
( String.IsNullOrEmpty( input.BaseURI )
? new Uri(
Path.Combine(
Environment.CurrentDirectory,
"nofile.xml" ) )
: new Uri( input.BaseURI ) );
// Create the environment
_env = new PreprocessorEnvironment( _settings, base_uri, resolver );
// Load the input document
XDocument doc = XDocument.Load( input, LoadOptions.PreserveWhitespace | LoadOptions.SetBaseUri | LoadOptions.SetLineInfo );
// Process the input document's nodes and write the results to the output stream
foreach ( XNode out_node in
doc.Nodes().SelectMany(
node => _env._DefaultNodeProcessor.Process( node ) ).Where( node => !(node is XText)) )
{
out_node.WriteTo( output );
}
// Notify listeners of all files encountered.
if (SubfileLoaded != null)
{
foreach (Uri path in _env.Fileset)
{
SubfileLoaded( path );
}
}
return _env;
}
public XsltTransformationManager
(
Processor processor,
Transform transform,
XmlUrlResolver resolver,
Serializer serializer,
Dictionary<string, XsltTransformer> xsltHashtable,
Hashtable xmlSourceHashtable,
Hashtable xdmNodeHashtable,
Hashtable namedXsltHashtable,
Hashtable namedXsltETagIndex,
Hashtable xdmNodeETagIndex,
Uri baseXsltUri,
String baseXsltUriHash,
String baseXsltName
) {
m_baseXsltUri = baseXsltUri;
m_baseXsltUriHash = baseXsltUriHash;
m_baseXsltName = baseXsltName;
m_transform = transform;
m_xsltHashtable = xsltHashtable;
m_processor = processor;
m_compiler = m_processor.NewXsltCompiler();
m_sourceHashtable = xmlSourceHashtable;
m_resolver = resolver;
m_compiler.XmlResolver = m_resolver;
m_builder = m_processor.NewDocumentBuilder();
m_serializer = serializer;
m_xdmNodeHashtable = xdmNodeHashtable;
m_xdmNodeETagIndex = xdmNodeETagIndex;
m_namedXsltHashtable = namedXsltHashtable;
m_namedXsltETagIndex = namedXsltETagIndex;
m_hashAlgorithm = HashAlgorithm.MD5;
//NOTE: TransformEngine enum PLACEHOLDER FOR FUTURE USE
m_transformEngine = TransformEngine.SAXON;
}
static void Main(string[] args)
{
Console.WriteLine("Demo1:\n");
XslCompiledTransform trans = new XslCompiledTransform();
trans.Load(@"..\..\books.xsl");
trans.Transform(@"..\..\books.xml", "out.html");
Console.WriteLine("Your Demo:\n");
// Create a resolver with default credentials.
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = System.Net.CredentialCache.DefaultCredentials;
// transform the personnel.xml file to HTML
XslTransform transform = new XslTransform();
// load up the stylesheet
transform.Load(@"..\..\PersonnelHTML.xsl", resolver);
// perform the transformation
transform.Transform(@"..\..\Personnel.xml", @"Personnel.html", resolver);
// transform the personnel.xml file to comma delimited format
// load up the stylesheet
transform.Load(@"..\..\PersonnelCSV.xsl", resolver);
// perform the transformation
transform.Transform(@"..\..\Personnel.xml", @"Personnel1.csv", resolver);
}
public static string GetXmlString(string stylesheet, string xmlstring, List<XsltExtensionParam> listExtensionParam,
bool enableDocumentFunction, bool enableScript)
{
MvpXslTransform xslt = new MvpXslTransform();
string text = string.Empty;
try {
using (XmlReader strm = XmlReader.Create(new MemoryStream(ASCIIEncoding.Default.GetBytes(stylesheet)))) {
if (enableDocumentFunction && enableScript) {
XsltSettings xslSettings = new XsltSettings(enableDocumentFunction, enableScript);
XmlResolver xmlResolver = new XmlUrlResolver();
xslt.Load(strm, xslSettings, xmlResolver);
} else if (enableDocumentFunction && !enableScript) {
XsltSettings xslSettings = new XsltSettings(enableDocumentFunction, false);
XmlResolver xmlResolver = new XmlUrlResolver();
xslt.Load(strm, xslSettings, xmlResolver);
} else {
xslt.Load(strm);
}
}
using (TextReader stringReader = new StringReader(xmlstring)) {
XPathDocument mydata = new XPathDocument(stringReader);
XmlInput a = new XmlInput(mydata);
using (TextWriter txtWriter = new StringWriter()) {
XsltArgumentList b = new XsltArgumentList();
foreach (XsltExtensionParam oep in listExtensionParam) {
b.AddExtensionObject(oep.Namespace, oep.Object);
}
xslt.Transform(a, b, new XmlOutput(txtWriter));
text = txtWriter.ToString();
}
}
} catch (Exception ex) {
}
return text;
}
internal DTDValidatingReader (XmlReader reader,
XmlValidatingReader validatingReader)
{
this.reader = new EntityResolvingXmlReader (reader);
this.sourceTextReader = reader as XmlTextReader;
elementStack = new Stack ();
automataStack = new Stack ();
attributes = new AttributeSlot [10];
nsmgr = new XmlNamespaceManager (reader.NameTable);
this.validatingReader = validatingReader;
valueBuilder = new StringBuilder ();
idList = new ArrayList ();
missingIDReferences = new ArrayList ();
XmlTextReader xtReader = reader as XmlTextReader;
if (xtReader != null) {
resolver = xtReader.Resolver;
}
else
resolver = new XmlUrlResolver ();
}
[Test] // bug #998
public void NullAbsoluteUriWithCustomSchemedRelativeUri ()
{
XmlResolver res = new XmlUrlResolver ();
var uri = res.ResolveUri (null, "view:Standard.xslt");
Assert.AreEqual ("view", uri.Scheme, "#1");
Assert.AreEqual ("Standard.xslt", uri.AbsolutePath, "#2");
Assert.AreEqual ("view:Standard.xslt", uri.AbsoluteUri, "#2");
}
public void GetReady ()
{
resolver = new XmlUrlResolver ();
}
internal XmlReader AddValidation(XmlReader reader)
{
if (_validationType == ValidationType.Schema)
{
XmlResolver resolver = GetXmlResolver_CheckConfig();
if (resolver == null &&
!this.IsXmlResolverSet &&
!EnableLegacyXmlSettings())
{
resolver = new XmlUrlResolver();
}
reader = new XsdValidatingReader(reader, resolver, this);
}
else if (_validationType == ValidationType.DTD)
{
reader = CreateDtdValidatingReader(reader);
}
return reader;
}
