internal PresentationLink CreateCopyForMerging()
{
PresentationLink ret = new PresentationLink();
ret.role = this.role;
ret.title = this.title;
ret.BaseSchema = this.BaseSchema;
ret.MyHref = this.MyHref;
//need to copy the locators
ret.locators = new Hashtable();
foreach (DictionaryEntry de in this.locators)
{
PresentationLocator orig = de.Value as PresentationLocator;
PresentationLocator copy = orig.CreateCopyForMerging();
ret.locators[de.Key] = copy;
}
//using the parentnewvalue list we need to reset the parent infotrmationin
//presentation locators
foreach (PresentationLocator pl in ret.locators.Values)
{
pl.ResetParentInformation(ret.locators);
}
return(ret);
}
/// <summary>
/// UPDATE PRESENTATION LINK TO CHANGE AN ARC TO PROHIBITED
/// </summary>
/// <param name="elementToProhibit"></param>
/// <param name="ParentNode"></param>
/// <param name="isPresentation"></param>
/// <returns></returns>
public bool ProhibitArc(Node elementToProhibit,
Node ParentNode, bool isPresentation)
{
PresentationLocator parentLocator = locators[ParentNode.Id] as PresentationLocator;
if (parentLocator == null)
{
return(false);
}
ChildPresentationLocator cpl = parentLocator.childLocatorsByHRef[elementToProhibit.Id] as ChildPresentationLocator;
foreach (LocatorRelationshipInfo lri in cpl.LocatorRelationshipInfos)
{
if (((double)(lri.Order)).ToString("####0.####", new CultureInfo("en-US")).Equals(
elementToProhibit.order.ToString("####0.####", new CultureInfo("en-US"))) &&
(!isPresentation || lri.PrefLabel == elementToProhibit.PreferredLabel) &&
(isPresentation || lri.CalculationWeight == elementToProhibit.CalculationWeight) &&
lri.IsProhibited == false)
{
//simply prohibit the link...
//when we reload the prohibited link would anyway superseed the optional one
lri.IsProhibited = true;
break;
}
}
return(true);
}
/// <summary>
/// Compare two <see cref="Object"/>s, assumed to be <see cref="PresentationLocator"/>s.
/// </summary>
/// <param name="x">The first <see cref="Object"/> to be compared. Assumed to be
/// a <see cref="PresentationLocator"/>.</param>
/// <param name="y">The second <see cref="Object"/> to be compared. Assumed to be
/// a <see cref="PresentationLocator"/>.</param>
/// <returns><bl>
/// <li>Less than zero if <paramref name="x"/> is less than <paramref name="y"/>.</li>
/// <li>Zero if <paramref name="x"/> is equal to <paramref name="y"/>.</li>
/// <li>Greater than zero if <paramref name="x"/> is greater than <paramref name="y"/>.</li>
/// </bl></returns>
/// <remarks>The results of the comparison is that of <see cref="String.CompareTo(String)"/>
/// on
/// the HRef of the two <see cref="PresentationLocator"/>s.</remarks>
public int Compare(object x, object y)
{
PresentationLocator a = x as PresentationLocator;
PresentationLocator b = y as PresentationLocator;
return(a.HRef.CompareTo(b.HRef));
}
public void AddChild(PresentationLocator childPl, string label, string priority,
float orderArg, string prefLabel, string weight, bool isProhibited)
{
childPl.AddParent(this);
if (this.childLocatorsByHRef == null)
{
this.childLocatorsByHRef = new HybridDictionary();
this.childDisplayOrder = new HybridDictionary();
}
LocatorRelationshipInfo newRelation = LocatorRelationshipInfo.CreateObj(label,
priority, orderArg, orderArg, prefLabel, weight, isProhibited);
ChildPresentationLocator cpl = childLocatorsByHRef[childPl.HRef] as ChildPresentationLocator;
if (cpl == null)
{
// doesn't exist in either the href table or the order table
cpl = new ChildPresentationLocator(childPl.HRef, newRelation);
childLocatorsByHRef.Add(childPl.HRef, cpl);
// keep these separate so they don't impact each other
ChildPresentationLocator cplOrder = new ChildPresentationLocator(cpl);
}
else
{
// the cpl already exists, append the existing relation info
cpl.AddRelationship(newRelation);
}
}
internal PresentationLocator CreateCopyForMerging()
{
PresentationLocator copy = new PresentationLocator();
copy.CopyLocatorBaseInformation(this);
if (this.childDisplayOrder != null)
{
copy.childDisplayOrder = new HybridDictionary();
foreach (DictionaryEntry de1 in this.childDisplayOrder)
{
copy.childDisplayOrder[de1.Key] = de1.Value;
}
}
if (this.childLocatorsByHRef != null)
{
copy.childLocatorsByHRef = new HybridDictionary();
foreach (DictionaryEntry de1 in this.childLocatorsByHRef)
{
ChildPresentationLocator cpl = de1.Value as ChildPresentationLocator;
copy.childLocatorsByHRef[de1.Key] = cpl.CreateCopyForMerging();
}
}
//parent info udjused later
copy.parents = this.parents;
return(copy);
}
public void Append(PresentationLink arg, ArrayList errors)
{
Hashtable tempLocators = new Hashtable();
if (arg.locators != null && arg.locators.Count > 0)
{
foreach (DictionaryEntry de in arg.locators)
{
PresentationLocator presLocator
= locators[de.Key] as PresentationLocator;
if (presLocator != null)
{
tempLocators[de.Key] = de.Value;
}
else
{
locators[de.Key] = de.Value;
}
}
}
// fix up the new locators
foreach (DictionaryEntry de in tempLocators)
{
PresentationLocator presLocator = locators[de.Key] as PresentationLocator;
PresentationLocator oldLocator = de.Value as PresentationLocator;
presLocator.Append(oldLocator);
}
//preserve the old BaseSchema, so roleRef href will point to the correct schema
BaseSchema = arg.BaseSchema;
}
public void Append(PresentationLocator arg)
{
if (arg.childLocatorsByHRef != null)
{
if (this.childLocatorsByHRef == null)
{
this.childLocatorsByHRef = new HybridDictionary();
this.childDisplayOrder = new HybridDictionary();
}
foreach (ChildPresentationLocator cpl in arg.childLocatorsByHRef.Values)
{
ChildPresentationLocator orig = this.childLocatorsByHRef[cpl.HRef] as ChildPresentationLocator;
if (orig == null)
{
childLocatorsByHRef[cpl.HRef] = cpl;
}
else
{
foreach (LocatorRelationshipInfo lri in cpl.LocatorRelationshipInfos)
{
if (orig.CanAddRelationship(lri))
{
orig.AddRelationship(lri);
}
}
}
}
}
if (arg.parents != null && arg.parents.Count > 0)
{
if (parents == null)
{
parents = arg.parents;
}
else
{
// unique parents only please
foreach (PresentationLocator parent in arg.Parents)
{
if (!parents.Contains(parent))
{
parents.Add(parent);
}
}
}
}
foreach (string label in arg.labelArray)
{
AddLabel(label);
}
}
private bool LoadLocator(XmlNode locNode,
Dictionary <string, string> discoveredSchemas, string schemaPath)
{
string href = null;
string label = null;
if (!Common.GetAttribute(locNode, HREF_TAG, ref href, errorList) ||
!Common.GetAttribute(locNode, LABEL_TAG, ref label, errorList))
{
return(false);
}
if (string.IsNullOrEmpty(href))
{
return(false);
}
LocatorBase locator = CreateLocator(href);
locator.ParseHRef(errorList);
LinkBase.AddDiscoveredSchema(schemaPath, locator.Xsd, discoveredSchemas);
locator.AddLabel(label);
if (locators.ContainsKey(locator.HRef))
{
PresentationLocator oll = (PresentationLocator)locators[locator.HRef];
// add a new one, pointing to the same locator
if (!oll.LabelArray.Contains(label))
{
oll.AddLabel(label);
}
}
else
{
locators[locator.HRef] = locator;
}
HybridDictionary hrefList = this.LabelHrefMapping[label] as HybridDictionary;
if (hrefList == null)
{
hrefList = new HybridDictionary();
this.LabelHrefMapping[label] = hrefList;
}
hrefList[locator.HRef] = 1;
return(true);
}
public bool IsChildProhibited(string parentHref, string childHref, double order)
{
PresentationLocator parentPl = this.locators[parentHref] as PresentationLocator;
if (parentPl != null)
{
return(parentPl.IsChildProhibited(childHref, order));
}
return(false);
}
/// <summary>
/// Retrieve a <see cref="PresentationLocator"/> for this <see cref="PresentationLink"/>'s locators
/// collection by URI (href).
/// </summary>
/// <param name="href">The URI (href) of the locator to be retrieved.</param>
/// <param name="locator">If return value is true, the retrieved locator.</param>
/// <returns>True if the requested <see cref="PresentationLocator"/> occurs in this <see cref="PresentationLink"/>'s locators
/// collection.</returns>
public bool TryGetLocator(string href, out PresentationLocator locator)
{
locator = null;
if (locators == null)
{
return(false);
}
locator = locators[href] as PresentationLocator;
return(locator != null);
}
/// <summary>
/// Add a new relationship between two locators...
/// </summary>
/// <param name="elementId"></param>
/// <param name="parentElementId"></param>
/// <param name="newLocatorRelationshipInfo"></param>
/// <param name="taxonomy"></param>
/// <returns></returns>
public bool UpdateArc(string elementId, string parentElementId,
LocatorRelationshipInfo newLocatorRelationshipInfo, Taxonomy taxonomy)
{
PresentationLocator parentLocator = locators[parentElementId] as PresentationLocator;
if (parentLocator == null && !string.IsNullOrEmpty(parentElementId))
{
parentLocator = new PresentationLocator();
parentLocator.href = parentElementId;
parentLocator.MyElement = taxonomy.allElements[parentElementId] as Element;
locators[parentElementId] = parentLocator;
}
PresentationLocator childLocator = locators[elementId] as PresentationLocator;
if (childLocator == null)
{
childLocator = new PresentationLocator();
childLocator.href = elementId;
childLocator.MyElement = taxonomy.allElements[elementId] as Element;
if (parentLocator != null)
{
childLocator.AddParent(parentLocator);
}
locators[elementId] = childLocator;
}
if (parentLocator != null)
{
if (parentLocator.childLocatorsByHRef == null)
{
parentLocator.childLocatorsByHRef = new HybridDictionary();
}
ChildPresentationLocator cpl = parentLocator.childLocatorsByHRef[elementId] as ChildPresentationLocator;
if (cpl != null)
{
cpl.AddRelationship(newLocatorRelationshipInfo);
}
else
{
cpl = new ChildPresentationLocator(elementId, newLocatorRelationshipInfo);
parentLocator.childLocatorsByHRef[elementId] = cpl;
}
}
return(true);
}
internal void AddParent(PresentationLocator parent)
{
if (parents == null)
{
parents = new ArrayList();
}
// BUG 1610 - don't add duplicate parents
if (!parents.Contains(parent))
{
parents.Add(parent);
}
}
/// <summary>
/// Constructs a new instance of <see cref="PresentationLocator"/>, initializing
/// properties from a parameter-supplied <see cref="PresentationLocator"/>.
/// </summary>
/// <param name="copy">The <see cref="PresentationLocator"/> from which the properties
/// of the new <see cref="PresentationLocator"/> are to be initialized.</param>
public PresentationLocator(PresentationLocator copy)
{
this.childLocatorsByHRef = copy.childLocatorsByHRef;
this.childDisplayOrder = copy.childDisplayOrder;
this.e = copy.e;
this.HRef = copy.HRef;
this.LabelArray = copy.LabelArray;
this.e = copy.MyElement;
this.parents = copy.parents;
this.unpartitionedHref = copy.unpartitionedHref;
this.xsd = copy.xsd;
}
public virtual bool LoadLocator(XmlNode locNode)
{
string href = null;
string label = null;
if (!Common.GetAttribute(locNode, HREF_TAG, ref href, errorList) ||
!Common.GetAttribute(locNode, LABEL_TAG, ref label, errorList))
{
return(false);
}
LocatorBase locator = CreateLocator(href);
locator.ParseHRef(errorList);
locator.AddLabel(label);
LocatorBase oll = null;
if (locators.ContainsKey(label))
{
oll = (LocatorBase)locators[label];
// add a new one, pointing to the same locator
if (!oll.LabelArray.Contains(label))
{
// BUG 1610 - create a new presentation locator, since two arcs could have different
// priorities.
PresentationLocator newPL = new PresentationLocator();
newPL.HRef = oll.HRef;
newPL.UnpartitionedHref = oll.UnpartitionedHref;
newPL.Xsd = oll.Xsd;
// Add the label to the new presentation locator. This will differentiate the two locators.
newPL.AddLabel(label);
locators[label] = newPL;
}
}
else
{
locators[label] = locator;
}
return(true);
}
/// <summary>
/// Retrieves those locators from the locators collection for this <see cref="PresentationLink"/>
/// that have a given URI.
/// </summary>
/// <param name="href">The URI for which method is to search.</param>
/// <param name="locatorList">An output parameter. A collection
/// of <see cref="PresentationLocator"/> objects containing those locators matching <paramref name="href"/>.</param>
/// <returns>True if one or more locators was found. False otherwise.</returns>
public bool TryGetLocatorsByHref(string href, out ArrayList locatorList)
{
// BUG 1610 - There can be multiple locators with the same href but different labels,
// and the element needs to be bound to all of them.
locatorList = new ArrayList();
if (locators == null)
{
return(false);
}
PresentationLocator pl = this.locators[href] as PresentationLocator;
if (pl != null)
{
locatorList.Add(pl);
}
return(locatorList.Count > 0);
}
/// <returns>The parent node for this link</returns>
/// <exception cref="AucentException">throws if this link does not contain any locator objects</exception>
public Node CreateNode(string lang, string role, Dimension dimension)
{
ArrayList nodeList = new ArrayList(locators.Count + 1);
Node parent = new Node(title);
parent.MyPresentationLink = this;
IDictionaryEnumerator enumer = locators.GetEnumerator();
while (enumer.MoveNext())
{
PresentationLocator pl = (PresentationLocator)enumer.Value;
if (!pl.HasParent)
{
// create all the nodes for this presentationLink
try
{
Node childNode = pl.CreateNode(lang, role, 0,
pl.href, parent, null, this, true, dimension);
if (childNode.Children == null &&
childNode.MyElement != null && childNode.MyElement.IsHyperCubeItem())
{
//we might have decided to not show an hypercube.. as it does not have
//any children nodes that are valid segments...
return(null);
}
//parent.AddChild(childNode);
}
catch (Exception ex)
{
string msg = ex.Message;
}
}
}
return(parent);
}
public void CheckAppend()
{
ArrayList errors = new ArrayList();
TestPresentationLocator parent = new TestPresentationLocator( "label", "parent#parent" );
TestPresentationLocator parentToMerge = new TestPresentationLocator( "label", "parent#parent" );
PresentationLocator pl1 = new PresentationLocator( "child#child" );
pl1.ParseHRef( errors );
Assert.AreEqual( 0, errors.Count );
PresentationLocator pl2 = new PresentationLocator( "child#child2" );
pl2.ParseHRef( errors );
Assert.AreEqual( 0, errors.Count );
parentToMerge.AddChild( pl1, 1.0F, "pref", "1" );
parentToMerge.AddChild( pl2, 2.0F, "pref", "1" );
parent.Append( parentToMerge );
Assert.AreEqual( parent.childDisplayOrder.Count, 2, "wrong number of orders" );
Assert.AreEqual( parent.childLocatorsByHRef.Count, 2, "wrong number of href's" );
}
/// <summary>
/// Map the parent values back to the new locator list
/// </summary>
/// <param name="newLocatorList"></param>
internal void ResetParentInformation(Hashtable newLocatorList)
{
if (this.parents != null && this.parents.Count > 0)
{
ArrayList newList = new ArrayList(this.parents.Count);
for (int i = 0; i < this.parents.Count; i++)
{
PresentationLocator pl = parents[i] as PresentationLocator;
PresentationLocator newPl = newLocatorList[pl.href] as PresentationLocator;
if (newPl != null)
{
newList.Add(newPl);
}
else
{
throw new ApplicationException("Failed to find corresponding parent values");
}
}
this.parents = newList;
}
}
/// <exclude/>
public TestPresentationLocator(PresentationLocator pl)
: base(pl)
{
}
public void CheckAppend3()
{
ArrayList errors = new ArrayList();
TestPresentationLocator parent = new TestPresentationLocator( "label", "parent#parent" );
TestPresentationLocator parentToMerge = new TestPresentationLocator( "label", "parent#parent" );
PresentationLocator pl1 = new PresentationLocator( "child#child" );
pl1.ParseHRef( errors );
Assert.AreEqual( 0, errors.Count );
PresentationLocator pl2 = new PresentationLocator( "child#child2" );
pl2.ParseHRef( errors );
Assert.AreEqual( 0, errors.Count );
PresentationLocator pl3 = new PresentationLocator( "child#child" );
pl3.ParseHRef( errors );
Assert.AreEqual( 0, errors.Count );
PresentationLocator pl4 = new PresentationLocator( "child#child2" );
pl4.ParseHRef( errors );
Assert.AreEqual( 0, errors.Count );
parent.AddChild( pl1, 1.0F, "pref", "1" );
parent.AddChild( pl2, 2.0F, "pref", "1" );
parentToMerge.AddChild( pl3, 1.0F, "pref", "1" );
parentToMerge.AddChild( pl4,"label", "2", 2.0F, "pref", "1", true );
parent.Append( parentToMerge );
Assert.AreEqual( parent.childDisplayOrder.Count, 2, "wrong number of orders" );
Assert.AreEqual( parent.childLocatorsByHRef.Count, 2, "wrong number of href's" );
int count = ((ChildPresentationLocator)parent.childLocatorsByHRef[parent.childDisplayOrder[2.0F]]).LocatorRelationshipInfos.Count;
LocatorRelationshipInfo lri = ((ChildPresentationLocator)parent.childLocatorsByHRef[parent.childDisplayOrder[2.0F]]).LocatorRelationshipInfos[count - 1] as LocatorRelationshipInfo;
Assert.IsTrue(lri.IsProhibited);
}
public Node CreateNode(string lang, string role, int level,
string currentId, Node parentNode, LocatorRelationshipInfo relation,
PresentationLink pLink, bool recursive,
Dimension dimensionInfo)
{
Node current = null;
if (e == null && pLink != null)
{
/* Something went wrong during mergePresentation because we should have an element at
* this point. Go to the presentationLink and try to get the element. */
PresentationLocator loc = null;
pLink.TryGetLocator(this.HRef, out loc);
if (loc != null && loc.MyElement != null)
{
//update the element and the child locators
e = loc.MyElement;
this.childLocatorsByHRef = loc.childLocatorsByHRef;
}
}
if (e == null)
{
//it is a locator to an invalid element
//just return null at this point...
return(null);
}
//make sure we have the right element if there's a parent (there could be clones)
Element elementToUse = e;
if (dimensionInfo != null && elementToUse != null)
{
if (elementToUse.IsDimensionItem())
{
//get the parent node
if (parentNode != null)
{
//DimensionNode hierNode;
//if (dimensionInfo.TryGetHypercubeNode(lang,
// role, pLink.Role, parentNode.Id, out hierNode))
//{
// foreach (DimensionNode dn in hierNode.Children)
// {
// if (dn.Id == elementToUse.Id)
// {
// if (parentNode != null)
// {
// and add it
// parentNode.AddChild(dn);
// }
// return dn;
// }
// }
//}
DimensionNode hierNode;
if (dimensionInfo.TryGetHypercubeNode(lang,
role, pLink.Role, parentNode.Id, true, out hierNode))
{
if (hierNode.Children != null)
{
foreach (DimensionNode dn in hierNode.Children)
{
if (dn.Id == elementToUse.Id)
{
if (parentNode != null)
{
// and add it
parentNode.AddChild(dn);
}
return(dn);
}
}
}
return(null); //strange ..could not find the correct hierarchy..
}
else
{
return(null);
}
}
}
}
current = elementToUse == null ? new Node(href) : elementToUse.CreateNode(lang, role, false);
if (relation != null)
{
current.SetOrder(relation.Order);
current.CalculationWeight = relation.CalculationWeight;
if (preferredLabelRole.Equals(role))
{
if (relation.PrefLabel != null)
{
current.UpdatePreferredLabel(lang, relation.PrefLabel);
}
}
// now check to see if it's prohibited
current.IsProhibited = relation.IsProhibited;
}
if (parentNode != null)
{
// and add it
parentNode.AddChild(current);
}
if (childLocatorsByHRef != null && recursive)
{
foreach (ChildPresentationLocator cpl in childLocatorsByHRef.Values)
{
PresentationLocator childLocator;
if (!pLink.TryGetLocator(cpl.HRef, out childLocator))
{
continue;
}
bool innerRecursive = true;
if (parentNode != null && parentNode.GetParent(cpl.HRef) != null)
{
//this might be ok if one of the links is a prohibitted link...
innerRecursive = false; //looks like we have a recursion...
}
//organize locators by base order
//we should have only one valid LocatorRelationshipInfo for each non xlink information...
LocatorRelationshipInfo currentRelationShip = null;
for (int i = cpl.LocatorRelationshipInfos.Count - 1; i >= 0; i--)
{
LocatorRelationshipInfo lri = cpl.LocatorRelationshipInfos[i] as LocatorRelationshipInfo;
if (currentRelationShip != null && lri.IsNonXlinkEquivalentRelationship(currentRelationShip))
{
continue;
}
currentRelationShip = lri;
// always create the child
childLocator.CreateNode(lang, role,
level + 1, cpl.HRef, current, lri, pLink, innerRecursive, dimensionInfo);
}
}
//need to sort the nodes
if (current.Children != null)
{
current.Children.Sort(new NodeOrderSorter());
}
}
return(current);
}
/// <summary>
/// Retrieve a <see cref="PresentationLocator"/> for this <see cref="PresentationLink"/>'s locators
/// collection by URI (href).
/// </summary>
/// <param name="href">The URI (href) of the locator to be retrieved.</param>
/// <param name="locator">If return value is true, the retrieved locator.</param>
/// <returns>True if the requested <see cref="PresentationLocator"/> occurs in this <see cref="PresentationLink"/>'s locators
/// collection.</returns>
public bool TryGetLocator(string href, out PresentationLocator locator)
{
locator = null;
if ( locators == null )
{
return false;
}
locator = locators[href] as PresentationLocator;
return locator != null;
}
internal PresentationLocator CreateCopyForMerging()
{
PresentationLocator copy = new PresentationLocator();
copy.CopyLocatorBaseInformation(this);
if (this.childDisplayOrder != null)
{
copy.childDisplayOrder = new HybridDictionary();
foreach (DictionaryEntry de1 in this.childDisplayOrder)
{
copy.childDisplayOrder[de1.Key] = de1.Value;
}
}
if (this.childLocatorsByHRef != null)
{
copy.childLocatorsByHRef = new HybridDictionary();
foreach (DictionaryEntry de1 in this.childLocatorsByHRef)
{
ChildPresentationLocator cpl = de1.Value as ChildPresentationLocator;
copy.childLocatorsByHRef[de1.Key] = cpl.CreateCopyForMerging();
}
}
//parent info udjused later
copy.parents = this.parents;
return copy;
}
public void AddChild( PresentationLocator childPl, float orderArg,
string prefLabel, string calculationWeight )
{
AddChild( childPl,childPl.Label, "0", orderArg, prefLabel, calculationWeight ,false );
}
public override bool LoadArc(XmlNode node)
{
string arcrole = string.Empty;
string from = string.Empty;
string to = string.Empty;
if (!Common.GetAttribute(node, ARCROLE_TAG, ref arcrole, errorList) ||
!Common.GetAttribute(node, FROM_TAG, ref from, errorList) ||
!Common.GetAttribute(node, TO_TAG, ref to, errorList))
{
return(false);
}
//default order should be 1 as defined by xbrl spec 2.1 ( section 3.5.3.9.5)
string order = "1";
string use = string.Empty;
string prefLabel = null;
string weight = string.Empty;
string priority = "0";
if (!Common.GetAttribute(node, ORDER_TAG, ref order, null) && !FRTAMessageWritten)
{
Common.WriteWarning("XBRLParser.Warning.LinkbaseNotFRTACompliant", errorList, ORDER_TAG);
FRTAMessageWritten = true;
}
Common.GetAttribute(node, USE_TAG, ref use, null);
Common.GetAttribute(node, PREFLABEL_TAG, ref prefLabel, null);
Common.GetAttribute(node, PRIORITY_TAG, ref priority, null);
Common.GetAttribute(node, WEIGHT_TAG, ref weight, null);
if (arcrole.IndexOf(CHILD_PARENT_RELATIONSHIP) > -1)
{
//need to switch from and to
string tmp = from;
from = to;
to = tmp;
}
HybridDictionary fromhd = LabelHrefMapping[from] as HybridDictionary;
HybridDictionary tohd = LabelHrefMapping[to] as HybridDictionary;
if (fromhd == null || tohd == null)
{
Common.WriteError("XBRLParser.Warning.PLocatorParentChildNotFound", errorList, from, to, title);
return(false);
}
ArrayList parentLocators = new ArrayList(fromhd.Keys);
ArrayList childLocators = new ArrayList(tohd.Keys);
if (parentLocators == null || childLocators == null)
{
Common.WriteError("XBRLParser.Warning.PLocatorParentChildNotFound", errorList, from, to, title);
return(false);
}
foreach (string parentHref in parentLocators)
{
foreach (string childHref in childLocators)
{
//need to build the relationshipbetween
PresentationLocator parentPl = this.locators[parentHref] as PresentationLocator;
PresentationLocator childPl = this.locators[childHref] as PresentationLocator;
if (parentPl == null || childPl == null)
{
Common.WriteError("XBRLParser.Warning.PLocatorParentChildNotFound", errorList, from, to, title);
return(false);
}
float ord = float.Parse(order, NumberFormatInfo.InvariantInfo);
bool isProhibited = false;
if (use == PROHIBITED_TAG)
{
isProhibited = true;
}
parentPl.AddChild(childPl, to, priority, ord,
prefLabel, weight, isProhibited);
}
}
return(true);
}
public void AddChild( PresentationLocator childPl, string label, string priority,
float orderArg, string prefLabel, string weight, bool isProhibited )
{
childPl.AddParent( this );
if( this.childLocatorsByHRef == null )
{
this.childLocatorsByHRef = new HybridDictionary();
this.childDisplayOrder = new HybridDictionary();
}
LocatorRelationshipInfo newRelation = LocatorRelationshipInfo.CreateObj( label,
priority, orderArg, orderArg, prefLabel, weight, isProhibited);
ChildPresentationLocator cpl = childLocatorsByHRef[childPl.HRef] as ChildPresentationLocator;
if ( cpl == null )
{
// doesn't exist in either the href table or the order table
cpl = new ChildPresentationLocator( childPl.HRef, newRelation );
childLocatorsByHRef.Add( childPl.HRef, cpl );
// keep these separate so they don't impact each other
ChildPresentationLocator cplOrder = new ChildPresentationLocator( cpl );
}
else
{
// the cpl already exists, append the existing relation info
cpl.AddRelationship( newRelation );
}
}
public void Append( PresentationLocator arg)
{
if ( arg.childLocatorsByHRef != null )
{
if ( this.childLocatorsByHRef == null )
{
this.childLocatorsByHRef = new HybridDictionary();
this.childDisplayOrder = new HybridDictionary();
}
foreach( ChildPresentationLocator cpl in arg.childLocatorsByHRef.Values )
{
ChildPresentationLocator orig = this.childLocatorsByHRef[cpl.HRef] as ChildPresentationLocator;
if( orig == null )
{
childLocatorsByHRef[cpl.HRef] = cpl;
}
else
{
foreach( LocatorRelationshipInfo lri in cpl.LocatorRelationshipInfos )
{
if ( orig.CanAddRelationship( lri ))
{
orig.AddRelationship(lri);
}
}
}
}
}
if ( arg.parents != null && arg.parents.Count > 0 )
{
if ( parents == null )
{
parents = arg.parents;
}
else
{
// unique parents only please
foreach ( PresentationLocator parent in arg.Parents )
{
if ( !parents.Contains( parent ) )
{
parents.Add( parent );
}
}
}
}
foreach ( string label in arg.labelArray )
{
AddLabel( label );
}
}
public void AddChild(PresentationLocator childPl, float orderArg,
string prefLabel, string calculationWeight)
{
AddChild(childPl, childPl.Label, "0", orderArg, prefLabel, calculationWeight, false);
}
public virtual bool LoadLocator(XmlNode locNode)
{
string href = null;
string label = null;
if (!Common.GetAttribute(locNode, HREF_TAG, ref href, errorList) ||
!Common.GetAttribute(locNode, LABEL_TAG, ref label, errorList))
{
return false;
}
LocatorBase locator = CreateLocator(href);
locator.ParseHRef(errorList);
locator.AddLabel(label);
LocatorBase oll = null;
if (locators.ContainsKey(label))
{
oll = (LocatorBase)locators[label];
// add a new one, pointing to the same locator
if (!oll.LabelArray.Contains(label))
{
// BUG 1610 - create a new presentation locator, since two arcs could have different
// priorities.
PresentationLocator newPL = new PresentationLocator();
newPL.HRef = oll.HRef;
newPL.UnpartitionedHref = oll.UnpartitionedHref;
newPL.Xsd = oll.Xsd;
// Add the label to the new presentation locator. This will differentiate the two locators.
newPL.AddLabel(label);
locators[label] = newPL;
}
}
else
{
locators[label] = locator;
}
return true;
}
/// <summary>
/// Add a new relationship between two locators...
/// </summary>
/// <param name="elementId"></param>
/// <param name="parentElementId"></param>
/// <param name="newLocatorRelationshipInfo"></param>
/// <param name="taxonomy"></param>
/// <returns></returns>
public bool UpdateArc(string elementId, string parentElementId ,
LocatorRelationshipInfo newLocatorRelationshipInfo, Taxonomy taxonomy )
{
PresentationLocator parentLocator = locators[parentElementId] as PresentationLocator;
if (parentLocator == null && !string.IsNullOrEmpty(parentElementId))
{
parentLocator = new PresentationLocator();
parentLocator.href = parentElementId;
parentLocator.MyElement = taxonomy.allElements[parentElementId] as Element;
locators[parentElementId] = parentLocator;
}
PresentationLocator childLocator = locators[elementId] as PresentationLocator;
if (childLocator == null )
{
childLocator = new PresentationLocator();
childLocator.href = elementId;
childLocator.MyElement = taxonomy.allElements[elementId] as Element;
if (parentLocator != null)
{
childLocator.AddParent(parentLocator);
}
locators[elementId] = childLocator;
}
if (parentLocator != null)
{
if (parentLocator.childLocatorsByHRef == null)
{
parentLocator.childLocatorsByHRef = new HybridDictionary();
}
ChildPresentationLocator cpl = parentLocator.childLocatorsByHRef[elementId] as ChildPresentationLocator;
if (cpl != null)
{
cpl.AddRelationship(newLocatorRelationshipInfo);
}
else
{
cpl = new ChildPresentationLocator(elementId, newLocatorRelationshipInfo);
parentLocator.childLocatorsByHRef[elementId] = cpl;
}
}
return true;
}
/// <summary>
/// Constructs a new instance of <see cref="PresentationLocator"/>, initializing
/// properties from a parameter-supplied <see cref="PresentationLocator"/>.
/// </summary>
/// <param name="copy">The <see cref="PresentationLocator"/> from which the properties
/// of the new <see cref="PresentationLocator"/> are to be initialized.</param>
public PresentationLocator(PresentationLocator copy)
{
this.childLocatorsByHRef = copy.childLocatorsByHRef;
this.childDisplayOrder = copy.childDisplayOrder;
this.e = copy.e;
this.HRef = copy.HRef;
this.LabelArray = copy.LabelArray;
this.e = copy.MyElement;
this.parents = copy.parents;
this.unpartitionedHref = copy.unpartitionedHref;
this.xsd = copy.xsd;
}
internal void AddParent( PresentationLocator parent )
{
if ( parents == null )
{
parents = new ArrayList();
}
// BUG 1610 - don't add duplicate parents
if ( !parents.Contains( parent ) )
{
parents.Add( parent );
}
}
