private static bool IsEqual(XmlAttributeCollection left, XmlAttributeCollection right)
{
if (left == null)
{
return right == null;
}
if (right == null)
{
return false;
}
if (left.Count != right.Count)
{
return false;
}
foreach (XmlAttribute attr in left)
{
var rightAttrNode = right.GetNamedItem(attr.Name);
if (rightAttrNode == null)
{
return false;
}
if ((rightAttrNode as XmlAttribute).Value != attr.Value)
{
return false;
}
}
return true;
}
public static string GetAttribute(XmlAttributeCollection attributes, string name)
{
XmlNode attr = attributes.GetNamedItem(name);
if (attr == null)
return "";
return attr.Value;
}
/// <summary>
/// Gets float value from XML attribute
/// </summary>
/// <param name="name"></param>
/// <param name="attrs"></param>
/// <param name="value_default"></param>
/// <returns></returns>
public static float GetFloatAttributeValue(string name, XmlAttributeCollection attrs, float value_default)
{
float r = value_default;
try{
XmlNode attr = attrs.GetNamedItem(name);
if (attr != null)
{
r = (float)Convert.ToDouble(attr.Value);
}
}catch(Exception ex){
Console.WriteLine("Error 'GetFloatAttributeValue' ["+name+"]-> "+ex.Message );
}
return r;
}
public virtual void RemoveAttribute(string localName, string namespaceURI)
{
if (attributes == null)
{
return;
}
XmlAttribute attr = attributes.GetNamedItem(localName, namespaceURI) as XmlAttribute;
if (attr != null)
{
Attributes.Remove(attr);
}
}
/// <summary>
/// Gets int value from XML attribute
/// </summary>
/// <param name="name"></param>
/// <param name="attrs"></param>
/// <param name="value_default"></param>
/// <returns></returns>
public static int GetIntAttributeValue(string name, XmlAttributeCollection attrs, int value_default)
{
int r = value_default;
try{
XmlNode attr = attrs.GetNamedItem(name);
if (attr != null)
{
r = Convert.ToInt32(attr.Value);
}
}catch(Exception ex){
Console.WriteLine("Error 'GetIntAttributeValue' -> ["+name+"]"+ex.Message );
}
return r;
}
/// <summary>
/// Gets string value from XML attribute
/// </summary>
/// <param name="name"></param>
/// <param name="attrs"></param>
/// <param name="value_default"></param>
/// <returns></returns>
public static string GetAttributeValue(string name, XmlAttributeCollection attrs, string value_default)
{
string r = value_default;
try{
XmlNode attr = attrs.GetNamedItem(name);
if (attr != null)
{
r = attr.Value;
//Console.WriteLine(name + ": " + r);
}
}catch(Exception ex){
Console.WriteLine("Error 'GetAttributeValue' ["+name+"]-> "+ex.Message );
}
return r;
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Interpret the use attribute as a FunctionValues value
/// </summary>
/// <param name="attributes">Collection of attributes that better have a "use"
/// attribute</param>
/// <param name="styleName">Stylename being processed (for error reporting purposes)
/// </param>
/// <returns>The function of the style</returns>
/// -------------------------------------------------------------------------------------
private FunctionValues GetFunction(XmlAttributeCollection attributes,
string styleName)
{
if (m_htReservedStyles.ContainsKey(styleName))
{
return m_htReservedStyles[styleName].function;
}
XmlNode node = attributes.GetNamedItem("use");
string sFunction = (node != null) ? node.Value : null;
if (sFunction == null)
return FunctionValues.Prose;
switch (sFunction)
{
case "prose":
case "proseSentenceInitial":
case "title":
case "properNoun":
case "special":
return FunctionValues.Prose;
case "line":
case "lineSentenceInitial":
return FunctionValues.Line;
case "list":
return FunctionValues.List;
case "table":
return FunctionValues.Table;
case "chapter":
return FunctionValues.Chapter;
case "verse":
return FunctionValues.Verse;
case "footnote":
return FunctionValues.Footnote;
case "stanzabreak":
return FunctionValues.StanzaBreak;
default:
Debug.Assert(false, "Unrecognized use attribute for style " + styleName +
" in " + ResourceFileName + ": " + sFunction);
throw new Exception(ResourceHelper.GetResourceString("kstidInvalidInstallation"));
}
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Returns a writing system ID from the named attribute
/// </summary>
/// <param name="attributes">collection of XML attributes for current tag</param>
/// <param name="attrName">name of the attribute</param>
/// <param name="defaultVal">a default to be used if no value present in the XML</param>
/// <returns>the writing system ID integer</returns>
/// -------------------------------------------------------------------------------------
protected int GetWritingSystem(XmlAttributeCollection attributes,
string attrName, int defaultVal)
{
XmlNode WsAttrib = attributes.GetNamedItem(attrName);
int wsResult;
if (WsAttrib != null && WsAttrib.Value != string.Empty)
{
ILgWritingSystemFactory wsf = m_scr.Cache.LanguageWritingSystemFactoryAccessor;
wsResult = wsf.GetWsFromStr(WsAttrib.Value);
if (wsResult != 0)
return wsResult;
else
{
// Unlike other "getAttribute" methods, this one may encounter a WS
// that is not installed yet.
//REVIEW: For now we will not throw an exception,
// but try to give a meaningful message and return the default.
string message;
//#if DEBUG
message = "Error reading TePublications.xml: Unrecognized writing system attribute: "
+ attrName + "=\"" + WsAttrib.Value + "\"" + "\n Default writing system will be used.";
//#else
// message = TeResourceHelper.GetResourceString("kstidInvalidInstallation");
//#endif
if (m_fUnderTest)
{
//throw new Exception(message);
Debug.WriteLine(message);
}
else
{
MessageBox.Show(message,
"FieldWorks", // better caption?
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
return defaultVal;
}
}
else
return defaultVal;
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Retrieves the measurement units for publications and returns a multiplier for
/// converting into millipoints.
/// </summary>
/// <param name="attributes">collection of XML attributes for current tag</param>
/// <param name="attrName">name of the attribute</param>
/// <param name="defaultVal">a default conversion factor, to be used if the specified
/// attribute is not present in the XML</param>
/// <returns>the multiplier for converting into millipoints</returns>
/// -------------------------------------------------------------------------------------
protected double GetUnitConversion(XmlAttributeCollection attributes, string attrName,
double defaultVal)
{
XmlNode measUnitsNode = attributes.GetNamedItem(attrName);
if (measUnitsNode != null)
{
string sMeasUnits = measUnitsNode.Value;
switch (sMeasUnits.ToLowerInvariant())
{
case "inch":
return kMpPerInch;
case "cm":
return kMpPerCm;
default:
{
string message;
#if DEBUG
message = "Error reading TePublications.xml: Unrecognized units for "
+ attrName + "=\"" + measUnitsNode.Value + "\"";
#else
message = TeResourceHelper.GetResourceString("kstidInvalidInstallation");
#endif
throw new Exception(message);
}
}
}
else
return defaultVal;
}
private string getValueAtributo(XmlAttributeCollection coleccion, string valor)
{
XmlNode atributoDecisor = coleccion.GetNamedItem(_prefijo + ":" + valor);
if (atributoDecisor != null)
{
return atributoDecisor.Value;
}
else
return "";
}
private static string ExtractAttributeValueFromNode(string attributeName, XmlAttributeCollection attributes)
{
return attributes.GetNamedItem(attributeName) != null ? attributes.GetNamedItem(attributeName).Value : null;
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Interpret the type attribute as a StyleType value
/// </summary>
/// <param name="attributes">Collection of attributes that better have a "type"
/// attribute</param>
/// <param name="styleName">Stylename being processed (for error reporting purposes)
/// </param>
/// <param name="context"></param>
/// <returns>The type of the style</returns>
/// -------------------------------------------------------------------------------------
public StyleType GetType(XmlAttributeCollection attributes, string styleName,
ContextValues context)
{
if (m_htReservedStyles.ContainsKey(styleName))
return m_htReservedStyles[styleName].styleType;
string sType = attributes.GetNamedItem("type").Value;
ValidateContext(context, styleName);
switch(sType)
{
case "paragraph":
ValidateParagraphContext(context, styleName);
return StyleType.kstParagraph;
case "character":
return StyleType.kstCharacter;
default:
Debug.Assert(false, "Unrecognized type attribute for style " + styleName +
" in " + ResourceFileName + ": " + sType);
throw new Exception(ResourceHelper.GetResourceString("kstidInvalidInstallation"));
}
}
/// <summary>
/// Separates XML namespace related attributes from "normal"
/// attributes.
/// </summary>
private static Attributes SplitAttributes(XmlAttributeCollection map)
{
XmlAttribute sLoc = map.GetNamedItem("schemaLocation",
XmlSchema.InstanceNamespace)
as XmlAttribute;
XmlAttribute nNsLoc = map.GetNamedItem("noNamespaceSchemaLocation",
XmlSchema.InstanceNamespace)
as XmlAttribute;
List<XmlAttribute> rest = new List<XmlAttribute>();
foreach (XmlAttribute a in map) {
if (XmlSchema.InstanceNamespace != a.NamespaceURI
&&
"http://www.w3.org/2000/xmlns/" != a.NamespaceURI) {
rest.Add(a);
}
}
return new Attributes(sLoc, nNsLoc, rest);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Returns the integer value from the named attribute.
/// If named item is not present, the default value is returned.
/// </summary>
/// <param name="attributes">collection of XML attributes for current tag</param>
/// <param name="attrName">name of the attribute</param>
/// <param name="defaultVal">The default value.</param>
/// <returns>the integer value, or null</returns>
/// ------------------------------------------------------------------------------------
protected static int GetInt(XmlAttributeCollection attributes, string attrName,
int defaultVal)
{
XmlNode attrib = attributes.GetNamedItem(attrName);
if (attrib != null && attrib.Value != string.Empty)
{
try
{
return System.Int32.Parse(attrib.Value);
}
catch
{
string message;
#if DEBUG
message = "Error reading TePublications.xml: Unrecognized integer attribute: "
+ attrName + "=\"" + attrib.Value + "\"";
#else
message = TeResourceHelper.GetResourceString("kstidInvalidInstallation");
#endif
throw new Exception(message);
}
}
else
return defaultVal;
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Returns the string value from the named attribute.
/// If named item is not present, null is returned.
/// </summary>
/// <param name="attributes">collection of XML attributes for current tag</param>
/// <param name="attrName">name of the attribute</param>
/// <returns>the string value, or null</returns>
/// -------------------------------------------------------------------------------------
protected static string GetString(XmlAttributeCollection attributes, string attrName)
{
XmlNode attrib = attributes.GetNamedItem(attrName);
if (attrib != null)
return attrib.Value;
else
return null;
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Retrieves the specified measurement attribute and computes the value in millipoints
/// </summary>
/// <param name="attributes">collection of XML attributes for current tag</param>
/// <param name="attrName">name of the attribute</param>
/// <param name="defaultVal">a default measurement in millipoints, to be used if
/// no value is present in the XML</param>
/// <param name="conversion">multiplier (based on the publication units) to convert
/// retrieved value into millipoints</param>
/// <returns>the integer measurement in millipoints from the named item</returns>
/// -------------------------------------------------------------------------------------
private int GetMeasurement(XmlAttributeCollection attributes, string attrName,
int defaultVal, double conversion)
{
double measurementInSourceUnits;
XmlNode measurementAttrib = attributes.GetNamedItem(attrName);
if (measurementAttrib != null && measurementAttrib.Value != string.Empty)
{
try
{
// Always read measurements with "en" culture because they have been formatted
// in that way.
measurementInSourceUnits = Double.Parse(measurementAttrib.Value,
CultureInfo.CreateSpecificCulture("en"));
}
catch
{
string message;
#if DEBUG
message = "Error reading TePublications.xml: Unrecognized measurement for "
+ attrName + "=\"" + measurementAttrib.Value + "\"";
#else
message = TeResourceHelper.GetResourceString("kstidInvalidInstallation");
#endif
throw new Exception(message);
}
}
else
return defaultVal;
return (int)(measurementInSourceUnits * conversion);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets the height and width of the page.
/// </summary>
/// <param name="attributes">collection of XML attributes for current tag</param>
/// <param name="pub">The publication object in which the height and width are to be
/// stored.</param>
/// <param name="supportedPubPageSizes">The supported publication page sizes.</param>
/// ------------------------------------------------------------------------------------
private void GetPageHeightAndWidth(XmlAttributeCollection attributes, IPublication pub,
XmlNode supportedPubPageSizes)
{
XmlNode pageSize = attributes.GetNamedItem("PageSize");
if (pageSize != null)
{
string sPageSize = pageSize.Value;
try
{
XmlNode pubPageSize =
supportedPubPageSizes.SelectSingleNode("PublicationPageSize[@id='" + sPageSize + "']");
pub.PageHeight = GetMeasurement(pubPageSize.Attributes, "Height", 0, m_conversion);
pub.PageWidth = GetMeasurement(pubPageSize.Attributes, "Width", 0, m_conversion);
}
catch
{
#if DEBUG
throw new Exception("Error reading TePublications.xml: Problem reading PageSize. value was \"" +
sPageSize + "\"");
#else
pub.PageHeight = 0;
pub.PageWidth = 0;
#endif
}
}
else
{
pub.PageHeight = 0;
pub.PageWidth = 0;
}
}
/// <summary>
/// This function gets called by the ogmo level loader
/// </summary>
public static void MyCreateEntity(Scene scene, XmlAttributeCollection ogmoParameters)
{
//ok ogmo gives us the position in x and y, and the list of decorators in DecoratorList
int x = ogmoParameters.Int("x", -1);
int y = ogmoParameters.Int("y", -1);
//this is how you read a string from ogmo
string decoList = ogmoParameters.GetNamedItem("DecoratorList").Value;
//create an instance
Tank t = new Tank(x, y);
//try and load an id; if there is none, the id will be -1
t.NetworkId = ogmoParameters.Int("NetworkId", -1);
//add to the scene because the decorators need that
scene.Add(t);
//split the decorators; they are seperated by a ":" in the DecoratorList string
string[] decoArray = decoList.Split(':');
//add each decorator
foreach (string decoratorName in decoArray)
{
//parse the name of the decorator to the decorator-enum, and then add to the tank
t.AddDecorator((Decorators) Enum.Parse(typeof(Decorators), decoratorName));
}
}
private bool GetValue(XmlAttributeCollection amlAttributes, string nodeName, out string value)
{
XmlNode xmlNode = amlAttributes.GetNamedItem(nodeName);
if (xmlNode == null)
{
value = "";
return false;
}
string xmlValue = xmlNode.Value;
value = xmlValue.Trim();
return value == "" ? false : true;
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Get the ws value (hvo) from the wsId contained in the given attributes
/// </summary>
/// <param name="attribs">Collection of attributes that better have an "wsId"
/// attribute</param>
/// <returns></returns>
/// -------------------------------------------------------------------------------------
private int GetWs(XmlAttributeCollection attribs)
{
string wsId = attribs.GetNamedItem("wsId").Value;
if (string.IsNullOrEmpty(wsId))
return 0;
return Cache.ServiceLocator.WritingSystemManager.GetWsFromStr(wsId);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Interprets a given attribute as a boolean value
/// </summary>
/// <param name="attributes">Collection of attributes to look in</param>
/// <param name="sAttrib">Named attribute</param>
/// <param name="styleName">The name of the style to which this attribute pertains (used
/// only for debug error reporting)</param>
/// <param name="fileName">Name of XML file (for error reporting)</param>
/// <returns>true if attribute value is "yes" or "true"</returns>
/// ------------------------------------------------------------------------------------
static public bool GetBoolAttribute(XmlAttributeCollection attributes, string sAttrib,
string styleName, string fileName)
{
string sVal = attributes.GetNamedItem(sAttrib).Value;
if (sVal == "yes" || sVal == "true")
return true;
else if (sVal == "no" || sVal == "false" || sVal == String.Empty)
return false;
ReportInvalidInstallation(String.Format(
FrameworkStrings.ksUnknownStyleAttribute, sAttrib, styleName, fileName));
return false; // Can't actually get here, but don't tell the compiler that!
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Get the ws value (hvo) from the iculocale contained in the given attributes
/// </summary>
/// <param name="attribs">Collection of attributes that better have an "iculocale"
/// attribute</param>
/// <returns></returns>
/// -------------------------------------------------------------------------------------
private int GetWs(XmlAttributeCollection attribs)
{
string iculocale = attribs.GetNamedItem("iculocale").Value;
if (iculocale == null || iculocale == string.Empty)
return 0;
int ws = 0;
if (!m_htIcuToWs.TryGetValue(iculocale, out ws))
{
ws = m_scr.Cache.LanguageEncodings.GetWsFromIcuLocale(iculocale);
m_htIcuToWs[iculocale] = ws;
}
return ws;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Retrieves a valid TE style name from the specified attributes.
/// </summary>
/// <param name="attributes">The attributes containing the style id to use</param>
/// <returns>a valid TE style name</returns>
/// ------------------------------------------------------------------------------------
private static string GetStyleName(XmlAttributeCollection attributes)
{
return attributes.GetNamedItem("id").Value.Replace("_", " ");
}
private static void CompareAttributes(XmlAttributeCollection attribs1, XmlAttributeCollection attribs2,
string attribute)
{
var attr1 = attribs1.GetNamedItem(attribute);
var attr2 = attribs2.GetNamedItem(attribute);
Assert.IsFalse(attr1 == null && attr2 != null);
Assert.IsFalse(attr1 != null && attr2 == null);
if (attr1 != null)
Assert.AreEqual(attr1.Value, attr2.Value);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Interpret the based on attribute
/// </summary>
/// <param name="attributes">Collection of attributes that better have a "context"
/// attribute</param>
/// <param name="styleName">Stylename being processed (for error reporting purposes)
/// </param>
/// <returns>The name of the based-on style</returns>
/// ------------------------------------------------------------------------------------
private string GetBasedOn(XmlAttributeCollection attributes, string styleName)
{
if (m_htReservedStyles.ContainsKey(styleName))
{
return m_htReservedStyles[styleName].basedOn;
}
XmlNode basedOn = attributes.GetNamedItem("basedOn");
return (basedOn == null) ? null : basedOn.Value.Replace("_", " ");
}
private string getAttribute(XmlAttributeCollection theAttributes, string strName)
{
XmlNode anAttribute = theAttributes.GetNamedItem(strName);
if (anAttribute != null)
return anAttribute.Value;
else
return "";
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Interpret the context attribute as a ContextValues value
/// </summary>
/// <param name="attributes">Collection of attributes that better have a "context"
/// attribute</param>
/// <param name="styleName">Stylename being processed (for error reporting purposes)
/// </param>
/// <returns>The context of the style</returns>
/// -------------------------------------------------------------------------------------
private ContextValues GetContext(XmlAttributeCollection attributes,
string styleName)
{
if (m_htReservedStyles.ContainsKey(styleName))
{
return m_htReservedStyles[styleName].context;
}
string sContext = attributes.GetNamedItem("context").Value;
// EndMarker was left out of the original conversion and would have raised an exception.
if (sContext == "back") sContext = "BackMatter";
try
{ // convert the string to a valid enum case insensitive
return (ContextValues)Enum.Parse(typeof(ContextValues), sContext, true);
}
catch (Exception ex)
{
Debug.Assert(false, "Unrecognized context attribute for style " + styleName +
" in " + ResourceFileName + ": " + sContext);
throw new Exception(ResourceHelper.GetResourceString("kstidInvalidInstallation"));
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Compares the XML attributes.
/// </summary>
/// <param name="owningNodeName">The name of the owning node.</param>
/// <param name="expected">The expected attributes.</param>
/// <param name="actual">The actual attributes.</param>
/// <param name="strDifference">out: A string describing the difference in attributes.</param>
/// <returns>
/// <c>true</c> if the attributes are the same; <c>false</c> otherwise
/// </returns>
/// ------------------------------------------------------------------------------------
public static bool CompareXmlAttributes(string owningNodeName, XmlAttributeCollection expected,
XmlAttributeCollection actual, out string strDifference)
{
strDifference = string.Empty;
int expectedCount = (expected == null ? 0 : expected.Count);
int actualCount = (actual == null ? 0 : actual.Count);
if (expectedCount != actualCount)
{
strDifference = string.Format("Count of attributes different in node {0}. Expected {1} but was {2}",
owningNodeName, expectedCount, actualCount);
return false;
}
if (expectedCount == 0)
return true;
foreach (XmlAttribute expectedAttrib in expected)
{
XmlNode actualAttrib =
(actual != null ? actual.GetNamedItem(expectedAttrib.Name) : null);
if (actualAttrib == null)
{
strDifference = string.Format("Attribute {0} is missing.", expectedAttrib.Name);
return false;
}
if (expectedAttrib.InnerText != actualAttrib.InnerText)
{
strDifference = "Attributes are different for attribute " +
expectedAttrib.Name + ": " + Environment.NewLine +
" Expected: " + expectedAttrib.InnerText + Environment.NewLine +
" Actual: " + actualAttrib.InnerText;
return false;
}
}
strDifference = string.Empty;
return true;
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Interpret the use attribute as a StructureValues value
/// </summary>
/// <param name="attributes">Collection of attributes that better have a "structure"
/// attribute</param>
/// <param name="styleName">Stylename being processed (for error reporting purposes)
/// </param>
/// <returns>The structure of the style</returns>
/// -------------------------------------------------------------------------------------
private StructureValues GetStructure(XmlAttributeCollection attributes,
string styleName)
{
if (m_htReservedStyles.ContainsKey(styleName))
{
return m_htReservedStyles[styleName].structure;
}
XmlNode node = attributes.GetNamedItem("structure");
string sStructure = (node != null) ? node.Value : null;
if (sStructure == null)
return StructureValues.Undefined;
switch(sStructure)
{
case "heading":
return StructureValues.Heading;
case "body":
return StructureValues.Body;
default:
Debug.Assert(false, "Unrecognized structure attribute for style " + styleName +
" in " + ResourceFileName + ": " + sStructure);
throw new Exception(ResourceHelper.GetResourceString("kstidInvalidInstallation"));
}
}
public static string GetAttributeValue(XmlAttributeCollection attrs, string attrName)
{
XmlNode attrNode = attrs.GetNamedItem(attrName);
if (attrNode != null) {
return attrNode.Value;
}
return null;
}
/// -------------------------------------------------------------------------------------
/// <summary>
/// Returns a DivisionStartOption from the named attribute.
/// </summary>
/// <param name="attributes">collection of XML attributes for current tag</param>
/// <param name="attrName">name of the attribute</param>
/// <param name="defaultVal">a default to be used if no value present in the XML</param>
/// <returns>the DivisionStartOption enum</returns>
/// -------------------------------------------------------------------------------------
protected DivisionStartOption GetDivisionStart(XmlAttributeCollection attributes,
string attrName, DivisionStartOption defaultVal)
{
XmlNode divStartAttrib = attributes.GetNamedItem(attrName);
if (divStartAttrib != null && divStartAttrib.Value != string.Empty)
{
try
{
return (DivisionStartOption)Enum.Parse(typeof(DivisionStartOption),
divStartAttrib.Value, true);
}
catch
{
string message;
#if DEBUG
message = "Error reading TePublications.xml: Unrecognized DivisionStartOption attribute: "
+ attrName + "=\"" + divStartAttrib.Value + "\"";
#else
message = TeResourceHelper.GetResourceString("kstidInvalidInstallation");
#endif
throw new Exception(message);
}
}
else
return defaultVal;
}
