BOOL CFormObjectDoc::SaveModified()
{
CFormObject* pView = (CFormObject*)GetView();
if(GetTree())
GetTree()->GetDocument()->SetModifiedFlag(1);
return TRUE;
}
CCheckTreeView::~CCheckTreeView (void)
{
if (m_fUseCheckMarks) {
CImageList *pIList = SetImageList (NULL, TVSIL_STATE);
DELETE_OBJ (pIList);
}
DeleteAllItems();
if (GetTree())
delete GetTree();
}
//****************************
void CObjInfo::OnCloseObj()
{
if(GetTree())
{
GetTree()->RemoveFromList(GetObj(),GetObjName());
SetTree(0);
}
else
{
if(bDeleteObj&&GetObj())
{
delete GetObj();
SetObj(0);
}
}
};
void SiteMapping::Print(ostream& os, Link* from, bool redundant) {
if (from->isLeaf()) {
os << GetTree()->GetNodeName(from);
if (redundant) {
os << '_';
}
else {
os << ':';
}
}
else {
os << '(';
for (Link* link=from->Next(); link!=from; link=link->Next()) {
Print(os,link->Out(), redundant);
if (link->Next() != from) {
os << ',';
}
}
os << ')';
}
if (from->isRoot()) {
os << GetPath(from->GetBranch())->GetCharInitState();
}
else {
os << GetPath(from->GetBranch())->ToString(redundant);
}
}
JFSFileTree*
JFSFileTreeNodeBase::GetFSFileTree()
{
JFSFileTree* tree = dynamic_cast<JFSFileTree*>(GetTree());
assert (tree != NULL);
return tree;
}
void
CMVarNode::SetValid
(
const JBoolean valid
)
{
if (valid != itsValidFlag)
{
itsValidFlag = valid;
JTree* tree;
if (GetTree(&tree))
{
tree->BroadcastChange(this);
}
}
// pointer values update their own contents
if (!valid || !itsIsPointerFlag)
{
const JSize count = GetChildCount();
for (JIndex i=1; i<=count; i++)
{
(GetVarChild(i))->SetValid(valid);
}
}
}
bool CThesaurus::IsA(DWORD TextEntryId, string ConceptStr) const
{
long ConceptNo = GetConceptNoByConceptStr(ConceptStr.c_str());
if (ConceptNo == -1) return false;
long ConceptId = m_Concepts[ConceptNo].m_ConceptId;
vector<long> ConceptsFromTextEntry;
GetConceptsByTextEntryId(TextEntryId, ConceptsFromTextEntry);
if (ConceptsFromTextEntry.empty()) return true;
vector<long> HIGHERConcepts;
vector<long> Path;
for (long i=0; i < ConceptsFromTextEntry.size();i++)
{
HIGHERConcepts.clear();
if (!GetTree(GetConceptNoByConceptId(ConceptsFromTextEntry[i]), HIGHERConcepts, Path, HIGHER))
{
ErrorMessage ("a cycle found starts from TextEntry " + m_Termins[GetTerminNoByTextEntryId(TextEntryId)].m_TerminStr);
return false;
}
for (long k=0; k <HIGHERConcepts.size();k++)
if (m_Concepts[HIGHERConcepts[k]].m_ConceptId == ConceptId)
return true;
};
return false;
}
int CThesaurus::QueryTopConcepts(UINT TextEntryId, vector<int>& CurrentTopConcepts) const
{
CurrentTopConcepts.clear();
vector<long> ConceptsFromTextEntry;
GetConceptsByTextEntryId(TextEntryId, ConceptsFromTextEntry);
if (ConceptsFromTextEntry.empty()) return 0;
for (long i=0; i <ConceptsFromTextEntry.size(); i++)
{
vector<long> HIGHERConcepts;
vector<long> Path;
if (!GetTree(GetConceptNoByConceptId(ConceptsFromTextEntry[i]), HIGHERConcepts, Path, HIGHER))
{
ErrorMessage ("a cycle found starts from TextEntry " + m_Termins[GetTerminNoByTextEntryId(TextEntryId)].m_TerminStr);
return 0;
};
for (long k=0; k < HIGHERConcepts.size(); k++)
if (GetRelationsCount(*this, HIGHERConcepts[k], HIGHER) == 0)
if (!_find(CurrentTopConcepts,HIGHERConcepts[k]))
CurrentTopConcepts.push_back(HIGHERConcepts[k]);
};
return CurrentTopConcepts.size();
}
void CThesaurus::QueryLowerTermins(const string& ConceptStr, UINT Language, vector<int>& CurrentLowerTermins) const
{
CurrentLowerTermins.clear();
long ConceptNo = GetConceptNoByConceptStr(ConceptStr);
if (ConceptNo == -1) return;
vector<long> LOWERConcepts;
vector<long> Path;
if (!GetTree(ConceptNo, LOWERConcepts, Path, LOWER))
return;
bool IsEnglish = Language == morphEnglish;
for (long i=0; i <LOWERConcepts.size(); i++)
{
vector<long> TextEntries;
GetTextEntriesByConcept(m_Concepts[LOWERConcepts[i]].m_ConceptId, TextEntries);
for (long k=0; k < TextEntries.size(); k++)
{
long TerminNo = GetTerminNoByTextEntryId(TextEntries[k]);
if (m_Termins[TerminNo].m_ModelNo == -1) continue;
if (IsEnglish != IsEnglishModel(m_Models[m_Termins[TerminNo].m_ModelNo])) continue;
if (!_find (CurrentLowerTermins, TerminNo))
CurrentLowerTermins.push_back(TerminNo);
};
};
}
void WLTreeItemAL::OnMouseMove(UINT /*nFlags*/, CPoint point)
{
if (!(m_dwStatus & TIS_HOT))
{
m_dwStatus |= TIS_HOT ;
UpdateItemView() ;
}
HostToClient(&point) ;
if (m_bPrepareDrag
&& GetTickCount() - m_dwPrepareDragTime >= 200
&& (abs(m_ptPrepareDragPoint.x - point.x) + abs(m_ptPrepareDragPoint.y - point.y)) >= 20)
{
m_bPrepareDrag = FALSE ;
ReleaseCapture() ;
NMTIDRAGINFO info ;
info.hdr.hWlFrom = this ;
info.hdr.idFrom = m_uID ;
info.hdr.code = TIN_BEGIN_DRAG ;
info.ptInItem.x = m_ptPrepareDragPoint.x ;
info.ptInItem.y = m_ptPrepareDragPoint.y ;
GetTree()->SendMessage(WM_NOTIFY, (WPARAM)m_uID, (LPARAM)&info) ;
}
}
BOOL WLTreeItemAL::Select(BOOL bSelect)
{
if (bSelect)
{
if (!(m_dwStatus & TIS_SELECTED))
{
m_dwStatus |= TIS_SELECTED ;
UpdateItemView() ;
// 告诉父窗口自己被选择了
NMTREEITEM ti ;
ti.hdr.hWlFrom = this ;
ti.hdr.idFrom = m_uID ;
ti.hdr.code = TIN_SELECTED ;
ti.hItem = this ;
GetTree()->SendMessage(WM_NOTIFY, (WPARAM)m_uID, (LPARAM)&ti) ;
return TRUE ;
}
}
else
{
if (m_dwStatus & TIS_SELECTED)
{
m_dwStatus &= ~TIS_SELECTED ;
UpdateItemView() ;
return TRUE ;
}
}
return FALSE ;
}
void
CBCTreeDirector::CBCTreeDirectorX()
{
itsCTree = dynamic_cast<CBCTree*>(GetTree());
assert( itsCTree != NULL );
itsEditCPPDialog = NULL;
}
void RandomForest::Node<T>::CreateTree()
{
tree->SetActureTreeNode(tree->GetActureTreeNode()+1);
int bestFeatureIndex;
T bestFeatureValue;
if (depth == tree->GetDepthUpperBound())
{
bestFeatureIndex = -1;
bestFeatureValue=meanLeaf();
featureIndex=bestFeatureIndex;
splitValue=bestFeatureValue;
return;
}
chooseBestSplit(&bestFeatureIndex, &bestFeatureValue, &decreasedImpurity);
featureIndex=bestFeatureIndex;
splitValue=bestFeatureValue;
if (bestFeatureIndex==-1)
{
return;
}
std::shared_ptr<std::vector<int> > indexList0(new std::vector<int>);
std::shared_ptr<std::vector<int> > indexList1(new std::vector<int>);
binSplitDataSet(sampleIndexList, bestFeatureIndex, bestFeatureValue,
indexList0,indexList1);
std::shared_ptr<Node<T> > leftchild(new Node<T>(GetTree()));
leftchild->SetDepth(depth+1);
if (leftchild->GetDepth() > tree->GetActureTreeDepth())
{
tree->SetActureTreeDepth(leftchild->GetDepth());
}
leftchild->SetSampleIndexList(indexList0);
leftchild->CreateTree();
left=leftchild;
std::shared_ptr<Node<T> > rightchild(new Node<T>(GetTree()));
rightchild->SetDepth(depth+1);
if (rightchild->GetDepth() > tree->GetActureTreeDepth())
{
tree->SetActureTreeDepth(rightchild->GetDepth());
}
rightchild->SetSampleIndexList(indexList1);
rightchild->CreateTree();
right=rightchild;
}
int main(void)
{
Tree *node = GetTree();
Tree *is = InorderSuccessor(node);
if (is != NULL) {
printf("%d\n", is->data);
}
Inorder(node);
printf("\n");
}
void CFolderDlg::OnItemExpanding(NMTREEVIEW* lpnmtv)
{
if (lpnmtv->action == TVE_EXPAND) {
TCHAR szKey[MAX_PATH];
//フォルダ名を取得
GetTree (lpnmtv->hdr.hwndFrom, lpnmtv->itemNew.hItem, szKey);
//子ツリーを列挙する
EnumChildren (lpnmtv->hdr.hwndFrom, lpnmtv->itemNew.hItem, szKey);
}
}
static inline void
IncrementStamp(cpBBTree *tree)
{
cpBBTree *dynamicTree = GetTree(tree->spatialIndex.dynamicIndex);
if(dynamicTree){
dynamicTree->stamp++;
} else {
tree->stamp++;
}
}
std::string Param::getDataAsTree() const
{
std::stringstream ss;
std::function<void(const CaffUtil::Param&, const uint32_t)> GetTree = [&](const CaffUtil::Param &node, const uint32_t level)
{
for(std::size_t t = 0; t < level; ++t)
{
ss << " ";
}
ss << "[" << node.getName() << "] " << node.asStdString() << "\n";
for(auto &child : node.m_childNodes)
{
GetTree(*child.second.get(), level + 1);
}
};
GetTree(*this, 0);
return ss.str();
}
void CFolderDlg::OnOK(HWND hDlg)
{
HWND hTV = GetDlgItem(hDlg, IDC_TREE_FOLDER);
TCHAR szPath[MAX_PATH] = _T("");
TCHAR szTemp[MAX_PATH] = _T("");
TCHAR szName[MAX_PATH] = _T("");
HTREEITEM hTreeItem = TreeView_GetSelection(hTV);
GetTree(hTV, hTreeItem, m_pszPath);
m_bSubFolder = SendMessage(GetDlgItem(hDlg, IDC_CHECK_SUBFOLDER), BM_GETCHECK, 0, 0);
EndDialog(hDlg, IDOK);
}
int getEvents(TString folder, TString condition)
{
auto files = list_files(Form("%s/%s",samplesfolder.Data(),folder.Data()));
double x0=0;
for (auto f:files) {
TFile *f0 = TFile::Open(f);
TTree *t0 = GetTree(f0,"hltanalysis/HltTree");//jettree);
x0 += t0->GetEntries(condition);
f0->Close();
}
return x0;
}
void HierarchyTreeController::DeleteNode(const HierarchyTreeNode::HIERARCHYTREENODEID nodeID,
bool deleteNodeFromMemory, bool deleteNodeFromScene,
bool deleteNodeFromDisk)
{
HierarchyTreeNode::HIERARCHYTREENODESLIST nodes;
HierarchyTreeNode* nodeToDelete = GetTree().GetNode(nodeID);
if (!nodeToDelete)
{
return;
}
nodes.push_back(nodeToDelete);
DeleteNodes(nodes, deleteNodeFromMemory, deleteNodeFromScene, deleteNodeFromDisk);
}
void CacheBase::Load(std::string hd_path)
{
BlockLockMutex lock(this);
tree = new DirEntry("", pf_stat(), NULL);
pf_stat s = tree->GetAttr();
s.mode = S_IFDIR | S_IRWXU;
tree->SetAttr(s);
try
{
hdd.BuildTree(GetTree(), hd_path);
}
catch(...)
{
throw;
}
}
// TSnap::IsTree
TEST(alg, IsTree) {
PNGraph Graph;
int RootNId;
Graph = GetSingleNode();
EXPECT_EQ(1,TSnap::IsTree(Graph,RootNId));
Graph = GetTree();
EXPECT_EQ(1,TSnap::IsTree(Graph,RootNId));
Graph = GetForest();
EXPECT_EQ(0,TSnap::IsTree(Graph,RootNId));
Graph = GetCircle();
EXPECT_EQ(0,TSnap::IsTree(Graph,RootNId));
}
void CPpcFolderDlg::OnOK(HWND hDlg)
{
HWND hTV = GetDlgItem(hDlg, IDC_TREE_FOLDER);
HTREEITEM hTreeItem = TreeView_GetSelection(hTV);
GetTree(hTV, hTreeItem, m_pszPath);
EndDialog(hDlg, IDOK);
if (m_hwndMB) {
CommandBar_Destroy(m_hwndMB);
m_hwndMB = NULL;
}
if (m_pOrgProc) {
SetWindowLong(GetDlgItem(hDlg, IDC_TREE_FOLDER), GWL_WNDPROC, (LONG)m_pOrgProc);
m_pOrgProc = NULL;
}
}
void CThesaurus::QueryHigherTermins(UINT TextEntryId, vector<int>& CurrentHigherTermins) const
{
CurrentHigherTermins.clear();
long TerminNo = GetTerminNoByTextEntryId(TextEntryId);
if (TerminNo == -1) return;
if (m_Termins[TerminNo].m_ModelNo == -1) return;
bool IsEnglish = IsEnglishModel(m_Models[m_Termins[TerminNo].m_ModelNo]);
vector<long> ConceptsFromTextEntry;
GetConceptsByTextEntryId(TextEntryId, ConceptsFromTextEntry);
if (ConceptsFromTextEntry.empty()) return;
vector<long> HigherConcepts;
long i=0;
for (; i <ConceptsFromTextEntry.size(); i++)
{
vector<long> HIGHERConcepts;
vector<long> Path;
if (!GetTree(GetConceptNoByConceptId(ConceptsFromTextEntry[i]), HIGHERConcepts, Path, HIGHER))
{
ErrorMessage ("a cycle found starts from TextEntry " + m_Termins[GetTerminNoByTextEntryId(TextEntryId)].m_TerminStr);
return;
};
for (long k=0; k < HIGHERConcepts.size(); k++)
if ( !_find(HigherConcepts, HIGHERConcepts[k]) )
HigherConcepts.push_back(HIGHERConcepts[k]);
};
for (i=0; i <HigherConcepts.size(); i++)
{
vector<long> TextEntries;
GetTextEntriesByConcept(m_Concepts[HigherConcepts[i]].m_ConceptId, TextEntries);
for (long k=0; k < TextEntries.size(); k++)
{
long TerminNo = GetTerminNoByTextEntryId(TextEntries[k]);
if (m_Termins[TerminNo].m_ModelNo == -1) continue;
if (IsEnglish != IsEnglishModel(m_Models[m_Termins[TerminNo].m_ModelNo])) continue;
if (!_find (CurrentHigherTermins, TerminNo))
CurrentHigherTermins.push_back(TerminNo);
};
};
}
BOOL CBCGPXMLSettings::CreateKey (LPCTSTR pszPath)
{
if (m_bReadOnly)
{
ASSERT (FALSE);
return FALSE;
}
ASSERT (pszPath != NULL);
CString strPath = pszPath;
int iPathLen = strPath.GetLength ();
if (iPathLen > 0 && strPath [iPathLen - 1] != _T('\\'))
{
strPath += _T('\\');
}
CBCGPXMLNode* pNode = GetTree ();
for (int iFrom = 0; iFrom < strPath.GetLength ();)
{
int iEnd = strPath.Find (_T('\\'), iFrom);
if (iEnd < 0)
{
ASSERT (FALSE);
return FALSE;
}
CString strSubKey = strPath.Mid (iFrom, iEnd - iFrom);
strSubKey.Remove (_T(' '));
CBCGPXMLNode* pChild = pNode->FindChild (strSubKey);
if (pChild == NULL)
{
pChild = new CBCGPXMLNode;
pChild->m_strName = strSubKey;
pNode->AddChild (pChild);
}
pNode = pChild;
iFrom = iEnd + 1;
}
m_pCurrNode = pNode;
return TRUE;
}
static void
LeafAddPairs(Node *leaf, cpBBTree *tree)
{
cpSpatialIndex *dynamicIndex = tree->spatialIndex.dynamicIndex;
if(dynamicIndex){
Node *dynamicRoot = GetRootIfTree(dynamicIndex);
if(dynamicRoot){
cpBBTree *dynamicTree = GetTree(dynamicIndex);
MarkContext context = {dynamicTree, NULL, NULL, NULL};
MarkLeafQuery(dynamicRoot, leaf, cpTrue, &context);
}
} else {
Node *staticRoot = GetRootIfTree(tree->spatialIndex.staticIndex);
MarkContext context = {tree, staticRoot, VoidQueryFunc, NULL};
MarkLeaf(leaf, &context);
}
}
void
JNamedTreeNode::SetName
(
const JCharacter* name
)
{
if (name != itsName)
{
itsName = name;
NameChanged();
JTree* tree;
if (GetTree(&tree))
{
tree->BroadcastChange(this);
}
}
}
BOOL CMyHelpDoc::SaveModified()
{
// return CRichEditDoc::SaveModified();
if(GetTree())//это режим в составе конфигурации
{
if(!GetObj()->bCanSave)
return TRUE;
CRichEditDoc::SetModifiedFlag(0);
CString Str;
((CMyHelpView*)GetView())->GetText(Str);
GetObj()->csFile=Str;
return TRUE;
}
else//это самостоятельный документ
{
return CRichEditDoc::SaveModified();
}
return TRUE;
}
///////////////////////////////////////////////////////////////
// GSFinder + TQのコードを引っ張ってきた。
// Qtaさんありがとー！！
// -- Ex.Q --
// ツリー ビューの項目の絶対パスを求める
void CFolderDlg::GetTree(HWND hwndTV, HTREEITEM hItem, LPTSTR pszKey)
{
CTempStr str(IDS_ROOT_FOLDER_NAME);
TCHAR szName[MAX_PATH];
TV_ITEM tvi;
memset (&tvi, 0, sizeof (tvi));
// 親を取得
HTREEITEM hParent;
hParent = TreeView_GetParent (hwndTV, hItem);
if (hParent) {
// 項目の親の親・・・を取得する
GetTree (hwndTV, hParent, pszKey);
// 項目の名前を取得する
tvi.mask = TVIF_TEXT;
tvi.hItem = hItem;
tvi.pszText = szName;
tvi.cchTextMax = MAX_PATH;
TreeView_GetItem(hwndTV, &tvi);
// ルートでなければ￥をつける
if (wcscmp(pszKey, str) != 0)
lstrcat (pszKey, TEXT("\\"));
else
lstrcpy (pszKey, TEXT("\\"));
// 親のパスに今のフォルダ名を追加
lstrcat (pszKey, szName);
} else {
// 項目の名前を取得する
lstrcpy(pszKey, _T(""));
szName[0] = _T('\0');
tvi.mask = TVIF_TEXT | TVIF_PARAM;
tvi.hItem = hItem;
tvi.pszText = szName;
tvi.cchTextMax = MAX_PATH;
TreeView_GetItem(hwndTV, &tvi);
}
}
BOOL CBCGPXMLSettings::Open (LPCTSTR pszPath)
{
ASSERT (pszPath != NULL);
CBCGPXMLNode* pNode = GetTree ();
m_sPath = pszPath;
CString strPath = pszPath;
int iPathLen = strPath.GetLength ();
if (iPathLen > 0 && strPath [iPathLen - 1] != _T('\\'))
{
strPath += _T('\\');
}
for (int iFrom = 0; iFrom < strPath.GetLength ();)
{
int iEnd = strPath.Find (_T('\\'), iFrom);
if (iEnd < 0)
{
ASSERT (FALSE);
return FALSE;
}
CString strSubKey = strPath.Mid (iFrom, iEnd - iFrom);
strSubKey.Remove (_T(' '));
CBCGPXMLNode* pChild = pNode->FindChild (strSubKey);
if (pChild == NULL)
{
m_pCurrNode = NULL;
return FALSE;
}
pNode = pChild;
iFrom = iEnd + 1;
}
m_pCurrNode = pNode;
return TRUE;
}
