TreeNode *buildSubTree(vector<int> &preorder, vector<int> &inorder, int preorderstart, int preorderend, int inorderstart, int inorderend)
{
if (preorderstart == preorderend) return NULL;
TreeNode *newnode = new TreeNode(preorder[preorderstart]);
if (preorderstart == preorderend - 1) return newnode;
int rootPos;
for (rootPos = inorderstart; rootPos < inorderend; rootPos++)
{
if (inorder[rootPos] == preorder[preorderstart]) break;
}
newnode->left = buildSubTree(preorder, inorder, preorderstart + 1, preorderstart + rootPos - inorderstart + 1, inorderstart, rootPos);
newnode->right = buildSubTree(preorder, inorder, preorderstart + rootPos - inorderstart + 1, preorderend, rootPos + 1, inorderend);
return newnode;
}
void VDirectoryTree::updateItemDirectChildren(QTreeWidgetItem *p_item)
{
QPointer<VDirectory> parentDir;
if (p_item) {
parentDir = getVDirectory(p_item);
} else {
parentDir = m_notebook->getRootDir();
}
const QVector<VDirectory *> &dirs = parentDir->getSubDirs();
QHash<VDirectory *, QTreeWidgetItem *> itemDirMap;
int nrChild = p_item ? p_item->childCount() : topLevelItemCount();
for (int i = 0; i < nrChild; ++i) {
QTreeWidgetItem *item = p_item ? p_item->child(i) : topLevelItem(i);
itemDirMap.insert(getVDirectory(item), item);
}
for (int i = 0; i < dirs.size(); ++i) {
VDirectory *dir = dirs[i];
QTreeWidgetItem *item = itemDirMap.value(dir, NULL);
if (item) {
if (p_item) {
p_item->removeChild(item);
p_item->insertChild(i, item);
} else {
int topIdx = indexOfTopLevelItem(item);
takeTopLevelItem(topIdx);
insertTopLevelItem(i, item);
}
itemDirMap.remove(dir);
} else {
// Insert a new item
if (p_item) {
item = new QTreeWidgetItem(p_item);
} else {
item = new QTreeWidgetItem(this);
}
fillTreeItem(item, dir);
buildSubTree(item, 1);
}
expandSubTree(item);
}
// Delete items without corresponding VDirectory
for (auto iter = itemDirMap.begin(); iter != itemDirMap.end(); ++iter) {
QTreeWidgetItem *item = iter.value();
if (p_item) {
p_item->removeChild(item);
} else {
int topIdx = indexOfTopLevelItem(item);
takeTopLevelItem(topIdx);
}
delete item;
}
}
BVHNode * BVHTree::buildTree(std::vector<Shape *> shapes) {
if (root != NULL) {
delete root;
}
int depth = 0;
root = buildSubTree(shapes, depth);
return root;
}
void VDirectoryTree::buildSubTree(QTreeWidgetItem *p_parent, int p_depth)
{
if (p_depth == 0) {
return;
}
Q_ASSERT(p_parent);
VDirectory *dir = getVDirectory(p_parent);
if (!dir->open()) {
VUtils::showMessage(QMessageBox::Warning,
tr("Warning"),
tr("Fail to open folder <span style=\"%1\">%2</span>.")
.arg(g_config->c_dataTextStyle)
.arg(dir->getName()),
tr("Please check if directory <span style=\"%1\">%2</span> exists.")
.arg(g_config->c_dataTextStyle)
.arg(dir->fetchPath()),
QMessageBox::Ok,
QMessageBox::Ok,
this);
return;
}
if (p_parent->childCount() > 0) {
// This directory has been built before. Try its children directly.
int cnt = p_parent->childCount();
for (int i = 0; i < cnt; ++i) {
buildSubTree(p_parent->child(i), p_depth -1);
}
} else {
const QVector<VDirectory *> &subDirs = dir->getSubDirs();
for (int i = 0; i < subDirs.size(); ++i) {
VDirectory *subDir = subDirs[i];
QTreeWidgetItem *item = new QTreeWidgetItem(p_parent);
fillTreeItem(item, subDir);
buildSubTree(item, p_depth - 1);
}
}
if (dir->isExpanded()) {
expandItem(p_parent);
}
}
BVHNode * BVHTree::buildSubTree(std::vector<Shape *> shapes, int depth) {
int size = (int) shapes.size();
int axis = depth % dims; // 0-2
// Construct leaf BVHNode containing shapes
if (size == shapesPerLeaf) {
BVHNode *leaf = new BVHNode();
leaf->addShape(shapes[0]); // Add shape and init bbox
leaf->leaf = true;
return leaf;
} else if (size == 0) {
return NULL;
}
// Otherwise split the shapes into two subsets, and divide them amongst
// the left and right child nodes
// Sort shapes based on the current axis
std::sort(shapes.begin(), shapes.end(), comparators[axis]);
// Find the median
int median = size / 2;
std::vector<Shape *>::iterator mid = shapes.begin() + median;
// Construct tree BVHNode
BVHNode *treeNode = new BVHNode();
// Construct left child BVHNode
std::vector<Shape *> lShapes(shapes.begin(), mid);
treeNode->left = buildSubTree(lShapes, depth + 1);
// Construct right child BVHNode
std::vector<Shape *> rShapes(mid, shapes.end());
treeNode->right = buildSubTree(rShapes, depth + 1);
// Store the bbox for the treeNode
treeNode->bbox = treeNode->left->bbox + treeNode->right->bbox;
return treeNode;
}
void TestASTMatcher::testMatchTree()
{
CPPUNIT_ASSERT_EQUAL(true, matcher.matchTree(NULL, NULL));
CPPUNIT_ASSERT_EQUAL(false, matcher.matchTree(testNode, NULL));
CPPUNIT_ASSERT_EQUAL(false, matcher.matchTree(NULL, testNode));
ASTNode* node = buildTree();
CPPUNIT_ASSERT_EQUAL(true, matcher.matchTree(testNode, node));
node = buildTreeWithDiffValue();
CPPUNIT_ASSERT_EQUAL(false, matcher.matchTree(testNode, node));
node = buildSubTree();
CPPUNIT_ASSERT_EQUAL(false, matcher.matchTree(testNode, node));
}
System* VpdRetriever::getComponentTree( )
{
System *root = db->fetch( );
if (root)
buildSubTree( root );
else
{
Logger logger;
logger.log( "Failed to fetch VPD DB, it may be corrupt.", LOG_ERR );
VpdException ve( "Failed to fetch VPD DB, it may be corrupt." );
throw ve;
}
return root;
}
void VDirectoryTree::buildChildren(QTreeWidgetItem *p_item)
{
Q_ASSERT(p_item);
int nrChild = p_item->childCount();
if (nrChild == 0) {
return;
}
for (int i = 0; i < nrChild; ++i) {
QTreeWidgetItem *childItem = p_item->child(i);
if (childItem->childCount() > 0) {
continue;
}
buildSubTree(childItem, 1);
}
}
void VDirectoryTree::updateDirectoryTree()
{
clear();
VDirectory *rootDir = m_notebook->getRootDir();
const QVector<VDirectory *> &subDirs = rootDir->getSubDirs();
for (int i = 0; i < subDirs.size(); ++i) {
VDirectory *dir = subDirs[i];
QTreeWidgetItem *item = new QTreeWidgetItem(this);
fillTreeItem(item, dir);
buildSubTree(item, 1);
}
if (!restoreCurrentItem() && topLevelItemCount() > 0) {
setCurrentItem(topLevelItem(0));
}
}
QTreeWidgetItem *VDirectoryTree::expandToVDirectory(const VDirectory *p_directory)
{
if (!p_directory
|| p_directory->getNotebook() != m_notebook
|| p_directory == m_notebook->getRootDir()) {
return NULL;
}
if (p_directory->getParentDirectory() == m_notebook->getRootDir()) {
// Top-level items.
int nrChild = topLevelItemCount();
for (int i = 0; i < nrChild; ++i) {
QTreeWidgetItem *item = topLevelItem(i);
if (getVDirectory(item) == p_directory) {
return item;
}
}
} else {
QTreeWidgetItem *pItem = expandToVDirectory(p_directory->getParentDirectory());
if (!pItem) {
return NULL;
}
int nrChild = pItem->childCount();
if (nrChild == 0) {
buildSubTree(pItem, 1);
}
nrChild = pItem->childCount();
for (int i = 0; i < nrChild; ++i) {
QTreeWidgetItem *item = pItem->child(i);
if (getVDirectory(item) == p_directory) {
return item;
}
}
}
return NULL;
}
void VpdRetriever::buildSubTree( Component* root )
{
Component* leaf;
const vector<string> children = root->getChildren( );
vector<string>::const_iterator i, end;
end = children.end( );
for( i = children.begin( ); i != end; ++i )
{
const string next = *i;
leaf = db->fetch( next );
if( leaf == NULL )
{
Logger logger;
logger.log( "Failed to fetch requested item.", LOG_ERR );
VpdException ve( "Failed to fetch requested item." );
throw ve;
}
buildSubTree( leaf );
root->addLeaf( leaf );
}
}
void VDirectoryTree::keyPressEvent(QKeyEvent *event)
{
int key = event->key();
int modifiers = event->modifiers();
switch (key) {
case Qt::Key_Return:
{
QTreeWidgetItem *item = currentItem();
if (item) {
item->setExpanded(!item->isExpanded());
}
break;
}
case Qt::Key_Asterisk:
{
if (modifiers == Qt::ShiftModifier) {
// *, by default will expand current item recursively.
// We build the tree recursively before the expanding.
QTreeWidgetItem *item = currentItem();
if (item) {
buildSubTree(item, -1);
}
}
break;
}
default:
break;
}
VTreeWidget::keyPressEvent(event);
}
TreeNode *buildTree(vector<int> &preorder, vector<int> &inorder) {
if (preorder.size() != inorder.size()) return NULL;
int n = preorder.size();
return buildSubTree(preorder, inorder, 0, n, 0, n);
}
void VDirectoryTree::reloadFromDisk()
{
if (!m_notebook) {
return;
}
QString msg;
QString info;
VDirectory *curDir = NULL;
QTreeWidgetItem *curItem = currentItem();
if (curItem) {
// Reload current directory.
curDir = getVDirectory(curItem);
info = tr("Are you sure to reload folder <span style=\"%1\">%2</span>?")
.arg(g_config->c_dataTextStyle).arg(curDir->getName());
msg = tr("Folder %1 reloaded from disk").arg(curDir->getName());
} else {
// Reload notebook.
info = tr("Are you sure to reload notebook <span style=\"%1\">%2</span>?")
.arg(g_config->c_dataTextStyle).arg(m_notebook->getName());
msg = tr("Notebook %1 reloaded from disk").arg(m_notebook->getName());
}
if (g_config->getConfirmReloadFolder()) {
int ret = VUtils::showMessage(QMessageBox::Information, tr("Information"),
info,
tr("VNote will close all the related notes before reload."),
QMessageBox::Ok | QMessageBox::YesToAll | QMessageBox::Cancel,
QMessageBox::Ok,
this);
switch (ret) {
case QMessageBox::YesToAll:
g_config->setConfirmReloadFolder(false);
// Fall through.
case QMessageBox::Ok:
break;
case QMessageBox::Cancel:
return;
default:
return;
}
}
m_notebookCurrentDirMap.remove(m_notebook);
if (curItem) {
if (!m_editArea->closeFile(curDir, false)) {
return;
}
setCurrentItem(NULL);
curItem->setExpanded(false);
curDir->setExpanded(false);
curDir->close();
// Remove all its children.
QList<QTreeWidgetItem *> children = curItem->takeChildren();
for (int i = 0; i < children.size(); ++i) {
delete children[i];
}
buildSubTree(curItem, 1);
setCurrentItem(curItem);
} else {
if (!m_editArea->closeFile(m_notebook, false)) {
return;
}
m_notebook->close();
if (!m_notebook->open()) {
VUtils::showMessage(QMessageBox::Warning, tr("Warning"),
tr("Fail to open notebook <span style=\"%1\">%2</span>.")
.arg(g_config->c_dataTextStyle).arg(m_notebook->getName()),
tr("Please check if path <span style=\"%1\">%2</span> exists.")
.arg(g_config->c_dataTextStyle).arg(m_notebook->getPath()),
QMessageBox::Ok, QMessageBox::Ok, this);
clear();
return;
}
updateDirectoryTree();
}
if (!msg.isEmpty()) {
g_mainWin->showStatusMessage(msg);
}
}
