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