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); }