void TreeView::sort(HTREEITEM hTreeItem)
{
::SendMessage(_hSelf, TVM_SORTCHILDREN, TRUE, (LPARAM)hTreeItem);
for (HTREEITEM hItem = getChildFrom(hTreeItem); hItem != NULL; hItem = getNextSibling(hItem))
sort(hItem);
}
DOMText *DOMTextImpl::splitText(XMLSize_t offset)
{
if (fNode.isReadOnly())
{
throw DOMException(
DOMException::NO_MODIFICATION_ALLOWED_ERR, 0, GetDOMNodeMemoryManager);
}
XMLSize_t len = fCharacterData.fDataBuf->getLen();
if (offset > len)
throw DOMException(DOMException::INDEX_SIZE_ERR, 0, GetDOMNodeMemoryManager);
DOMText *newText =
getOwnerDocument()->createTextNode(
this->substringData(offset, len - offset));
DOMNode *parent = getParentNode();
if (parent != 0)
parent->insertBefore(newText, getNextSibling());
fCharacterData.fDataBuf->chop(offset);
if (this->getOwnerDocument() != 0) {
Ranges* ranges = ((DOMDocumentImpl *)this->getOwnerDocument())->getRanges();
if (ranges != 0) {
XMLSize_t sz = ranges->size();
if (sz != 0) {
for (XMLSize_t i =0; i<sz; i++) {
ranges->elementAt(i)->updateSplitInfo( this, newText, offset);
}
}
}
}
return newText;
}
bool TreeView::moveDown(HTREEITEM itemToMove)
{
HTREEITEM hItemToUp = getNextSibling(itemToMove);
if (!hItemToUp)
return false;
return swapTreeViewItem(itemToMove, hItemToUp);
}
bool TreeView::retrieveFoldingStateTo(TreeStateNode & treeState2Construct, HTREEITEM treeviewNode)
{
if (!treeviewNode)
return false;
TCHAR textBuffer[MAX_PATH];
TVITEM tvItem;
tvItem.hItem = treeviewNode;
tvItem.pszText = textBuffer;
tvItem.cchTextMax = MAX_PATH;
tvItem.mask = TVIF_TEXT | TVIF_PARAM | TVIF_STATE;
SendMessage(_hSelf, TVM_GETITEM, 0,(LPARAM)&tvItem);
treeState2Construct._label = textBuffer;
treeState2Construct._isExpanded = (tvItem.state & TVIS_EXPANDED) != 0;
treeState2Construct._isSelected = (tvItem.state & TVIS_SELECTED) != 0;
if (tvItem.lParam)
{
treeState2Construct._extraData = *((generic_string *)tvItem.lParam);
}
int i = 0;
for (HTREEITEM hItem = getChildFrom(treeviewNode); hItem != NULL; hItem = getNextSibling(hItem))
{
treeState2Construct._children.push_back(TreeStateNode());
retrieveFoldingStateTo(treeState2Construct._children.at(i), hItem);
++i;
}
return true;
}
HTREEITEM TreeView::searchSubItemByName(const TCHAR *itemName, HTREEITEM hParentItem)
{
HTREEITEM hItem = NULL;
if (hParentItem != NULL)
hItem = getChildFrom(hParentItem);
else
hItem = getRoot();
for ( ; hItem != NULL; hItem = getNextSibling(hItem))
{
TCHAR textBuffer[MAX_PATH];
TVITEM tvItem;
tvItem.hItem = hItem;
tvItem.pszText = textBuffer;
tvItem.cchTextMax = MAX_PATH;
tvItem.mask = TVIF_TEXT;
SendMessage(_hSelf, TVM_GETITEM, 0,(LPARAM)&tvItem);
if (lstrcmp(itemName, tvItem.pszText) == 0)
{
return hItem;
}
}
return NULL;
}
void TreeView::removeAllItems()
{
for (HTREEITEM tvProj = getRoot();
tvProj != NULL;
tvProj = getNextSibling(tvProj))
{
cleanSubEntries(tvProj);
}
TreeView_DeleteAllItems(_hSelf);
}
DOMNode* DOMTreeWalkerImpl::nextSibling () {
if (!fCurrentNode) return 0;
DOMNode* node = getNextSibling(fCurrentNode);
if (node != 0) {
fCurrentNode = node;
}
return node;
}
void connect1(TreeLinkNode *curNode)
{
if (!curNode) return;
TreeLinkNode* nextHead = NULL;
while (curNode)
{
if(curNode->left)
{
curNode->left->next = getNextSibling(curNode, true);
if (!nextHead) nextHead = curNode->left;
}
if (curNode->right)
{
curNode->right->next = getNextSibling(curNode, false);
if (!nextHead) nextHead = curNode->right;
}
curNode = curNode->next;
}
connect1(nextHead);
}
DOM_Node TreeWalkerImpl::nextSibling () {
DOM_Node result;
if (fCurrentNode.isNull()) return result;
DOM_Node node = getNextSibling(fCurrentNode);
if (! node.isNull()) {
fCurrentNode = node;
}
return node;
}
ElementPtr Node::getNextSiblingElement() const
{
NodePtr found = getNextSibling();
while (found)
{
if (found->isElement())
return found->toElement();
found = found->getNextSibling();
}
return ElementPtr();
}
const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *ChildAxis::nextNode(DynamicContext *context)
{
if(toDo_) {
// initialise
toDo_ = false;
child_ = getFirstChild(contextNode_);
}
else if(child_ != 0) {
child_ = getNextSibling(child_);
}
return child_;
}
void CProjectItem::buildFilesList() {
_files.destroyContents();
CTreeItem *treeItem = getFirstChild();
while (treeItem) {
if (treeItem->isFileItem()) {
CString name = static_cast<CFileItem *>(treeItem)->getFilename();
_files.add()->_name = name;
}
treeItem = getNextSibling();
}
}
DOMNode* DOMElementImpl::rename(const XMLCh* namespaceURI, const XMLCh* name)
{
DOMDocumentImpl* doc = (DOMDocumentImpl*) fParent.fOwnerDocument;
if (!namespaceURI || !*namespaceURI) {
fName = doc->getPooledString(name);
fAttributes->reconcileDefaultAttributes(getDefaultAttributes());
// and fire user data NODE_RENAMED event
castToNodeImpl(this)->callUserDataHandlers(DOMUserDataHandler::NODE_RENAMED, this, this);
return this;
}
else {
// create a new ElementNS
DOMElementNSImpl* newElem = (DOMElementNSImpl*)doc->createElementNS(namespaceURI, name);
// transfer the userData
doc->transferUserData(castToNodeImpl(this), castToNodeImpl(newElem));
// remove old node from parent if any
DOMNode* parent = getParentNode();
DOMNode* nextSib = getNextSibling();
if (parent) {
parent->removeChild(this);
}
// move children to new node
DOMNode* child = getFirstChild();
while (child) {
removeChild(child);
newElem->appendChild(child);
child = getFirstChild();
}
// insert new node where old one was
if (parent) {
parent->insertBefore(newElem, nextSib);
}
// move specified attributes to new node
newElem->fAttributes->moveSpecifiedAttributes(fAttributes);
// and fire user data NODE_RENAMED event
castToNodeImpl(newElem)->callUserDataHandlers(DOMUserDataHandler::NODE_RENAMED, this, newElem);
return newElem;
}
}
DOM_Node TreeWalkerImpl::getNextSibling (DOM_Node node) {
DOM_Node result;
if (node.isNull() || node == fRoot) return result;
DOM_Node newNode = node.getNextSibling();
if (newNode.isNull()) {
newNode = node.getParentNode();
if (newNode.isNull() || node == fRoot) return result;
short parentAccept = acceptNode(newNode);
if (parentAccept == DOM_NodeFilter::FILTER_SKIP) {
return getNextSibling(newNode);
}
return result;
}
short accept = acceptNode(newNode);
if (accept == DOM_NodeFilter::FILTER_ACCEPT)
return newNode;
else
if (accept == DOM_NodeFilter::FILTER_SKIP) {
DOM_Node fChild = getFirstChild(newNode);
if (fChild.isNull()) {
return getNextSibling(newNode);
}
return fChild;
}
return getNextSibling(newNode);
}
void TreeView::cleanSubEntries(HTREEITEM hTreeItem)
{
for (HTREEITEM hItem = getChildFrom(hTreeItem); hItem != NULL; hItem = getNextSibling(hItem))
{
TVITEM tvItem;
tvItem.hItem = hItem;
tvItem.mask = TVIF_PARAM;
SendMessage(_hSelf, TVM_GETITEM, 0,(LPARAM)&tvItem);
if (tvItem.lParam)
{
delete (generic_string *)(tvItem.lParam);
}
cleanSubEntries(hItem);
}
}
bool TreeView::searchLeafRecusivelyAndBuildTree(HTREEITEM tree2Build, const generic_string & text2Search, int index2Search, HTREEITEM tree2Search)
{
if (!tree2Search)
return false;
TCHAR textBuffer[MAX_PATH];
TVITEM tvItem;
tvItem.hItem = tree2Search;
tvItem.pszText = textBuffer;
tvItem.cchTextMax = MAX_PATH;
tvItem.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
SendMessage(_hSelf, TVM_GETITEM, 0,(LPARAM)&tvItem);
if (tvItem.iImage == index2Search)
{
generic_string itemNameUpperCase = stringToUpper(tvItem.pszText);
generic_string text2SearchUpperCase = stringToUpper(text2Search);
size_t res = itemNameUpperCase.find(text2SearchUpperCase);
if (res != generic_string::npos)
{
if (tvItem.lParam)
{
tvItem.lParam = (LPARAM)(new generic_string(*((generic_string *)(tvItem.lParam))));
}
TVINSERTSTRUCT tvInsertStruct;
tvInsertStruct.item = tvItem;
tvInsertStruct.hInsertAfter = (HTREEITEM)TVI_LAST;
tvInsertStruct.hParent = tree2Build;
::SendMessage(_hSelf, TVM_INSERTITEM, 0, (LPARAM)(LPTVINSERTSTRUCT)&tvInsertStruct);
}
}
size_t i = 0;
bool isOk = true;
for (HTREEITEM hItem = getChildFrom(tree2Search); hItem != NULL; hItem = getNextSibling(hItem))
{
isOk = searchLeafRecusivelyAndBuildTree(tree2Build, text2Search, index2Search, hItem);
if (!isOk)
break;
++i;
}
return isOk;
}
bool TreeView::restoreFoldingStateFrom(const TreeStateNode & treeState2Compare, HTREEITEM treeviewNode)
{
if (!treeviewNode)
return false;
TCHAR textBuffer[MAX_PATH];
TVITEM tvItem;
tvItem.hItem = treeviewNode;
tvItem.pszText = textBuffer;
tvItem.cchTextMax = MAX_PATH;
tvItem.mask = TVIF_TEXT | TVIF_PARAM | TVIF_STATE;
SendMessage(_hSelf, TVM_GETITEM, 0,(LPARAM)&tvItem);
if (treeState2Compare._label != textBuffer)
return false;
if (tvItem.lParam)
{
if (treeState2Compare._extraData != *((generic_string *)tvItem.lParam))
return false;
}
if (treeState2Compare._isExpanded) //= (tvItem.state & TVIS_EXPANDED) != 0;
expand(treeviewNode);
else
fold(treeviewNode);
if (treeState2Compare._isSelected) //= (tvItem.state & TVIS_SELECTED) != 0;
selectItem(treeviewNode);
size_t i = 0;
bool isOk = true;
for (HTREEITEM hItem = getChildFrom(treeviewNode); hItem != NULL; hItem = getNextSibling(hItem))
{
if (i >= treeState2Compare._children.size())
return false;
isOk = restoreFoldingStateFrom(treeState2Compare._children.at(i), hItem);
if (!isOk)
break;
++i;
}
return isOk;
}
DOM_Node TreeWalkerImpl::getFirstChild (DOM_Node node) {
DOM_Node result;
if (node.isNull()) return result;
DOM_Node newNode = node.getFirstChild();
if (newNode.isNull()) return result;
short accept = acceptNode(newNode);
if (accept == DOM_NodeFilter::FILTER_ACCEPT)
return newNode;
else
if (accept == DOM_NodeFilter::FILTER_SKIP
&& newNode.hasChildNodes())
{
return getFirstChild(newNode);
}
return getNextSibling(newNode);
}
const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *DescendantOrSelfAxis::nextNode(DynamicContext *context)
{
if(toDo_) {
// initialise
toDo_ = false;
descendant_ = contextNode_;
}
else if(descendant_ != 0) {
const XERCES_CPP_NAMESPACE_QUALIFIER DOMNode *result = getFirstChild(descendant_);
while(result == 0 && descendant_ != contextNode_) {
result = getNextSibling(descendant_);
if(result == 0) {
descendant_ = getParent(descendant_);
}
}
descendant_ = result;
}
return descendant_;
}
DOMNode* DOMTreeWalkerImpl::getFirstChild (DOMNode* node) {
if (!node) return 0;
if(!fExpandEntityReferences && node->getNodeType()==DOMNode::ENTITY_REFERENCE_NODE)
return 0;
DOMNode* newNode = node->getFirstChild();
if (!newNode) return 0;
short accept = acceptNode(newNode);
if (accept == DOMNodeFilter::FILTER_ACCEPT)
return newNode;
else
if (accept == DOMNodeFilter::FILTER_SKIP
&& newNode->hasChildNodes())
{
return getFirstChild(newNode);
}
return getNextSibling(newNode);
}
void TreeView::dupTree(HTREEITEM hTree2Dup, HTREEITEM hParentItem)
{
for (HTREEITEM hItem = getChildFrom(hTree2Dup); hItem != NULL; hItem = getNextSibling(hItem))
{
TCHAR textBuffer[MAX_PATH];
TVITEM tvItem;
tvItem.hItem = hItem;
tvItem.pszText = textBuffer;
tvItem.cchTextMax = MAX_PATH;
tvItem.mask = TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE;
SendMessage(_hSelf, TVM_GETITEM, 0,(LPARAM)&tvItem);
if (tvItem.lParam)
{
tvItem.lParam = (LPARAM)(new generic_string(*((generic_string *)(tvItem.lParam))));
}
TVINSERTSTRUCT tvInsertStruct;
tvInsertStruct.item = tvItem;
tvInsertStruct.hInsertAfter = (HTREEITEM)TVI_LAST;
tvInsertStruct.hParent = hParentItem;
HTREEITEM hTreeParent = (HTREEITEM)::SendMessage(_hSelf, TVM_INSERTITEM, 0, (LPARAM)(LPTVINSERTSTRUCT)&tvInsertStruct);
dupTree(hItem, hTreeParent);
}
}
TextImpl *TextImpl::splitText(unsigned int offset)
{
if (isReadOnly())
{
throw DOM_DOMException(
DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, null);
}
unsigned int len = data.length();
if (offset > len)
throw DOM_DOMException(DOM_DOMException::INDEX_SIZE_ERR, null);
TextImpl *newText =
(TextImpl *) getOwnerDocument()->createTextNode(
data.substringData(offset, data.length() - offset));
NodeImpl *parent = getParentNode();
if (parent != null)
parent->insertBefore(newText, getNextSibling());
data = data.substringData(0, offset);
if (this->getOwnerDocument() != null) {
typedef RefVectorOf<RangeImpl> RangeImpls;
RangeImpls* ranges = this->getOwnerDocument()->getRanges();
if (ranges != null) {
unsigned int sz = ranges->size();
if (sz != 0) {
for (unsigned int i =0; i<sz; i++) {
ranges->elementAt(i)->updateSplitInfo( this, newText, offset);
}
}
}
}
return newText;
};
NodePtr Node::getNextSiblingChecked() const throw(Exceptions::CheckFailed)
{
NodePtr result = getNextSibling();
ZS_THROW_CUSTOM_IF(Exceptions::CheckFailed, !result)
return result;
}
std::shared_ptr<SuggestionList> CompletionTrie::getSuggestions(std::string term,
const int k) const {
std::transform(term.begin(), term.end(), term.begin(), ::tolower);
auto suggestions = suggestionStore->getSuggestionList(k);
int termPrefixPos = 0;
std::vector<NodeWithRelativeScoreStore> fittingLeafNodes;
PackedNode* node = findBestFitting(term, termPrefixPos, fittingLeafNodes);
std::vector<PackedNode*> v;
/*
* TODO if term is wihtin fittingLeafNodes this must be shown as first element!
*/
term = term.substr(0, termPrefixPos);
if (node == root || node == nullptr) {
for (NodeWithRelativeScoreStore n : fittingLeafNodes) {
suggestions->addSuggestion(n);
}
return suggestions;
}
std::vector<NodeWithRelativeScoreStore> nodesByParentScore;
nodesByParentScore.push_back( { 0xFFFFFFFF, node, term });
bool isFirstNode = true;
while (!nodesByParentScore.empty()) {
std::sort(nodesByParentScore.begin(), nodesByParentScore.end(),
NodeWithScoreStoreComparator());
NodeWithRelativeScoreStore nodeWithParentScore =
*nodesByParentScore.rbegin();
nodesByParentScore.pop_back();
// std::cout << nodeWithParentScore.getString() << std::endl;
if (nodeWithParentScore.node->isLeafNode()) {
suggestions->addSuggestion(nodeWithParentScore);
if (suggestions->isFull()) {
return suggestions;
}
}
/*
* Push first child to priority queue
*/
if (nodeWithParentScore.node->firstChildOffsetSize_ != 0) {
PackedNode* child = getFirstChild(nodeWithParentScore.node);
nodesByParentScore.push_back( {
nodeWithParentScore.getRelativeScore(), child,
nodeWithParentScore.getString() });
}
/*
* Push next sibling to priority queue
*/
if (!isFirstNode) {
PackedNode* sibling = getNextSibling(nodeWithParentScore.node);
if (sibling != nullptr) {
nodesByParentScore.push_back(
{ nodeWithParentScore.relativeScoreOfParent, sibling,
nodeWithParentScore.prefix });
}
} else {
isFirstNode = false;
}
}
/*
* TODO: where should be put the nodes defining substrings of the requested term?
*/
return suggestions;
}
