Add documentation

Author: Tajfun403

Algorithms/BinTree.cs

@@ -381,7 +381,7 @@ public async Task SwapValues(Node<T> one, Node<T> other)
     /// Delete specified node from the tree.<para/>
     /// You can find the node first with <see cref="Find(T)"/>
     /// </summary>
-    /// <param name="currNode">Node to delete</param>
+    /// <param name="victim">Node to delete</param>
     /// <returns></returns>
     public async Task Delete(Node<T> victim)
     {

Docs/Documentation.pdf

@@ -7,6 +7,8 @@ Operations to support:
 - Find min
 - Find max
 
+Should ship with documentation that focuses on the properties of binary trees and used data structured, with documentation of the UI implementation being a secondary target.
+
 # Roadmap
 Project requirements:
 - [ X ] Initial UI setup

Docs/Notes.md

@@ -0,0 +1,38 @@
+# Project overview
+## Base BST
+The binary search tree is build out of nodes - starting by root, each of the subsequent children can have two children of their own.  
+The base property of the binary tree which allows for O(log n) search is the way the children nodes are placed - nodes smaller than their parent are placed on the left, and nodes bigger than their parent - on the right. Thanks to this, the area of tree which needs to be searched is effectively halved with each recursive iterations (assuming the tree is balanced well enough).
+### Insertion
+- Proceed like with normal search, then if a spot is found where the search would continue but the spot is empty - insert a new node into it.
+### Search
+- Follow the tree with the principle of going left if the searched value is smaller than the current node, and right if the searched value is bigger. 
+- Check if the current is the searched node if neither of those paths can be taken.
+### Deletion
+- Find an item to delete. 
+- Next, try to find its successor - the next element which is minimally smaller than the current one (that can be obtained by going one to right and then max to left, thanks to binary tree properties). 
+- Once a successor is found, swap the victim with the succesor, and then remove the victim whose been moved out of the original location. 
+- If the victim is not placed in a leaf position (i.e. having no children), repeat finding a successor and swapping until a leaf node is reached which can then be removed safely. 
+
+## AVL
+AVL tree is a type of a binary search tree. It operates on the same base princinple regarding to the location of nodes, but with an additional mechanic - rotations.  
+Whenever a subtree becomes unbalances - i.e. one of its sides is at least two nodes taller than the other one - a node with the middle value is picked out of the long branch, and then the other nodes from this branch are balanced around it.  
+Thanks to this, a normally successive chain (eg. 1 -> 2 -> 3) becomes a neatly balanced, smaller tree (with node {2} pointing to {1} to the left and to {3} to the right).
+
+Operations on AVL trees start exactly the same way as on base BSTs, but then after a node is either inserted or removed, all parents of the affected node are visitied to make sure the tree is kept in balance, and rotations are performed if they are not.
+ 
+## App structure
+The application is written utilizing C# 13 preview language, .NET 9.0 framework, as well as WPF framework for the UI.  
+The tree is layouted using a modified Wetherell and Shannon algorithm.  
+It uses Material Design (http://materialdesigninxaml.net/) NuGet package for the interface theme, as well as ScottPlot library (https://scottplot.net/) for rendering the collected performance data into graphs.  
+The tree's logical data structures are partially separated from the WPF elements and use a composite model.
+- `BinTree<T>` and `Node<T>` are the main data logical structures that hold the info about the binary tree and can perform operations on it. 
+- `TreeLayout` is a helper class that can auto-layout the tree.
+- `BinTreeMan` is a WPF page which holds the main user interface and delegates operations requested by user to the binary tree.
+- `BinTreeControl` is a WPF UserControl that holds Canvas where the nodes are physically placed into
+- `NodeControl` is a WPF UserControl that represents a visual node - each `NodeControl` is directly managed by a `Node<T>` it is associated with, and physically placed upon `BinTreeControl`'s Canvas
+- `NodeArrow` is a WPF UserControl that represents and arrow that can point from one point into another. Each `Node<T>` manages an arrow pointing towards it.
+- `ProgressLabel` is a WPF Control that is used for displaying descriptions.
+- `TreeStats` and `StatsWindow.xaml` are classes used for gathering and displaying the statistics respectively.
+
+Documentation PDF is generated with Doxygen.  
+Detailed descriptions of each of the classes, methods, and properties used in the program are contained in the following chapters of the documentation PDF.

Docs/ProjectOverview.md

@@ -60,5 +60,20 @@ Total so far: 29 hours 20 minutes
 29-12 => 23h00 - 23h30 - fill in more documentation
 29-12 => 00h30 - 01h00 - check for tree being empty
 
+Time spent today: 1 hours 40 minutes
+Total so far: 31 hours 00 minutes
+
+====================================
+=============== 2025 ===============
+====================================
+
+02-12 => 10h00 - 10h10 - auto rescale tree on window resize
+
+Time spent today: 0 hours 10 minutes
+Total so far: 31 hours 10 minutes
+
+03-12 => 15h00 - 16h00 - add overview article as highlighted by requirements
+03-12 => 16h00 - 16h30 - generate documentation
+
 Time spent today: 1 hours 40 minutes
 Total so far: 31 hours 00 minutes

Docs/TimeSpent.ini

@@ -8,7 +8,7 @@ Supports:
 - Deletion
 - Search
 
-All steps performed during an algorithm's execution are described in the log, and all nodes associated with the particular sub-operation are highlighted - what enables clear and easy following of an algorithm.
+All steps performed during an algorithm's execution are described in the log, and all the nodes associated with the particular sub-operation are highlighted - which enables clear and easy following of an algorithm.
 
 ![Rotation screenshot](https://i.imgur.com/lVTFZxL.png)
 
@@ -26,4 +26,6 @@ This allows one to verify the algorithms' time complexity with real-world data.
 - The tree is auto-layouted using a modified Wetherell and Shannon algorithm for visually pleasant and efficient use of space 
 
 # Build
-Uses .NET 9.0 and C# 13 preview with WPF UI. To build with Visual Studio 2022.
+Uses .NET 9.0 and C# 13 preview with WPF UI. To build with Visual Studio 2022.  
+Utilizes [Material Design](http://materialdesigninxaml.net/) NuGet package for the interface theme, as well as [ScottPlot library](https://scottplot.net/) for rendering the collected performance data into graphs.  
+The interface is connected to the logical binary tree with a composite model, where `BinTree<T>` and `Node<T>` manage their respective `BinTreeControl` and `BinTreeNode` WPF controls, respectively.

Readme.md

@@ -217,6 +217,9 @@ protected virtual void OnPropertyChanged([CallerMemberName] string propertyName
         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
     }
 
+    /// <summary>
+    /// The last operation that was performed. It will be exeucted when pressing the Enter key.
+    /// </summary>
     Action<object, RoutedEventArgs> lastOperation;
 
     /// <summary>