CTreeNode* CTreeBuilder::TraverseTree(CTreeNode* parent, string nodePath, CTreeNode* pTempNode)
{
CTreeNode* n = NULL;
if (parent != NULL)
{
if ( parent->GetParent() == NULL && parent->GetNodePath() == nodePath)
{
pTempNode = parent;
}
else if(!parent->IsLeaf())
{
for (n = parent->GetChild(); n != NULL; n = n->GetSibling())
{
if(nodePath==n->GetNodePath())
{
pTempNode=n;
return n;
}
if (pTempNode==NULL && ! n->IsLeaf())
{
pTempNode=TraverseTree(n, nodePath,pTempNode);
}
}
}
}
return pTempNode; //parent;
}
CTreeNode* CTreeWnd::AddNode(LPCTSTR name,CTreeNode* pParent,short it /* = itDefault */)
{
if (!m_pTree)
return NULL;
mtNode* mtParent = pParent ? pParent->getmtNode() : NULL;
mtNode* pNode = m_pTree->newItem(name,mtParent);
if (pNode)
{
CTreeNode* pTreeNode = new CTreeNode();
pTreeNode->setTree(this);
pNode->setData((unsigned long)pTreeNode);
pTreeNode->setmtNode(pNode);
pTreeNode->setIconType( it );
//ForceLayout();
//Invalidate();
return pTreeNode;
}
else
return NULL;
}
bool CTree::MouseDoubleClicked(int code, int mx, int my)
{
if (CPanel::MouseDoubleClicked(code, mx, my))
return true;
m_iSelected = ~0;
for (size_t i = 0; i < m_ahAllNodes.size(); i++)
{
CBaseControl* pNode = m_ahAllNodes[i];
if (!pNode->IsVisible())
continue;
float x, y, w, h;
pNode->GetAbsDimensions(x, y, w, h);
if (mx >= x && my >= y && mx < x+w && my < y+h)
{
m_iSelected = i;
CTreeNode* pTreeNode = dynamic_cast<CTreeNode*>(pNode);
pTreeNode->Selected();
if (m_pfnConfirmedCallback)
m_pfnConfirmedCallback(m_pConfirmedListener, sprintf("%d", GetSelectedNodeId()));
return true;
}
}
return false;
}
bool CTree::MousePressed(int code, int mx, int my)
{
m_bMouseDown = true;
m_iMouseDownX = mx;
m_iMouseDownY = my;
if (CPanel::MousePressed(code, mx, my))
return true;
m_iSelected = ~0;
for (size_t i = 0; i < m_ahAllNodes.size(); i++)
{
CBaseControl* pNode = m_ahAllNodes[i];
if (!pNode->IsVisible())
continue;
float x, y, w, h;
pNode->GetAbsDimensions(x, y, w, h);
if (mx >= x && my >= y && mx < x+w && my < y+h)
{
m_iSelected = i;
CTreeNode* pTreeNode = dynamic_cast<CTreeNode*>(pNode);
pTreeNode->Selected();
return true;
}
}
if (m_pSelectedListener)
m_pfnSelectedCallback(m_pSelectedListener, "-1");
return false;
}
ETreeTraverseCode
operator()(CTreeNode<CBDB_QueryNode>& tr, int delta)
{
CBDB_QueryNode& qnode = tr.GetValue();
if (delta == 0 || delta == 1) {
// If node has children, we skip it and process on the way back
if (!tr.IsLeaf())
return eTreeTraverse;
}
if (qnode.GetType() == CBDB_QueryNode::eDBField)
return eTreeTraverse;
if (qnode.HasValue()) {
string& fvalue = qnode.GetValue();
int len = fvalue.length();
// if string value is in apostrophe marks: remove it
if (fvalue[0] == '\'' && fvalue[len-1] == '\'') {
len -= 2;
if (len) {
qnode.SetValue(fvalue.substr(1, len));
} else {
qnode.SetValue(kEmptyStr);
}
} else {
CBDB_File::TUnifiedFieldIndex fidx = m_File.GetFieldIdx(fvalue);
if (fidx) {
qnode.SetField(fidx);
}
}
}
return eTreeTraverse;
}
void CSoliDire::insert_file(CString filename)
{
CFile f(filename, CFile::modeRead);
if (f)
{
CInode tmp(f.GetFilePath(), 0, f.GetLength());
if (!m_DirTree->m_pRoot)
{
m_DirTree->m_pRoot = new CTreeNode;
m_DirTree->m_pRoot->set_inode(tmp);
}
else
{
CTreeNode * p = m_DirTree->m_pRoot;
while (p->has_rchild())
p = p->get_rchild();
p->new_rchild(tmp);
}
SetModifiedFlag(TRUE);
f.Close();
}
}
long CTreeWnd::GetScrollExtent(int nBar)
{
int extent = 0;
if (nBar == SB_HORZ)
{
for (int i = 0; i < m_pHeader->GetNumPanes(); i++)
{
extent += m_pHeader->GetPaneWidth(i);
}
}
else if (nBar == SB_VERT)
{
// vertical scroll size is total height of all expanded nodes...
CTreeNode* pNode = GetRootNode();
if (pNode && (!(m_style & MTS_SHOWROOT)))
pNode = pNode->FirstChild();
bool done = false;
while (pNode && !done)
{
//extent += DEF_NODE_HEIGHT;
extent++;
CTreeNode* pNext = pNode->NextNode();
if (pNext == pNode)
done = true;
else
pNode = pNext;
}
}
return extent;
}
void CTreeWnd::SetFirstVisibleNode()
{
m_firstVisibleIdx = 0;
int index = GetScrollPos32(SB_VERT);
CTreeNode* pNode = GetRootNode();
if (!pNode)
return;
if (!(m_style & MTS_SHOWROOT))
pNode = pNode->FirstChild();
m_firstVisible = pNode;
int pos = 0;
while (pNode && pos < index)
{
pos ++;//= DEF_NODE_HEIGHT;
pNode = pNode->NextNode();
if (pNode)
{
m_firstVisible = pNode;
m_firstVisibleIdx++;
}
}
}
unsigned int CTreeNode::GetDepth() const
{
CTreeNode * parent = GetParentNode();
if (parent)
return parent->GetDepth() + 1;
return 0;
}
CTreeNode* CTreeBuilder::BuildNode(NodeDetails nodeDetails)
{
CTreeNode* tempNode = new CTreeNode();
tempNode->SetNodeName(nodeDetails.name);
tempNode->SetNodeValue(nodeDetails.value);
tempNode->SetType(nodeDetails.type);
return tempNode;
}
string CTreeBuilder::GetAsString(string sSectionPath, string sDefaultValue)
{
string sNodeValue = sDefaultValue;
CTreeNode* pCurrentNode = NodeFind(sSectionPath);
if ( pCurrentNode!= NULL)
{
sNodeValue = pCurrentNode->GetNodeValue();
}
return sNodeValue;
}
bool RefreshChildren(const std::_tstring & qualifiedLabel, CTreeNode * startingNode)
{
CTreeNode * found = Locate(qualifiedLabel, startingNode, 0);
if (found)
{
found->Expand(TVE_COLLAPSE | TVE_COLLAPSERESET);
found->Expand();
return true;
}
return false;
}
float CTreeBuilder::GetAsFloat(string sSectionPath, float fDefaultValue)
{
string sNodeValue;
float fNodeValue = fDefaultValue;
CTreeNode* pCurrentNode = NodeFind(sSectionPath);
if ( pCurrentNode!= NULL)
{
sNodeValue = pCurrentNode->GetNodeValue();
}
from_string<float>(fNodeValue , sNodeValue, fixed);
return fNodeValue ;
}
CControlHandle CTree::AddControl(CBaseControl* pControl, bool bToTail)
{
CControlHandle hControl = BaseClass::AddControl(pControl, bToTail);
if (pControl != m_hVerticalScrollBar && pControl != m_hHorizontalScrollBar)
{
CTreeNode* pTreeNode = dynamic_cast<CTreeNode*>(pControl);
if (pTreeNode)
m_ahAllNodes.push_back(CControl<CTreeNode>(pTreeNode->GetHandle()));
}
return hControl;
}
bool Select(const std::_tstring & qualifiedLabel, CTreeNode * startingNode, bool bExpand)
{
CTreeNode * found = Locate(qualifiedLabel, startingNode, 0);
if (found)
{
found->Select();
if (bExpand)
found->Expand();
found->EnsureVisible();
return true;
}
return false;
}
int CTreeBuilder::GetAsInt(string sSectionPath, int iDefaultValue)
{
string sNodeValue;
int iNodeValue = iDefaultValue;
CTreeNode* pCurrentNode = NodeFind(sSectionPath);
if ( pCurrentNode!= NULL)
{
sNodeValue = pCurrentNode->GetNodeValue();
}
from_string<int>(iNodeValue, sNodeValue, dec);
return iNodeValue;
}
CTreeNode* CTreeWnd::HitTestExpandBox(CPoint pt)
{
vector<CShape*>::iterator pos;
for (pos = m_shapes.begin(); pos != m_shapes.end(); ++pos)
{
CShape *pShape = *pos;
CTreeNode* pNode = NodeFromShape(pShape);
if (pNode && pNode->HitExpandBox(pt))
{
return pNode;
}
}
return NULL;
}
int GetNodeIndex(CTreeNode *node)
{
int index = 0;
CTreeNode *parent = node->GetParentNode();
if ( parent )
{
for (WTL::CTreeItem ti = parent->GetChild(); ti != NULL; ti = ti.GetNextSibling())
{
if ( ti == *node )
return index;
index++;
}
}
return -1;
}
void Eval(CTreeNode<CBDB_QueryNode>& tr)
{
int cmpres = CmpEval(tr);
bool res = cmpres <= 0;
SetResult(tr.GetValue(), res);
}
CTreeNode* CTreeWnd::NodeFromMTNode(mtNode* pNode)
{
if (!pNode)
return NULL;
long data2 = pNode->getData2();
if (data2 == 0)
{
CTreeNode* pTreeNode = new CTreeNode();
pTreeNode->setTree(this);
pTreeNode->setmtNode(pNode);
pNode->setData2((DWORD)pTreeNode);
return pTreeNode;
}
else
return (CTreeNode*)data2;
}
void CTreeBuilder::ConfigToStr(CTreeNode* parent)
{
CTreeNode* n = NULL;
if (parent != NULL)
{
if(!parent->IsLeaf())
{
string temp = "";
for ( int i = 1; i< parent->GetDepth(); i++)
temp+="\t";
m_sXmlBuf += temp+"<"+parent->GetNodeName()+">\n";
for (n = parent->GetChild(); n != NULL; n = n->GetSibling())
{
if (!n->IsLeaf())
{
ConfigToStr(n);
}
else
{
string temp1 = "";
for ( int i = 1; i< n->GetDepth(); i++)
temp1+="\t";
m_sXmlBuf+=temp1+"<"+n->GetNodeName()+">"+n->GetNodeValue()+"</"+n->GetNodeName()+">\n";
}
}
m_sXmlBuf+=temp+"</"+parent->GetNodeName()+">\n";
}
}
}
bool CTreeNode::IsVisible()
{
if (!CPanel::IsVisible())
return false;
if (!m_hParent)
return true;
CTreeNode* pNode = m_hParent;
do
{
if (!pNode->IsExpanded())
return false;
}
while (pNode = pNode->m_hParent);
return true;
}
void CTreeWnd::NotifyLButtonDblClick(UINT nFlags,CPoint point)
{
CShape* pShape = HitTestShape(point);
if (pShape)
{
CTreeNode* pNode = NodeFromShape(pShape);
if (pNode)
{
if (OnNodeDoubleClicked(pNode))
{
pNode->ToggleExpanded();
ForceLayout();
Invalidate();
}
}
}
}
void CTagQualifiers::operator()( const CNode& node, CTreeNode& tree_node )
{
(*this)(node);
auto arg = node.first_child();
CTag& argTag = CTagContainer::getTag( arg.name() );
int argType = argTag.getType();
argTag(arg, tree_node.Step(node.name()));
arg = argTag.checkSignature(arg);
}
void CFileTree::build_tree(CInodeList & files)
{
CTreeNode * p;
if (!m_pRoot)
{
m_pRoot = new CTreeNode;
p = m_pRoot;
}
else
{
p = m_pRoot;
while (p->has_rchild())
p = p->get_rchild();
p->new_rchild();
p = p->get_rchild();
}
build_tree(p, files);
}
//Saves the tree into the binary file.
//Nodes packed into the file in preorder.
void CTree::save(const char* fileName)
{
fstream fsave(fileName, ios_base::binary | ios_base::out | ios_base::app); //file
stack<CTreeNode*> nodes; //stack for keeping roots of subtrees in the packing order
nodes.push(&root);
while(!nodes.empty())
{
CTreeNode* pNode = nodes.top(); //current node to be packed
nodes.pop();
pNode->save(fsave);
if(!pNode->isLeaf())
{
nodes.push(pNode->right);
nodes.push(pNode->left);
}
}
fsave.close();
}
void CSoliDire::build_dir_tree(CString basedir)
{
CTreeNode * p = NULL;
if (!m_DirTree->m_pRoot)
{
m_DirTree->m_pRoot = new CTreeNode;
p = m_DirTree->m_pRoot;
}
else
{
p = m_DirTree->m_pRoot;
while (p->has_rchild())
p = p->get_rchild();
p->new_rchild();
p = p->get_rchild();
}
build_dir_tree(p, basedir);
SetModifiedFlag(TRUE);
}
bool CTreeBuilder::WriteConfigString(string sNodePath, string value)
{
bool bRetCode = false;
//check if the base root is available
int iSecSlash = sNodePath.find('/', 1);
string sRootSection = sNodePath.substr(0, iSecSlash);
if ( IfSectionExists(sRootSection) == true && IfSectionExists(sNodePath) == false)
{
bRetCode = RecursiveAdd(sNodePath);
}
CTreeNode* pNode = NodeFind(sNodePath);
if ( pNode!= NULL)
{
pNode->SetNodeValue(value);
m_bModified = true;
}
return bRetCode;
}
void Eval(CTreeNode<CBDB_QueryNode>& tr)
{
GetArguments(tr, eCheckAll);
CBDB_QueryNode& qnode = tr.GetValue();
const string* arg = GetArg(0);
if (*arg == "0") {
qnode.SetValue("1");
} else {
qnode.SetValue("0");
}
}
void CTagCn::operator ()(const CNode& node, CTreeNode& tree_node)
{
(*this)(node);
checkAttributes(node, { "type" });
string attr = node.attribute("type").as_string();
CNode child = node.first_child();
if (attr == "real" || attr == "")
{
hasNChilds(node, 1);
nodeIsReal(child, tree_node.Step("cn"));
return;
}
}
