// http://msdn.microsoft.com/en-us/library/system.windows.ink.contextnode(v=vs.90).aspx
private void BuildTree(ContextNode parentCNode, TreeViewItem parentTNode)
{
parentTNode.IsExpanded = true;
foreach (ContextNode cNode in parentCNode.SubNodes)
{
// Create new tree node corresponding to context node.
TreeViewItem tNode = new TreeViewItem();
tNode.Tag = cNode;
tNode.Header = cNode.ToString();
if (cNode is InkWordNode)
{
tNode.Header += ": " + (cNode as InkWordNode).GetRecognizedString();
}
else if (cNode is InkDrawingNode)
{
tNode.Header += ": " + (cNode as InkDrawingNode).GetShapeName();
}
if (cNode.IsConfirmed(ConfirmationType.NodeTypeAndProperties))
{
tNode.Header += "Confirmed.";
}
parentTNode.Items.Add(tNode);
BuildTree(cNode, tNode);
}
}
private int WriteChunkInternal(ContextNode top, byte[] buffer, int offset, int count)
{
ulong maxBytes;
if ((top.Size != (ulong)ChunkSize.Unknown32Bit) &&
(top.Size != (ulong)ChunkSize.Unknown64Bit))
{
maxBytes = top.Size - top.Offset;
if ((ulong)count > maxBytes)
{
count = (int)maxBytes;
}
}
if (count <= 0)
{
return(0);
}
var result = _streamOperations.Write(_ioContext, buffer, offset, count);
if (result >= 0)
{
top.Offset += (ulong)result;
if (top.Offset > top.CurrentSize)
{
top.CurrentSize = top.Offset;
}
}
return(result);
}
private void TsDelete_Click(object sender, EventArgs e)
{
Path = null;
MainGraph.RemoveNode(NodeContext);
ContextNode.Close();
NodeContext = null;
}
public TContext Resolve <TContext>(string name = null)
where TContext : class
{
Type contextType = typeof(TContext);
if (_contextRegistry.ContainsKey(contextType) == false)
{
_contextRegistry[contextType] = new ContextNode();
}
if (string.IsNullOrEmpty(name))
{
if (_contextRegistry[contextType].Default == null)
{
_contextRegistry[contextType].Default = Create <TContext>(name);
}
return(_contextRegistry[contextType].Default as TContext);
}
if (_contextRegistry[contextType].ContainsKey(name) == false)
{
_contextRegistry[contextType][name] = Create <TContext>(name);
}
return(_contextRegistry[contextType][name] as TContext);
}
private SerilogLoggingAdapter(LoggingBus bus, string logSource, Type logClass, ContextNode enricher) : base(bus, logSource, logClass, SerilogLogMessageFormatter.Instance)
{
_bus = bus;
_logSource = logSource;
_logClass = logClass;
_enricherNode = enricher;
}
public void AddChildContext(ContextNode child)
{
if (children.IndexOf(child) < 0)
{
children.Add(child);
}
}
/// <summary>
/// Unity callback.
/// </summary>
protected void OnDestroy()
{
this.Trigger = null;
this.node.SetValueListener(null);
this.node = null;
}
private static Range NotContainingSubformula(Range applyto, ContextNode subformula)
{
var which = applyto.Cells.Cast <Range>()
.GroupBy(c => (string)c.FormulaR1C1)
.Select(group => new { parse = Helper.ParseCtx(@group.First(), subformula.Ctx), example = @group.First() })
.FirstOrDefault(t => !t.parse.Contains(subformula));
return(which?.example);
}
protected virtual void Awake()
{
this.node = new ContextNode(this.gameObject, this.Path);
if (this.Target == null)
{
this.Target = this.GetComponent <TComponent>();
}
}
public void CreatePreViewCode()
{
var selectedTransform = Selection.activeTransform;
if (selectedTransform == null)
{
Debug.LogError("No transform is selected");
return;
}
else
{
var transformPath = GraphEditorWindow.GetGameObjectPath(selectedTransform);
Debug.Log(string.Format("Create binding graph for {0}", transformPath), selectedTransform);
}
ReadTemplate();
templateOut = string.Empty;
var container = selectedTransform.GetComponent <Hugula.Databinding.BindableObject>();
ContextNode.templateDic.Clear();
ContextNode.templateDic["name"] = new StringBuilder().Append(container.name);
ContextNode.templateDic["property"] = new StringBuilder();
ContextNode.templateDic["command"] = new StringBuilder();
var root = new ContextNode()
{
name = container.name, contextType = ContextType.ViewModel
};
Dictionary <Hugula.Databinding.BindableObject, ContextNode> sourceContext = new Dictionary <BindableObject, ContextNode>();
BuildContextTree(container, root, sourceContext);
Debug.Log(root.name);
root.GenTemplateString();
var tempOut = template;
string key = string.Empty;
string content = string.Empty;
var templateTypes = System.Enum.GetValues(typeof(TemplateType));
System.Text.StringBuilder sb = new StringBuilder();
foreach (var en in templateTypes)
{
key = System.Enum.GetName(typeof(TemplateType), en);//获取名称
content = string.Empty;
if (ContextNode.templateDic.TryGetValue(key, out sb))
{
content = sb.ToString();
}
key = "{" + key + "}";
tempOut = tempOut.Replace(key, content);
}
Debug.Log(tempOut);
templateOut = tempOut;
}
private void FreeContextNode(ContextNode contextNode)
{
_stack.Remove(contextNode);
while (contextNode.ContextInfoNodes.Count > 0)
{
var contextInfoNode = contextNode.ContextInfoNodes.RemoveHead();
PurgeContextInfoNode(contextInfoNode);
}
contextNode.Dispose();
}
private void setRefactoredFormula()
{
if (orFormula == null || Formula == null || NewCellAddress == null)
{
return;
}
RefactoredFormula = orFormula.Replace(Formula, orFormula.Ctx.Parse(NewCellAddress.Address()));
OnPropertyChanged("RefactoredFormula");
OnPropertyChanged("RefactoredFormulaStr");
}
public void insertStrokes(InkAnalyzer analyzer, InkCanvas mainInkCanvas, InkCanvas insertionCanvas)
{
double bestY = -10000;
ContextNode selectedNode = null;
foreach (ContextNode node in analyzer.FindLeafNodes())
{
double y1 = strokeToBeReplaced.GetBounds().Y;
double y2 = node.Strokes.GetBounds().Y;
if (y1 - y2 > 0 && y1 - y2 < y1 - bestY)
{
bestY = y2;
selectedNode = node;
}
}
if (bestY == -10000)
{
bestY = strokeToBeReplaced.GetBounds().Y;
}
StrokeCollection strokeCollection = insertionCanvas.Strokes.Clone();
insertionCanvas.Strokes.Clear();
double bestX = strokeToBeReplaced.GetBounds().X;
double strokeX = strokeCollection.GetBounds().X;
double strokeY = strokeCollection.GetBounds().Y;
Matrix inkTransform = new Matrix();
inkTransform.Translate(bestX - strokeX + 20, bestY - strokeY);
strokeCollection.Transform(inkTransform, false);
double width = strokeCollection.GetBounds().Width + Constants.SPACING;
double startX = strokeCollection.GetBounds().X;
Matrix transform = new Matrix();
transform.Translate(width, 0);
if (selectedNode != null)
{
for (int i = 0; i < selectedNode.ParentNode.SubNodes.Count; i++)
{
ContextNode siblingNode = selectedNode.ParentNode.SubNodes[i];
for (int j = 0; j < siblingNode.Strokes.Count; j++)
{
Stroke stroke = siblingNode.Strokes[j];
double offsetX = stroke.GetBounds().X;
if (offsetX > startX)
{
stroke.Transform(transform, false);
}
}
}
}
mainInkCanvas.Strokes.Add(strokeCollection);
mainInkCanvas.Strokes.Remove(strokeToBeReplaced);
}
/// <summary>
/// Gets the parent context.
/// </summary>
/// <returns>The parent context.</returns>
/// <param name="contextNode">Context node.</param>
public ContextNode GetParentContext(ContextNode contextNode)
{
ContextNode parent;
parent = (ContextNode)contextNode.Successor;
if (parent != null && parent.Id != 0)
{
return(parent);
}
return(null);
}
private void MarkNodeAsRed(ContextNode cNode)
{
foreach (Stroke stroke in MainInkCanvas.Strokes)
{
stroke.DrawingAttributes.Color = Colors.Black;
}
foreach (Stroke stroke in cNode.Strokes)
{
stroke.DrawingAttributes.Color = Colors.Red;
}
}
public ILoggingAdapter SetContextProperty(string name, object value, bool destructureObjects = false)
{
var contextProperty = new PropertyEnricher(name, value, destructureObjects);
var contextNode = new ContextNode
{
Enricher = contextProperty,
Next = _enricherNode
};
return(new SerilogExtendedLoggingAdapter(_adapter, contextNode));
}
public void SetContext(ContextPickerData aContext)
{
if (aContext == null)
{
_Context = aContext;
_ContextRoot = null;
}
else
{
_Context = aContext.Clone() as ContextPickerData;
_ContextRoot = new ContextNode(aContext.Selected);
}
}
private void AnalysisView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
TreeViewItem selectedItem = e.NewValue as TreeViewItem;
if (selectedItem == null)
{
return;
}
ContextNode cNode = (ContextNode)selectedItem.Tag;
MarkNodeAsRed(cNode);
}
private void DeleteContentsToTrash()
{
if (RequestIdList.Count == 0)
{
ContextNode.Delete();
}
else
{
foreach (var node in RequestNodeList)
{
node.Delete();
}
}
}
public static void Refactor(Range applyto, Location to, ContextNode subformula)
{
// Check if all cells contain the subformula
var notContaining = NotContainingSubformula(applyto, subformula);
if (notContaining != null)
{
throw new ArgumentException(String.Format((string)"Not all cells contain that subformula, for example: {0}", (object)notContaining.Address[false, false]));
}
Range target = applyto.Worksheet.Cells[to.Row1, to.Column1];
if (target.Value2 != null && target.Value2 != "")
{
throw new ArgumentException($"Target cell {to} is not empty");
}
target.Formula = "=" + subformula.Print();
var targetAddr = subformula.Ctx.Parse(to.Address());
foreach (var uniqueR1C1Group in applyto.Cells.Cast <Range>().GroupBy(c => c.FormulaR1C1))
{
var prototype = uniqueR1C1Group.First();
var parsed = Helper.ParseCtx(prototype);
prototype.Formula = "=" + parsed.Replace(subformula, targetAddr).Print();
var r1c1 = prototype.FormulaR1C1;
foreach (var cell in uniqueR1C1Group)
{
cell.FormulaR1C1 = r1c1;
}
}
// TODO: Provide some sort of undo functionality if possible
// Warning: You cannot allow Excel to undo the actions of a VSTO plugin, so that path is doomed to fail :(
// Quote from page 176 from "Visual Studio Tools for Office 2007" by E. Carter:
/* Undo in Excel
* Excel has an Undo method that can be used to undo the last few actions
* taken by the user. However, Excel does not support undoing actions taken
* by your code. As soon as your code touches the object model, Excel clears
* the undo history and it does not add any of the actions your code performs
* to the undo history.
*/
// Best option would be a manual undo stack, but that still goes against user expectations:
// (will Ctrl+Z work?, cannot undo further than Add-in actions etc.)
// To hook up on Excel's undo trigger there's [Application.OnUndo](https://msdn.microsoft.com/en-us/library/office/ff194135(v=office.15).aspx)
// but that still requires a VBA macro to be defined to undo the changes made by the addon.
}
internal IFFParser(IFFIOCallbacks callbacks, string openKey, bool writeMode)
{
_streamOperations = callbacks;
_writeMode = writeMode;
_newIO = true;
_alignment = (UInt16)ChunkSize.Alignment;
_stack = new List <ContextNode>();
_topContext = new ContextNode(0, 0);
_stack.AddHead(_topContext);
try {
_ioContext = _streamOperations.Open(openKey, writeMode);
} catch (Exception ex) {
throw ex;
}
}
/// <summary>
/// Loads the command binding from the specified section.
/// </summary>
/// <param name="decoupledStorage"></param>
/// <param name="section"></param>
/// <returns>Returns true if this command was most recently selected.</returns>
public bool Load(DecoupledStorage decoupledStorage, string section)
{
_CustomData = decoupledStorage.ReadString(section, "CustomData", "");
_Command = decoupledStorage.ReadString(section, "Command", "");
_Comments = decoupledStorage.ReadString(section, "Comments", "");
_Parameters = decoupledStorage.ReadString(section, "Parameters", "");
_CtrlKeyDown = decoupledStorage.ReadBoolean(section, "CtrlKeyDown", false);
_AnyShiftModifier = decoupledStorage.ReadBoolean(section, "AnyShiftModifier", false);
_AltKeyDown = decoupledStorage.ReadBoolean(section, "AltKeyDown", false);
_ShiftKeyDown = decoupledStorage.ReadBoolean(section, "ShiftKeyDown", false);
_Enabled = decoupledStorage.ReadBoolean(section, "Enabled", true);
_Context.Load(decoupledStorage, section, "Context");
_ContextRoot = new ContextNode(_Context.Selected);
return(decoupledStorage.ReadBoolean(section, "Selected", false));
}
public string GetReadableContext(ContextNameDecorator decorator)
{
string lResult = "";
if (_ContextRoot == null)
{
if (_Context == null)
{
lResult = "";
}
_ContextRoot = new ContextNode(_Context.Selected);
}
lResult = _ContextRoot.GetReadableContext(_Context, decorator);
return(lResult);
}
private static void Inline(ExcelRaw.Range toInline, Context toInlineCtx, ContextNode toInlineAST)
{
// Gather dependencies
var dependencies = InlineFormula.GetAllDirectDependents(toInline);
var toInlineAddress = Helper.ParseCtx(toInline.Address[false, false], toInlineCtx);
var errors = new List <Exception>();
foreach (ExcelRaw.Range dependent in dependencies)
{
try
{
var dependentAST = Helper.ParseCtx(dependent);
if (dependentAST.Node == null)
{
throw new InvalidOperationException($"Could not parse formula of {dependent.SheetAndAddress()}");
}
var newFormula = dependentAST.Replace(toInlineAddress, toInlineAST);
try
{
dependent.Formula = "=" + newFormula.Print();
}
catch (COMException e)
{
throw new InvalidOperationException(
$"Refactoring produced invalid formula '={newFormula.Print()}' from original formula '{dependentAST.Print()}' for cell {dependent.SheetAndAddress()}",
e);
}
}
catch (Exception e)
{
errors.Add(e);
}
finally
{
Marshal.ReleaseComObject(dependent);
}
}
if (errors.Count > 0)
{
throw new AggregateException(
$"Could not replace references with name in all dependents:\n{String.Join("\n", errors.Select(e => e.Message))}",
errors);
}
}
public void ContextHasExpectedParts()
{
GraphView graphView = new GraphView(null, null, "");
var nodeModel = new ContextNodeModel();
nodeModel.DefineNode();
var context = new ContextNode();
context.SetupBuildAndUpdate(nodeModel, null, graphView);
Assert.IsNotNull(context.SafeQ <VisualElement>(CollapsibleInOutNode.topPortContainerPartName), "Top vertical port Container part was expected but not found");
Assert.IsNotNull(context.SafeQ <VisualElement>(CollapsibleInOutNode.titleIconContainerPartName), "Title part was expected but not found");
Assert.IsNotNull(context.SafeQ <VisualElement>(Node.portContainerPartName), "Horizontal Port Container part was expected but not found");
Assert.IsNotNull(context.SafeQ <VisualElement>(ContextNode.blocksPartName), "Blocks part was expected but not found");
Assert.IsNotNull(context.SafeQ <VisualElement>(CollapsibleInOutNode.bottomPortContainerPartName), "Bottom vertical Port Container part was expected but not found");
}
private static bool strokeIsHorizontalLine(Stroke stroke)
{
InkAnalyzer temp = new InkAnalyzer();
temp.AddStroke(stroke);
temp.Analyze();
ContextNode node = temp.RootNode.SubNodes[0];
if (node is InkDrawingNode)
{
InkDrawingNode drawing = node as InkDrawingNode;
PointCollection boundingBox = drawing.GetRotatedBoundingBox();
double d1 = distSquared(boundingBox[0], boundingBox[1]);
double d2 = distSquared(boundingBox[1], boundingBox[2]);
return((d2 > 0 && d1 / d2 > 10 * 10 && d1 > 100 && Math.Abs(slope(boundingBox[0], boundingBox[1])) < 0.5) ||
(d1 > 0 && d2 / d1 > 10 * 10 && d2 > 100 && Math.Abs(slope(boundingBox[1], boundingBox[2])) < 0.5));
}
return(false);
}
public static void MergeParagraphs(InkAnalyzer inkAnalyzer)
{
foreach (ContextNode writingRegion in inkAnalyzer.RootNode.SubNodes)
{
List <ParagraphAnalysisEntry> paragraphs = new List <ParagraphAnalysisEntry>();
foreach (ContextNode node in writingRegion.SubNodes)
{
if (node is ParagraphNode)
{
ParagraphNode paragraph = node as ParagraphNode;
ContextNode firstLine = paragraph.SubNodes[0];
Point paragraphReference = firstLine.Strokes.GetBounds().TopLeft;
ParagraphAnalysisEntry entry = new ParagraphAnalysisEntry();
entry.paragraph = paragraph;
entry.point = paragraphReference;
paragraphs.Add(entry);
}
}
paragraphs.Sort(delegate(ParagraphAnalysisEntry a, ParagraphAnalysisEntry b)
{
return(a.point.Y.CompareTo(b.point.Y));
});
for (int i = 0; i < paragraphs.Count - 1; i++)
{
ParagraphAnalysisEntry entry = paragraphs[i];
ParagraphAnalysisEntry next = paragraphs[i + 1];
bool closeto = entry.closeTo(next);
if (closeto)
{
foreach (ContextNode node in next.paragraph.SubNodes)
{
node.Reparent(entry.paragraph);
}
writingRegion.DeleteSubNode(next.paragraph);
paragraphs[i + 1] = entry;
}
}
}
}
/// <summary>
/// Dispose the <see cref="IFFParser"/>.
/// </summary>
/// <param name="disposing">If set to <c>true</c> disposing.</param>
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
var result = 0L;
var top = (ContextNode)null;
var ci = (ContextInfoNode)null;
while (GetCurrentContext() != null)
{
result = PopChunkRead();
if (result < 0)
{
while ((top = GetCurrentContext()) != null)
{
FreeContextNode(top);
}
}
}
/* also do the master context */
while (_topContext.ContextInfoNodes.Count > 0)
{
ci = _topContext.ContextInfoNodes.RemoveHead();
PurgeContextInfoNode(ci);
}
if (result >= 0)
{
result = _streamOperations.Close(_ioContext);
}
else
{
_streamOperations.Close(_ioContext);
}
_topContext.Dispose();
_topContext = null;
}
_disposed = true;
}
}
private XmlNodeList SelectNodes()
{
XmlNamespaceManager nsMgr = NamespaceManager;
XmlNodeList nodes = null;
try
{
if (nsMgr != null)
{
nodes = ContextNode.SelectNodes(XPath, nsMgr);
}
else
{
nodes = ContextNode.SelectNodes(XPath);
}
}
catch (XPathException xe)
{
Status = BindingStatusInternal.PathError;
if (TraceData.IsEnabled)
{
TraceData.TraceAndNotify(TraceEventType.Error, TraceData.CannotGetXmlNodeCollection, ParentBindingExpression,
traceParameters: new object[] { (ContextNode != null) ? ContextNode.Name : null, XPath, ParentBindingExpression, xe },
eventParameters: new object[] { xe });
}
}
if (TraceData.IsExtendedTraceEnabled(ParentBindingExpression, TraceDataLevel.GetValue))
{
TraceData.TraceAndNotifyWithNoParameters(TraceEventType.Warning,
TraceData.SelectNodes(
TraceData.Identify(ParentBindingExpression),
IdentifyNode(ContextNode),
TraceData.Identify(XPath),
IdentifyNodeList(nodes)),
ParentBindingExpression);
}
return(nodes);
}
/// <summary>
/// Attaches the context info.
/// </summary>
/// <param name="contextNode">Context node.</param>
/// <param name="contextInfoNode">Context info node.</param>
public void AttachContextInfo(ContextNode contextNode, ContextInfoNode contextInfoNode)
{
uint type = contextInfoNode.Type,
id = contextInfoNode.Id,
identifier = contextInfoNode.Identifier;
var contextInfoNodesToDelete = new List <ContextInfoNode> ();
foreach (var ci in contextNode.ContextInfoNodes)
{
if (ci.Id == id && ci.Type == type && ci.Identifier == identifier)
{
contextInfoNodesToDelete.AddHead(ci);
}
}
foreach (var ci in contextInfoNodesToDelete)
{
contextNode.ContextInfoNodes.Remove(ci);
PurgeContextInfoNode(ci);
}
contextNode.ContextInfoNodes.AddHead(contextInfoNode);
}
// http://msdn.microsoft.com/en-us/library/system.windows.ink.contextnode(v=vs.90).aspx
private void BuildTree(ContextNode parentCNode, TreeViewItem parentTNode)
{
parentTNode.IsExpanded = true;
foreach (ContextNode cNode in parentCNode.SubNodes)
{
// Create new tree node corresponding to context node.
TreeViewItem tNode = new TreeViewItem();
tNode.Tag = cNode;
tNode.Header = cNode.ToString();
if (cNode is InkWordNode)
{
tNode.Header += ": " + (cNode as InkWordNode).GetRecognizedString();
}
else if (cNode is InkDrawingNode)
{
tNode.Header += ": " + (cNode as InkDrawingNode).GetShapeName();
}
if (cNode.IsConfirmed(ConfirmationType.NodeTypeAndProperties))
{
tNode.Header += "Confirmed.";
}
parentTNode.Items.Add(tNode);
BuildTree(cNode, tNode);
}
}
/// <summary>
/// InkAnalysis results form a tree, this method is called recursively
/// to render each node in the tree.
/// </summary>
private void DrawFeedback(DrawingContext drawingContext, ContextNode contextNode)
{
//see what type of ContextNode this is by casting it
Rect nodeBounds = contextNode.Strokes.GetBounds();
InkWordNode inkWordNode = contextNode as InkWordNode;
if (inkWordNode != null)
{
drawingContext.DrawRoundedRectangle(null, new Pen(Brushes.Blue, 1.0d), nodeBounds, 1d, 1d);
drawingContext.DrawText(new FormattedText(inkWordNode.GetRecognizedString(),
CultureInfo.CurrentCulture,
FlowDirection.LeftToRight,
new Typeface("Verdana"),
9.0d,
Brushes.Black),
nodeBounds.BottomLeft);
//check current output value
CheckOutputValue(contextNode.Strokes, inkWordNode.GetRecognizedString());
goto recurse;
}
InkDrawingNode inkDrawingNode = contextNode as InkDrawingNode;
if (inkDrawingNode != null)
{
drawingContext.DrawRoundedRectangle(null, new Pen(Brushes.Purple, 1.0d), nodeBounds, 1d, 1d);
drawingContext.DrawText(new FormattedText("Drawing: " + inkDrawingNode.GetShapeName(),
CultureInfo.CurrentCulture,
FlowDirection.LeftToRight,
new Typeface("Verdana"),
9.0d,
Brushes.Black),
nodeBounds.BottomLeft);
CheckOutputValue(contextNode.Strokes, inkDrawingNode.GetShapeName());
goto recurse;
}
InkBulletNode inkBulletNode = contextNode as InkBulletNode;
if (inkBulletNode != null)
{
drawingContext.DrawRoundedRectangle(null, new Pen(Brushes.Green, 1.0d), nodeBounds, 1d, 1d);
drawingContext.DrawText(new FormattedText(inkBulletNode.GetRecognizedString(),
CultureInfo.CurrentCulture,
FlowDirection.LeftToRight,
new Typeface("Verdana"),
9.0d,
Brushes.Black),
nodeBounds.BottomLeft);
goto recurse;
}
WritingRegionNode writingRegionNode = contextNode as WritingRegionNode;
if (writingRegionNode != null)
{
nodeBounds.Inflate(3d, 3d);
drawingContext.DrawRoundedRectangle(null, new Pen(Brushes.Black, 1.0d), nodeBounds, 1d, 1d);
drawingContext.DrawText(new FormattedText("Writing Region",
CultureInfo.CurrentCulture,
FlowDirection.LeftToRight,
new Typeface("Verdana"),
9.0d,
Brushes.Black),
nodeBounds.BottomLeft + new Vector(0, 3));
goto recurse;
}
ParagraphNode paragraphNode = contextNode as ParagraphNode;
if (paragraphNode != null)
{
nodeBounds.Inflate(2d, 2d); //inflate so this will be visible outside the line node
drawingContext.DrawRoundedRectangle(null, new Pen(Brushes.Red, 1.0d), nodeBounds, 1d, 1d);
goto recurse;
}
LineNode lineNode = contextNode as LineNode;
if (lineNode != null)
{
nodeBounds.Inflate(1d, 1d); //inflate so this will be visible outside the word node
drawingContext.DrawRoundedRectangle(null, new Pen(Brushes.Orange, 1.0d), nodeBounds, 1d, 1d);
goto recurse;
}
recurse:
foreach (ContextNode subNode in contextNode.SubNodes)
{
DrawFeedback(drawingContext, subNode);
}
}
private void GenerateBoundingBoxes(ContextNode node = null)
{
if (node == null)
{
OverlayInkCanvas.Strokes.Clear();
node = inkAnalyzer.RootNode;
}
PointCollection boundingBox = null;
Color strokeColor = Colors.Black;
if (node is InkWordNode)
{
boundingBox = (node as InkWordNode).GetRotatedBoundingBox();
strokeColor = Colors.Azure;
}
else if (node is LineNode)
{
boundingBox = (node as LineNode).GetRotatedBoundingBox();
strokeColor = Colors.Lime;
}
else if (node is ParagraphNode)
{
boundingBox = (node as ParagraphNode).GetRotatedBoundingBox();
strokeColor = Colors.Magenta;
}
else if (node is InkDrawingNode)
{
boundingBox = (node as InkDrawingNode).GetRotatedBoundingBox();
strokeColor = Colors.Gold;
}
if (boundingBox != null)
{
StrokeCollection collection = new StrokeCollection();
// Copy of the points for wrapping.
boundingBox.Add(boundingBox[0]);
for (int i = 0; i < boundingBox.Count - 1; i++)
{
StylusPointCollection points = new StylusPointCollection();
StylusPoint point1 = new StylusPoint(boundingBox[i].X, boundingBox[i].Y, 1.0f);
StylusPoint point2 = new StylusPoint(boundingBox[i + 1].X, boundingBox[i + 1].Y, 1.0f);
points.Add(point1);
points.Add(point2);
Stroke stroke = new Stroke(points);
stroke.DrawingAttributes.IsHighlighter = true; // for transparency
stroke.DrawingAttributes.Color = strokeColor;
collection.Add(stroke);
}
OverlayInkCanvas.Strokes.Add(collection);
}
// Recurse
foreach (ContextNode child in node.SubNodes)
GenerateBoundingBoxes(child);
}
private void MarkNodeAsRed(ContextNode cNode)
{
foreach (Stroke stroke in MainInkCanvas.Strokes)
stroke.DrawingAttributes.Color = Colors.Black;
foreach (Stroke stroke in cNode.Strokes)
stroke.DrawingAttributes.Color = Colors.Red;
}
