internal void InitializeAll()
{
foreach (LoggingRule r in LoggingRules)
{
foreach (Target t in r.Targets)
{
if (!_aliveTargets.Contains(t))
{
_aliveTargets.Add(t);
}
}
}
foreach (Target target in _aliveTargets)
{
try
{
target.Initialize();
}
catch (Exception ex)
{
InternalLogger.Error("Error while initializing target: {0} {1}", target.Name, ex);
}
}
}
public void MouseMove(Point mousePos)
{
// Find the Target the mouse is currently over (if any)
Target t = _targets.Contains(mousePos);
// Set appropriate cursor
if (t != null)
{
_source.Cursor = _validCursor;
}
else
{
_source.Cursor = _invalidCursor;
}
if (t != _lastTarget)
{
// Remove the old indicator
if (_lastTarget != null)
{
DrawHelper.DrawDragRectangle(_lastTarget.DrawRect, _rectWidth);
}
// Draw the new indicator
if (t != null)
{
DrawHelper.DrawDragRectangle(t.DrawRect, _rectWidth);
}
// Remember for next time around
_lastTarget = t;
}
}
private void okButton_Click(object sender, RoutedEventArgs e)
{
for (int i = SourceCollection.Count - 1; i >= 0; i--)
{
object o = SourceCollection[i];
if (!SourceCollectionEdited.Contains(o))
{
SourceCollection.RemoveAt(i);
}
}
foreach (object o in SourceCollectionEdited)
{
if (!SourceCollection.Contains(o))
{
SourceCollection.Add(o);
}
}
for (int i = TargetCollection.Count - 1; i >= 0; i--)
{
object o = TargetCollection[i];
if (!TargetCollectionEdited.Contains(o))
{
TargetCollection.RemoveAt(i);
}
}
foreach (object o in TargetCollectionEdited)
{
if (!TargetCollection.Contains(o))
{
TargetCollection.Add(o);
}
}
cancelButton_Click(sender, e);
}
/// <summary>
/// Parses the arguments.
/// </summary>
/// <param name="args">Program arguments.</param>
/// <returns>A collection of all targets to be executed.</returns>
private static List <ITarget> ParseArguments(string[] args)
{
List <ITarget> result = new List <ITarget>();
foreach (string arg in args)
{
if (TargetCollection.Contains(arg))
{
result.Add(TargetCollection.Get(arg));
}
else
{
HoneycombConsole.WriteErrorLine($"Unknown target '{arg}' found. Use 'honeycomb help' for a list of all available targets.");
Exit(ExitCode.UnknownTarget);
}
}
return(result);
}
/// <summary>
/// Executes the specified target.
/// </summary>
protected override void ExecuteTask()
{
Target owningTarget = Parent as Target;
if (owningTarget != null)
{
// topologically sorted list of targets that will be executed
TargetCollection targets = Project.TopologicalTargetSort(TargetName, Project.Targets);
// check if owning target is part of list of targets that will
// be executed again
if (targets.Contains(owningTarget.Name))
{
// check if owning target is actually a dependency of the
// target that should be executed
if (targets.IndexOf(targets[owningTarget.Name]) < targets.IndexOf(targets[JustTargetName()]))
{
throw new BuildException("Circular dependency: " + targets.ToString(" <- ") + " <- " + owningTarget.Name);
}
}
}
Project.Execute(TargetName, CascadeDependencies);
}
// component logic
public override void Apply(XmlDocument document, string key)
{
// XmlNodeList link_nodes = document.SelectNodes("//referenceLink");
XPathNodeIterator linkIterator = document.CreateNavigator().Select(referenceLinkExpression);
XPathNavigator[] linkNodes = BuildComponentUtilities.ConvertNodeIteratorToArray(linkIterator);
foreach (XPathNavigator linkNode in linkNodes)
{
// extract link information
ReferenceLinkInfo2 link = ReferenceLinkInfo2.Create(linkNode);
if (link == null)
{
WriteMessage(MessageLevel.Warn, "Invalid referenceLink element.");
}
else
{
// determine target, link type, and display options
string targetId = link.Target;
DisplayOptions options = link.DisplayOptions;
LinkType2 type = LinkType2.None;
Target target = GetTarget(targetId);
if (target == null)
{
// no such target known; set link type to none and warn
type = LinkType2.None;
WriteMessage(MessageLevel.Warn, String.Format("Unknown reference link target '{0}'.", targetId));
}
else
{
// if overload is prefered and found, change targetId and make link options hide parameters
if (link.PreferOverload)
{
bool isConversionOperator = false;
MethodTarget method = target as MethodTarget;
if (method != null)
{
isConversionOperator = method.conversionOperator;
}
MemberTarget member = target as MemberTarget;
// if conversion operator is found, always link to individual topic.
if ((member != null) && (!String.IsNullOrEmpty(member.OverloadId)) && !isConversionOperator)
{
Target overloadTarget = targets[member.OverloadId];
if (overloadTarget != null)
{
target = overloadTarget;
targetId = overloadTarget.Id;
}
}
// if individual conversion operator is found, always display parameters.
if (isConversionOperator && member != null && (!string.IsNullOrEmpty(member.OverloadId)))
{
options = options | DisplayOptions.ShowParameters;
}
else
{
options = options & ~DisplayOptions.ShowParameters;
}
}
// get stored link type
type = target.DefaultLinkType;
// if link type is local or index, determine which
if (type == LinkType2.LocalOrIndex)
{
if ((key != null) && targets.Contains(key) && (target.Container == targets[key].Container))
{
type = LinkType2.Local;
}
else
{
type = LinkType2.Index;
}
}
}
// links to this page are not live
if (targetId == key)
{
type = LinkType2.Self;
}
else if ((target != null) && (key != null) && targets.Contains(key) && (target.File == targets[key].File))
{
type = LinkType2.Self;
}
// get msdn or external endpoint, if needed
string externalUrl = null;
if (type == LinkType2.Msdn || type == LinkType2.External)
{
externalUrl = ResolveExternalUrl(targetId, type);
if (String.IsNullOrEmpty(externalUrl))
{
type = LinkType2.None;
}
}
// write opening link tag and target info
XmlWriter writer = linkNode.InsertAfter();
switch (type)
{
case LinkType2.None:
writer.WriteStartElement("span");
writer.WriteAttributeString("class", "nolink");
break;
case LinkType2.Self:
writer.WriteStartElement("span");
writer.WriteAttributeString("class", "selflink");
break;
case LinkType2.Local:
// format link with prefix and/or postfix
string href = String.Format(hrefFormat, target.File);
// make link relative, if we have a baseUrl
if (baseUrl != null)
{
href = BuildComponentUtilities.GetRelativePath(href, BuildComponentUtilities.EvalXPathExpr(document, baseUrl, "key", key));
}
writer.WriteStartElement("a");
writer.WriteAttributeString("href", href);
break;
case LinkType2.Index:
writer.WriteStartElement("mshelp", "link", "http://msdn.microsoft.com/mshelp");
writer.WriteAttributeString("keywords", targetId);
writer.WriteAttributeString("tabindex", "0");
break;
case LinkType2.Msdn:
case LinkType2.External:
writer.WriteStartElement("a");
writer.WriteAttributeString("href", externalUrl);
writer.WriteAttributeString("target", linkTarget);
break;
}
// write the link text
if (String.IsNullOrEmpty(link.DisplayTarget))
{
if (link.Contents == null)
{
if (target != null)
{
resolver.WriteTarget(target, options, writer);
}
else
{
//Console.WriteLine("Attemting to create reference");
Reference reference = TextReferenceUtilities.CreateReference(targetId);
//Console.WriteLine("Returned");
if (reference is InvalidReference)
{
WriteMessage(MessageLevel.Warn, String.Format("Invalid reference link target '{0}'.", targetId));
}
resolver.WriteReference(reference, options, writer);
}
}
else
{
// write contents to writer
link.Contents.WriteSubtree(writer);
}
}
else
{
//Console.WriteLine("Display target = {0}", link.DisplayTarget);
if ((String.Compare(link.DisplayTarget, "content", true) == 0) && (link.Contents != null))
{
// Use the contents as an XML representation of the display target
//Console.WriteLine(link.Contents.NodeType);
Reference reference = XmlTargetCollectionUtilities.CreateReference(link.Contents);
//Console.WriteLine(reference.GetType().FullName);
resolver.WriteReference(reference, options, writer);
}
if ((String.Compare(link.DisplayTarget, "format", true) == 0) && (link.Contents != null))
{
// Use the contents as a format string for the display target
string format = link.Contents.OuterXml;
//Console.WriteLine("format = {0}", format);
string input = null;
StringWriter textStore = new StringWriter();
try {
XmlWriterSettings settings = new XmlWriterSettings();
settings.ConformanceLevel = ConformanceLevel.Fragment;
XmlWriter xmlStore = XmlWriter.Create(textStore, settings);
try {
if (target != null)
{
resolver.WriteTarget(target, options, xmlStore);
}
else
{
Reference reference = TextReferenceUtilities.CreateReference(targetId);
resolver.WriteReference(reference, options, xmlStore);
}
} finally {
xmlStore.Close();
}
input = textStore.ToString();
} finally {
textStore.Close();
}
//Console.WriteLine("input = {0}", input);
string output = String.Format(format, input);
//Console.WriteLine("output = {0}", output);
XmlDocumentFragment fragment = document.CreateDocumentFragment();
fragment.InnerXml = output;
fragment.WriteTo(writer);
//writer.WriteRaw(output);
}
else if ((String.Compare(link.DisplayTarget, "extension", true) == 0) && (link.Contents != null))
{
Reference extMethodReference = XmlTargetCollectionUtilities.CreateExtensionMethodReference(link.Contents);
resolver.WriteReference(extMethodReference, options, writer);
}
else
{
// Use the display target value as a CER for the display target
TextReferenceUtilities.SetGenericContext(key);
Reference reference = TextReferenceUtilities.CreateReference(link.DisplayTarget);
//Console.WriteLine("Reference is {0}", reference.GetType().FullName);
resolver.WriteReference(reference, options, writer);
}
}
// write the closing link tag
writer.WriteEndElement();
writer.Close();
}
// delete the original tag
linkNode.DeleteSelf();
}
}
private void ProcessReferenceLink(XmlDocument document, string key)
{
XPathNodeIterator linkIterator = document.CreateNavigator().Select(
referenceLinkExpression);
if (linkIterator == null || linkIterator.Count == 0)
{
return;
}
XPathNavigator[] linkNodes = BuildComponentUtilities.ConvertNodeIteratorToArray(linkIterator);
foreach (XPathNavigator linkNode in linkNodes)
{
// extract link information
ReferenceLinkInfo link = ReferenceLinkInfo.Create(linkNode);
if (link == null)
{
this.WriteMessage(MessageLevel.Warn,
"Invalid referenceLink element.");
#if DEBUG
this.WriteMessage(MessageLevel.Warn, linkNode.OuterXml);
#endif
}
else
{
// determine target, link type, and display options
string targetId = link.Target;
ReferenceLinkDisplayOptions options = link.DisplayOptions;
ReferenceLinkType type = ReferenceLinkType.None;
Target target = _targets[targetId];
if (target == null)
{
if (_hasTopicLinks && _targetController[targetId] != null)
{
this.ProcessConceptualLink(linkNode, key);
// delete the original tag
linkNode.DeleteSelf();
continue;
}
else
{
// no such target known; set link type to none and warn
type = ReferenceLinkType.None;
this.WriteMessage(MessageLevel.Warn, String.Format(
"Unknown reference link target '{0}'.", targetId));
}
}
else
{
// if overload is preferred and found, change targetId and make link options hide parameters
if (link.PreferOverload)
{
bool isConversionOperator = false;
TargetType targetType = target.TargetType;
MemberTarget member = null;
if (targetType == TargetType.Method)
{
MethodTarget method = (MethodTarget)target;
isConversionOperator = method.ConversionOperator;
member = method; // a method is a member...
}
else if (targetType == TargetType.Member || targetType == TargetType.Constructor ||
targetType == TargetType.Procedure || targetType == TargetType.Event ||
targetType == TargetType.Property)
{
member = (MemberTarget)target;
}
// if conversion operator is found, always link to individual topic.
if ((member != null) && (!String.IsNullOrEmpty(member.OverloadId)) && !isConversionOperator)
{
Target overloadTarget = _targets[member.OverloadId];
if (overloadTarget != null)
{
target = overloadTarget;
targetId = overloadTarget.Id;
}
}
// if individual conversion operator is found, always display parameters.
if (isConversionOperator && member != null &&
(!string.IsNullOrEmpty(member.OverloadId)))
{
options = options | ReferenceLinkDisplayOptions.ShowParameters;
}
else
{
options = options & ~ReferenceLinkDisplayOptions.ShowParameters;
}
}
// get stored link type
type = _targets.RecentLinkTypeIsMsdn ?
_targets.RecentLinkType : target.LinkType;
// if link type is local or index, determine which
if (type == ReferenceLinkType.LocalOrIndex)
{
if ((key != null) && _targets.Contains(key) &&
(target.Container == _targets[key].Container))
{
type = ReferenceLinkType.Local;
}
else
{
type = ReferenceLinkType.Index;
}
}
}
// links to this page are not live
if (targetId == key)
{
type = ReferenceLinkType.Self;
}
else if ((target != null) && (key != null) && _targets.Contains(key) &&
(target.File == _targets[key].File))
{
type = ReferenceLinkType.Self;
}
// get msdn endpoint, if needed
string msdnUrl = null;
if (type == ReferenceLinkType.Msdn)
{
if ((_msdnResolver == null) || (_msdnResolver.IsDisabled))
{
// no msdn resolver
}
else
{
msdnUrl = _msdnResolver[targetId];
if (String.IsNullOrEmpty(msdnUrl))
{
WriteMessage(MessageLevel.Warn, String.Format(
"MSDN URL not found for target '{0}'.", targetId));
}
}
if (String.IsNullOrEmpty(msdnUrl))
{
type = ReferenceLinkType.None;
}
}
// write opening link tag and target info
XmlWriter writer = linkNode.InsertAfter();
switch (type)
{
case ReferenceLinkType.None:
writer.WriteStartElement("span");
writer.WriteAttributeString("class", "nolink");
break;
case ReferenceLinkType.Self:
writer.WriteStartElement("span");
writer.WriteAttributeString("class", "selflink");
break;
case ReferenceLinkType.Local:
// format link with prefix and/or postfix
string href = String.Format(_hrefFormat, target.File);
// make link relative, if we have a baseUrl
if (_baseUrl != null)
{
href = BuildComponentUtilities.GetRelativePath(href,
BuildComponentUtilities.EvalXPathExpr(document, _baseUrl, "key", key));
}
writer.WriteStartElement("a");
writer.WriteAttributeString("href", href);
break;
case ReferenceLinkType.Index:
writer.WriteStartElement("mshelp", "link", "http://msdn.microsoft.com/mshelp");
writer.WriteAttributeString("keywords", targetId);
writer.WriteAttributeString("tabindex", "0");
break;
case ReferenceLinkType.Msdn:
writer.WriteStartElement("a");
writer.WriteAttributeString("href", msdnUrl);
writer.WriteAttributeString("target", _linkTarget);
break;
case ReferenceLinkType.Id:
string xhelp = String.Format("ms-xhelp://?Id={0}", targetId);
xhelp = xhelp.Replace("#", "%23");
writer.WriteStartElement("a");
writer.WriteAttributeString("href", xhelp);
break;
}
// write the link text
if (String.IsNullOrEmpty(link.DisplayTarget))
{
if (link.Contents == null)
{
if (target != null)
{
_linkResolver.WriteTarget(target, options, writer);
}
else
{
Reference reference = ReferenceTextUtilities.CreateReference(targetId);
if (reference.ReferenceType == ReferenceType.Invalid)
{
WriteMessage(MessageLevel.Warn, String.Format(
"Invalid reference link target '{0}'.", targetId));
}
_linkResolver.WriteReference(reference, options, writer);
}
}
else
{
// write contents to writer
link.Contents.WriteSubtree(writer);
}
}
else
{
if ((String.Compare(link.DisplayTarget, "content", true) == 0) && (link.Contents != null))
{
// Use the contents as an XML representation of the display target
Reference reference = TargetCollectionXmlUtilities.CreateReference(link.Contents);
_linkResolver.WriteReference(reference, options, writer);
}
if ((String.Compare(link.DisplayTarget, "format", true) == 0) && (link.Contents != null))
{
// Use the contents as a format string for the display target
string format = link.Contents.OuterXml;
string input = null;
StringWriter textStore = new StringWriter();
try
{
XmlWriter xmlStore = XmlWriter.Create(textStore, _writerSettings);
try
{
if (target != null)
{
_linkResolver.WriteTarget(target, options, xmlStore);
}
else
{
Reference reference = ReferenceTextUtilities.CreateReference(targetId);
_linkResolver.WriteReference(reference, options, xmlStore);
}
}
finally
{
xmlStore.Close();
}
input = textStore.ToString();
}
finally
{
textStore.Close();
}
string output = String.Format(format, input);
XmlDocumentFragment fragment = document.CreateDocumentFragment();
fragment.InnerXml = output;
fragment.WriteTo(writer);
//writer.WriteRaw(output);
}
else if ((String.Compare(link.DisplayTarget, "extension", true) == 0) && (link.Contents != null))
{
Reference extMethodReference = TargetCollectionXmlUtilities.CreateExtensionMethodReference(link.Contents);
_linkResolver.WriteReference(extMethodReference, options, writer);
}
else
{
// Use the display target value as a CER for the display target
ReferenceTextUtilities.SetGenericContext(key);
Reference reference = ReferenceTextUtilities.CreateReference(link.DisplayTarget);
_linkResolver.WriteReference(reference, options, writer);
}
}
// write the closing link tag
writer.WriteEndElement();
writer.Close();
}
// delete the original tag
linkNode.DeleteSelf();
}
}
