/// <summary>
/// sets the inital angle if datacontext is a ContentControl and if the Canvas was found.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void RotateThumb_DragStarted(object sender, VectorEventArgs e)
{
_designerItem = DataContext as ContentControl;
if (_designerItem != null)
{
_canvas = TreeExtensions.TryFindParent <Canvas>(_designerItem);
if (_canvas != null)
{
_centerPoint = (Point)_designerItem.TranslatePoint(
new Point(_designerItem.Width * _designerItem.RenderTransformOrigin.Point.X,
_designerItem.Height * _designerItem.RenderTransformOrigin.Point.Y),
_canvas);
Point startPoint = VisualExtensions.
PointToClient(_canvas, new PixelPoint((int)e.Vector.X, (int)e.Vector.Y));
_startVector = startPoint - _centerPoint;
_rotateTransform = _designerItem.RenderTransform as RotateTransform;
if (_rotateTransform == null)
{
_designerItem.RenderTransform = new RotateTransform(0);
_initialAngle = 0;
}
else
{
_initialAngle = _rotateTransform.Angle;
}
}
}
}
public void CreateTree()
{
var bar0 = new Bar(1, null);
var bar1 = new Bar(2, null);
var bar0_0 = new Bar(3, 1);
var bar0_1 = new Bar(4, 1);
var bar_0_0_0 = new Bar(5, 3);
var list = new List <Bar>()
{
bar0,
bar1,
bar0_0,
bar0_1,
bar_0_0_0
};
//Create the tree
var tree = TreeExtensions.CreateTree(list.Where(b => b.ParentId == null),
list,
(p, c) => c.ParentId != null && c.ParentId.Value == p.Id);
Assert.Same(bar0, tree.Nodes[0].Item);
Assert.Same(bar1, tree.Nodes[1].Item);
Assert.Same(bar0_1, tree.Nodes[0].Nodes[1].Item);
}
public void CheckHeight_Unbalanced_MinValue()
{
var actual = TreeExtensions.CheckHeight(CreateTwoLevelsUnbalanced());
Assert.AreEqual(int.MinValue, actual);
actual = TreeExtensions.CheckHeight(CreateThreeLevelsUnbalanced());
Assert.AreEqual(int.MinValue, actual);
}
public void IsBalanced_Unbalanced_False()
{
var actual = TreeExtensions.IsBalanced(CreateTwoLevelsUnbalanced());
Assert.AreEqual(false, actual);
actual = TreeExtensions.IsBalanced(CreateThreeLevelsUnbalanced());
Assert.AreEqual(false, actual);
}
public void ListOfDepths_OneNode_One()
{
var tree = CreateOneNode();
var actual = TreeExtensions.CreateListOfDepths(tree);
Assert.AreEqual(1, actual.Count);
Assert.AreEqual(0, actual[0].First.Value.Value);
}
public void CheckBST_NonBST_False()
{
var actual = TreeExtensions.CheckBST(CreateTwoLevelsNonBST());
Assert.AreEqual(false, actual);
actual = TreeExtensions.CheckBST(CreateThreeLevelsNonBST());
Assert.AreEqual(false, actual);
}
public void ListOfDepths_TwoLevels_ExpectedResult()
{
var tree = CreateTwoLevels();
var actual = TreeExtensions.CreateListOfDepths(tree);
Assert.AreEqual(2, actual.Count);
Assert.AreEqual(0, actual[0].First.Value.Value);
Assert.AreEqual(1, actual[1].First.Value.Value);
Assert.AreEqual(2, actual[1].First.Next.Value.Value);
}
/// <summary>
/// function for moving the control
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
private void ProcessMove(double x, double y)
{
var width = _partOverlay./*RenderSize.*/ Width;
var height = _partOverlay./*RenderSize.*/ Height;
var offset = TreeExtensions.GetOffsetFrom(this, _partWindow);
//var offset = VisualTreeHelper.GetOffset(this.partWindow);
//todo correct me
var widthOffset = offset.M11; // offset.X;
var heightOffset = offset.M12; //offset.Y;
var realX = _moveTransform.X + x + widthOffset;
var realY = _moveTransform.Y + y + heightOffset;
const int extraGap = 5;
var widthGap = Math.Max(_icon?./*Actual*/ Width + 5 ?? 30, 30);
var heightGap = Math.Max(this.TitleBarHeight, 30);
var changeX = _moveTransform.X;
var changeY = _moveTransform.Y;
if (realX < (0 + extraGap))
{
changeX = -widthOffset + extraGap;
}
else if (realX > (width - widthGap - extraGap))
{
changeX = width - widthOffset - widthGap - extraGap;
}
else
{
changeX += x;
}
if (realY < (0 + extraGap))
{
changeY = -heightOffset + extraGap;
}
else if (realY > (height - heightGap - extraGap))
{
changeY = height - heightOffset - heightGap - extraGap;
}
else
{
changeY += y;
}
if (!Equals(changeX, _moveTransform.X) || !Equals(changeY, _moveTransform.Y))
{
this.SetValue(OffsetXProperty, changeX);
this.SetValue(OffsetYProperty, changeY);
this.InvalidateArrange();
}
}
public void CheckHeight_Balanced_Zero()
{
var actual = TreeExtensions.CheckHeight(CreateOneNode());
Assert.AreEqual(0, actual);
actual = TreeExtensions.CheckHeight(CreateTwoLevels());
Assert.AreEqual(1, actual);
actual = TreeExtensions.CheckHeight(CreateThreeLevels());
Assert.AreEqual(2, actual);
}
public void IsBalanced_Balanced_True()
{
var actual = TreeExtensions.IsBalanced(CreateOneNode());
Assert.AreEqual(true, actual);
actual = TreeExtensions.IsBalanced(CreateTwoLevels());
Assert.AreEqual(true, actual);
actual = TreeExtensions.IsBalanced(CreateThreeLevels());
Assert.AreEqual(true, actual);
}
public void CheckBST_BST_True()
{
var actual = TreeExtensions.CheckBST(CreateOneNode());
Assert.AreEqual(true, actual);
actual = TreeExtensions.CheckBST(CreateTwoLevels());
Assert.AreEqual(true, actual);
actual = TreeExtensions.CheckBST(CreateThreeLevels());
Assert.AreEqual(true, actual);
}
/// <summary>
/// sets the Angle tot he rotate transform if not null
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ResizeThumb_DragStarted(object sender, VectorEventArgs e)
{
_designerItem = DataContext as ContentControl;
if (_designerItem != null)
{
_canvas = TreeExtensions.TryFindParent <Canvas>(_designerItem);
if (_canvas != null)
{
_transformOrigin = _designerItem.RenderTransformOrigin;
_rotateTransform = _designerItem.RenderTransform as RotateTransform;
if (_rotateTransform != null)
{
_angle = _rotateTransform.Angle * Math.PI / 180.0;
}
else
{
_angle = 0.0d;
}
}
}
}
private int[] UwzglednijPoziomyZagniezdzone(int aktualnyPoziom, bool uwzglednijBrygady)
{
#region przygotowanie drzewa
List <TreeNode> _nodes = new List <TreeNode>();
if (uwzglednijBrygady)
{
var wydzialy = context.Wydzialy;
foreach (Wydzial w in wydzialy)
{
_nodes.Add(new TreeNode {
id = w.ID, text = w.Nazwa, parent = w.IDParent.ToString()
});
}
Tree tree = TreeBuilder.BuildTree(_nodes);
// dodanie podległych działów do wyniku - potomków w drzewie
Tree y = TreeExtensions.FindNode(tree, aktualnyPoziom);
List <Tree> x = TreeExtensions.Descendants(y).ToList();
return(x.Select(t => ( int )t.Id).ToArray());
}
else
{
var wydzialy = context.Wydzialy.Where(w => w.IsBrygada == uwzglednijBrygady);
foreach (Wydzial w in wydzialy)
{
_nodes.Add(new TreeNode {
id = w.ID, text = w.Nazwa, parent = w.IDParent.ToString()
});
}
Tree tree = TreeBuilder.BuildTree(_nodes);
// dodanie podległych działów do wyniku - potomków w drzewie
Tree y = TreeExtensions.FindNode(tree, aktualnyPoziom);
List <Tree> x = TreeExtensions.Descendants(y).ToList();
return(x.Select(t => ( int )t.Id).ToArray());
}
#endregion
}
static void Main(string[] args)
{
TreeExtensions.ReadTree();
Console.WriteLine(/*Method name goes here*/);
}
public static IReadOnlyCollection <ChainNode> ListLeafPaths(ChainNode node) => TreeExtensions.ListLeafPaths(meta, node);
public static IReadOnlyCollection <string> ListXPaths(ChainNode node) => TreeExtensions.ListXPaths(meta, node);
public static bool IsSubTreeOf(ChainNode node1, ChainNode node2) => TreeExtensions.IsSubTreeOf(meta, node1, node2);
public static ChainNode Merge(ChainNode node1, ChainNode node2) => TreeExtensions.Merge(meta, node1, node2);
public static ChainNode FindLinkedRootPath(ChainMemberNode node) => TreeExtensions.FindLinkedRootPath(meta, node);
public static bool IsEqualTo(ChainNode node1, ChainNode node2) => TreeExtensions.IsEqualTo(meta, node1, node2);
public static string[] FindLinkedRootKeyPath(ChainNode node) => TreeExtensions.FindLinkedRootKeyPath(meta, node);
public static bool FindNode(ChainNode root, string[] path, out ChainMemberNode node) => TreeExtensions.FindNode(meta, root, path, out node);
public void CheckHeight_Null_NegativeOne()
{
var actual = TreeExtensions.CheckHeight <int>(null);
Assert.AreEqual(-1, actual);
}
public void CheckBST_Null_True()
{
var actual = TreeExtensions.CheckBST(null);
Assert.AreEqual(true, actual);
}
public void ListOfDepths_Null_Null()
{
var actual = TreeExtensions.CreateListOfDepths <int>(null);
Assert.AreEqual(null, actual);
}
