bool IsRightChild(tree_node *Node)
{
if(Node && IsLeafNode(Node))
{
tree_node *Parent = Node->Parent;
return Parent->RightChild == Node;
}
return false;
}
tree_node *GetNearestTreeNodeToTheRight(tree_node *Node)
{
if(Node)
{
if(Node->Parent)
{
tree_node *Root = Node->Parent;
if(Root->RightChild == Node)
return GetNearestTreeNodeToTheRight(Root);
if(IsLeafNode(Root->RightChild))
return Root->RightChild;
Root = Root->RightChild;
while(!IsLeafNode(Root->LeftChild))
Root = Root->LeftChild;
return Root->LeftChild;
}
}
return NULL;
}
int sprintTriePath(CTXTdeclc char * buffer, BTNptr pLeaf) {
BTNptr pRoot;
int ctr = 0;
if ( IsNULL(pLeaf) ) {
return sprintf(buffer, "NULL");
}
if ( ! IsLeafNode(pLeaf) ) {
fprintf(stderr, "printTriePath() called with non-Leaf node!\n");
printTrieNode(stderr, pLeaf);
return -1;
}
if (IsEscapeNode(pLeaf) ) {
// printf("escape\n");
pRoot = BTN_Parent(pLeaf);
if ( IsNonNULL(pRoot) ) {
ctr = ctr + sprintTrieSymbol(buffer+ctr, BTN_Symbol(pRoot));
return ctr;
}
else {
fprintf(stderr, "ESCAPE node");
return 0;
}
}
SymbolStack_ResetTOS;
SymbolStack_PushPathRoot(pLeaf,pRoot);
if ( IsTrieFunctor(BTN_Symbol(pRoot)) ) {
// printf("tf\n");
SymbolStack_Push(BTN_Symbol(pRoot));
ctr = ctr + symstkSPrintNextTerm(CTXTc buffer+ctr,FALSE);
}
else {
// printf("nontf\n");
ctr = ctr + sprintTrieSymbol(buffer+ctr,BTN_Symbol(pRoot));
ctr = ctr + sprintf(buffer+ctr, "(");
ctr = ctr + symstkSPrintNextTerm(CTXTc buffer+ctr,FALSE);
while ( ! SymbolStack_IsEmpty ) {
ctr = ctr + sprintf(buffer+ctr, ",");
ctr = ctr + symstkSPrintNextTerm(CTXTc buffer+ctr,FALSE);
}
ctr = ctr + sprintf(buffer+ctr, ")");
}
return ctr;
}
void ExtractLeafDLL(struct TNode* root,struct TNode** head){
if(!root){
return;
}
if(root->left){
ExtractLeafDLL(root->left,&(*head));
}
if(IsLeafNode(root)){
InsertDLL(&(*head),root);
return;
}
if(root->right){
ExtractLeafDLL(root->right,&(*head));
}
}
void printTriePath(FILE *fp, BTNptr pLeaf, xsbBool printLeafAddr) {
BTNptr pRoot;
if ( IsNULL(pLeaf) ) {
fprintf(fp, "NULL");
return;
}
if ( ! IsLeafNode(pLeaf) ) {
fprintf(fp, "printTriePath() called with non-Leaf node!\n");
printTrieNode(fp, pLeaf);
return;
}
if ( printLeafAddr )
fprintf(fp, "Leaf %p: ", pLeaf);
if ( IsEscapeNode(pLeaf) ) {
pRoot = BTN_Parent(pLeaf);
if ( IsNonNULL(pRoot) )
printTrieSymbol(fp, BTN_Symbol(pRoot));
else
fprintf(fp, "ESCAPE node");
return;
}
SymbolStack_ResetTOS;
SymbolStack_PushPathRoot(pLeaf,pRoot);
if ( IsTrieFunctor(BTN_Symbol(pRoot)) ) {
SymbolStack_Push(BTN_Symbol(pRoot));
symstkPrintNextTerm(fp,FALSE);
}
else {
printTrieSymbol(fp,BTN_Symbol(pRoot));
fprintf(fp, "(");
symstkPrintNextTerm(fp,FALSE);
while ( ! SymbolStack_IsEmpty ) {
fprintf(fp, ",");
symstkPrintNextTerm(fp,FALSE);
}
fprintf(fp, ")");
}
}
//function for finding leaf nodes recursively
void DecisionTree::FindLeafNodes(Node* pSubRootNode)
{
/* first caller must do clearing vpLeafNodes vector */
if (IsLeafNode(pSubRootNode))
{
vpLeafNodes.push_back(pSubRootNode);
return;
}
else
{
if (pSubRootNode->plChild)
{
FindLeafNodes(pSubRootNode->plChild);
}
if (pSubRootNode->prChild)
{
FindLeafNodes(pSubRootNode->prChild);
}
}
}
//function for destructing nodes recursively
void DecisionTree::Destroyer(Node* pSubRootNode)
{
if (IsLeafNode(pSubRootNode))
{
delete pSubRootNode;
pSubRootNode = nullptr;
return;
}
else
{
if (pSubRootNode->plChild)
{
Destroyer(pSubRootNode->plChild);
}
if (pSubRootNode->prChild)
{
Destroyer(pSubRootNode->prChild);
}
delete pSubRootNode;
pSubRootNode = nullptr;
}
}
void RotateTree(tree_node *Node, int Deg)
{
if (Node == NULL || IsLeafNode(Node))
return;
DEBUG("RotateTree() " << Deg << " degrees");
if((Deg == 90 && Node->SplitMode == SPLIT_VERTICAL) ||
(Deg == 270 && Node->SplitMode == SPLIT_HORIZONTAL) ||
Deg == 180)
{
tree_node *Temp = Node->LeftChild;
Node->LeftChild = Node->RightChild;
Node->RightChild = Temp;
Node->SplitRatio = 1 - Node->SplitRatio;
}
if(Deg != 180)
Node->SplitMode = Node->SplitMode == SPLIT_HORIZONTAL ? SPLIT_VERTICAL : SPLIT_HORIZONTAL;
RotateTree(Node->LeftChild, Deg);
RotateTree(Node->RightChild, Deg);
}
void ToggleFocusedNodeSplitMode()
{
ax_display *Display = AXLibMainDisplay();
space_info *SpaceInfo = &WindowTree[Display->Space->Identifier];
if(!FocusedApplication)
return;
ax_window *Window = FocusedApplication->Focus;
if(!Window)
return;
tree_node *Node = GetTreeNodeFromWindowID(SpaceInfo->RootNode, Window->ID);
if(!Node)
return;
tree_node *Parent = Node->Parent;
if(!Parent || IsLeafNode(Parent))
return;
Parent->SplitMode = Parent->SplitMode == SPLIT_VERTICAL ? SPLIT_HORIZONTAL : SPLIT_VERTICAL;
CreateNodeContainers(Display, Parent, false);
ApplyTreeNodeContainer(Parent);
}
void ModifyContainerSplitRatio(double Offset, int Degrees)
{
if(!FocusedApplication)
return;
ax_window *Window = FocusedApplication->Focus;
if(!Window)
return;
ax_display *Display = AXLibWindowDisplay(Window);
space_info *SpaceInfo = &WindowTree[Display->Space->Identifier];
tree_node *Root = SpaceInfo->RootNode;
if(!Root || IsLeafNode(Root) || Root->WindowID != 0)
return;
tree_node *Node = GetTreeNodeFromWindowIDOrLinkNode(Root, Window->ID);
if(Node)
{
ax_window *ClosestWindow = NULL;
if(FindClosestWindow(Degrees, &ClosestWindow, false))
{
tree_node *Target = GetTreeNodeFromWindowIDOrLinkNode(Root, ClosestWindow->ID);
tree_node *Ancestor = FindLowestCommonAncestor(Node, Target);
if(Ancestor)
{
if(!(Node == Ancestor->LeftChild || IsLeftChildInSubTree(Ancestor->LeftChild, Node)))
Offset = -Offset;
double NewSplitRatio = Ancestor->SplitRatio + Offset;
SetContainerSplitRatio(NewSplitRatio, Node, Ancestor, Display, true);
}
}
}
}
bool IsPseudoNode(tree_node *Node)
{
return Node && Node->WindowID == 0 && IsLeafNode(Node);
}
