void Triggerconf::createConfigAttribute (string module, string submodule, string configname, string attributename) { // // attributes are always created, no matter if they exists or not // dublication is prevented by xercesc // DOMNode* currentConfigElement = selectConfigElement (module, submodule, configname); if (currentConfigElement == NULL) return; assert (currentConfigElement->getNodeType () == DOMNode::ELEMENT_NODE); DOMElement* elem = (DOMElement*) currentConfigElement; XMLCh* xattrname = XMLString::transcode (attributename.c_str ()); XMLCh* xempty = XMLString::transcode (""); elem->setAttribute (xattrname, xempty); XMLString::release (&xattrname); XMLString::release (&xempty); resetError (); }
void findElement(unsigned index) { currentElement = NULL; while ((elementList != NULL) && (index < elementList->getLength())) { DOMNode *node = elementList->item(index); if (node == NULL) { // Should be impossible throw new runtime_error("DOMChildIterator::setIndex() - elementList->item(i) failed"); } if (node->getNodeType() == DOMNode::ELEMENT_NODE) { DOMElement *el = dynamic_cast< xercesc::DOMElement* >( node ); if (el == NULL) { // Should be impossible throw new runtime_error("DOMChildIterator::setIndex() - casting failed"); } currentElement = el; this->index = index; break; } index++; } }
// Returns the value of the "name" child of an "animal" element. const XMLCh* getAnimalName(const DOMElement* animal) { static XercesString name = fromNative("name"); // Iterate though animal's children DOMNodeList* children = animal->getChildNodes( ); for ( size_t i = 0, len = children->getLength( ); i < len; ++i ) { DOMNode* child = children->item(i); if ( child->getNodeType( ) == DOMNode::ELEMENT_NODE && static_cast<DOMElement*>(child)->getTagName( ) == name ) { // We've found the "name" element. return child->getTextContent( ); } } return 0; }
DOMElement * DOMElementImpl::getPreviousElementSibling() const { DOMNode* n = getPreviousLogicalSibling(this); while (n != NULL) { switch (n->getNodeType()) { case DOMNode::ELEMENT_NODE: return (DOMElement*) n; case DOMNode::ENTITY_REFERENCE_NODE: { DOMElement* e = getLastElementChild(n); if (e != NULL) return e; } break; default: break; } n = getPreviousLogicalSibling(n); } return NULL; }
const XMLCh* DOMNodeImpl::lookupPrefix(const XMLCh* namespaceURI) const { // REVISIT: When Namespaces 1.1 comes out this may not be true // Prefix can't be bound to null namespace if (namespaceURI == 0) { return 0; } DOMNode *thisNode = castToNode(this); short type = thisNode->getNodeType(); switch (type) { case DOMNode::ELEMENT_NODE: { return lookupPrefix(namespaceURI, (DOMElement*)thisNode); } case DOMNode::DOCUMENT_NODE:{ return ((DOMDocument*)thisNode)->getDocumentElement()->lookupPrefix(namespaceURI); } case DOMNode::ENTITY_NODE : case DOMNode::NOTATION_NODE: case DOMNode::DOCUMENT_FRAGMENT_NODE: case DOMNode::DOCUMENT_TYPE_NODE: // type is unknown return 0; case DOMNode::ATTRIBUTE_NODE:{ if (fOwnerNode->getNodeType() == DOMNode::ELEMENT_NODE) { return fOwnerNode->lookupPrefix(namespaceURI); } return 0; } default:{ DOMNode *ancestor = getElementAncestor(thisNode); if (ancestor != 0) { return ancestor->lookupPrefix(namespaceURI); } return 0; } } }
void XmlPropertyReader::parseGameObjectFile(Ogre::DataStreamPtr &stream, const Ogre::String &groupName) { initializeXml(); XERCES_CPP_NAMESPACE::DOMDocument* doc = loadDocument(stream); DOMNodeList* godefsXml = doc->getDocumentElement()->getElementsByTagName(AutoXMLCh("gameobjectclass").data()); for (unsigned int idx = 0; idx < godefsXml->getLength(); idx++) { PropertyRecordPtr ps(new PropertyRecord()); DOMElement* curNode = static_cast<DOMElement*>(godefsXml->item(idx)); const DOMNamedNodeMap* godefAttrs = curNode->getAttributes(); for (XMLSize_t attrIdx = 0; attrIdx < godefAttrs->getLength(); attrIdx++) { PropertyEntry entry = processProperty(static_cast<DOMAttr*>(godefAttrs->item(attrIdx))); if (entry.first != "") { ps->setProperty(entry.first, entry.second); } } DOMNodeList* godefChildren = curNode->getChildNodes(); for (XMLSize_t childIdx = 0; childIdx < godefChildren->getLength(); childIdx++) { DOMNode* curChild = godefChildren->item(childIdx); if (curChild->getNodeType() == DOMNode::ELEMENT_NODE) { PropertyEntry entry = processProperty(static_cast<DOMElement*>(curChild)); if (entry.first != "") { ps->setProperty(entry.first, entry.second); } } } mPropertyRecords.push_back(ps); } shutdownXml(); }
void DSIGKeyInfoName::load(void) { // Assuming we have a valid DOM_Node to start with, load the signing key so that it can // be used later on if (mp_keyInfoDOMNode == NULL) { // Attempt to load an empty signature element throw XSECException(XSECException::LoadEmptyInfoName); } if (!strEquals(getDSIGLocalName(mp_keyInfoDOMNode), "KeyName")) { throw XSECException(XSECException::LoadNonInfoName); } // Now find the text node containing the name DOMNode *tmpElt = mp_keyInfoDOMNode->getFirstChild(); while (tmpElt != 0 && tmpElt->getNodeType() != DOMNode::TEXT_NODE) tmpElt = tmpElt->getNextSibling(); if (tmpElt != 0) { mp_keyNameTextNode = tmpElt; mp_name = tmpElt->getNodeValue(); } else { throw XSECException(XSECException::ExpectedDSIGChildNotFound, MAKE_UNICODE_STRING("Expected TEXT node as child to <KeyName> element")); } }
int attNodeCount(DOMElement * d) { int ret; ret = d->getAttributes()->getLength(); DOMNode *c; c = d->getFirstChild(); while (c != NULL) { if (c->getNodeType() == DOMNode::ELEMENT_NODE) ret += attNodeCount((DOMElement *) c); c = c->getNextSibling(); } return ret; }
DOMNode *WrapXerces::getNextLogicalSibling ( const DOMNode* n ) { // Copied from Xerces-C DOMNode* next = n->getNextSibling(); // If "n" has no following sibling and its parent is an entity reference node we // need to continue the search through the following siblings of the entity // reference as these are logically siblings of the given node. if ( !next ) { DOMNode* parent = n->getParentNode(); while ( parent && parent->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE ) { next = parent->getNextSibling(); if ( next ) break; parent = parent->getParentNode(); } } return next; }
Implementation CSDReader4qxml::implementation (DOMElement* element) throw(CSDReadException) { Implementation impl; impl.id = Qedo::transcode(element->getAttribute(X("id"))); std::string element_name; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = Qedo::transcode(child->getNodeName()); // // os // if (element_name == "os") { impl.os_name=os((DOMElement*)child); } // // fileinarchive // else if (element_name == "descriptor") { impl.descriptor=descriptor((DOMElement*)child); } } // get next child child = child->getNextSibling(); } //throw CSDReadException(); return impl; }
void CSDReader4qxml::softpkgref (DOMElement* element) throw(CSDReadException) { std::string element_name; std::string idref; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = Qedo::transcode(child->getNodeName()); // // fileinarchive // if (element_name == "fileinarchive") { // todo // fileinarchive( (DOMElement*)child ); } // // implref // else if (element_name == "implref") { // idref = implref( (DOMElement*)child ); } } // get next child child = child->getNextSibling(); } // data_->softpkg_dependencies.push_back( idref ); }
bool DOMNodeImpl::isEqualNode(const DOMNode* arg) const { if (!arg) return false; if (isSameNode(arg)) { return true; } DOMNode* thisNode = castToNode(this); if (arg->getNodeType() != thisNode->getNodeType()) { return false; } // the compareString will check null string as well if (!XMLString::equals(thisNode->getNodeName(), arg->getNodeName())) { return false; } if (!XMLString::equals(thisNode->getLocalName(),arg->getLocalName())) { return false; } if (!XMLString::equals(thisNode->getNamespaceURI(), arg->getNamespaceURI())) { return false; } if (!XMLString::equals(thisNode->getPrefix(), arg->getPrefix())) { return false; } if (!XMLString::equals(thisNode->getNodeValue(), arg->getNodeValue())) { return false; } return true; }
Descriptor CSDReader4qxml::descriptor (DOMElement* element) throw(CSDReadException) { Descriptor descr; descr.type = Qedo::transcode(element->getAttribute(X("type"))); std::string element_name; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = Qedo::transcode(child->getNodeName()); // // link // if (element_name == "link") { // return link((DOMElement*)child).file; } // // fileinarchive // else if (element_name == "fileinarchive") { descr.filearchive=fileinarchive((DOMElement*)child); } } // get next child child = child->getNextSibling(); } return descr; //throw CSDReadException(); }
void *NclLayoutParser::parseRegion( DOMElement *parentElement, void *objGrandParent) { wclog << "parseRegion" << endl; void *parentObject; DOMNodeList *elementNodeList; DOMElement *element; DOMNode *node; string elementTagName; void *elementObject; parentObject = createRegion(parentElement, objGrandParent); if (parentObject == NULL) { return NULL; } elementNodeList = parentElement->getChildNodes(); for (int i = 0; i < (int)elementNodeList->getLength(); i++) { node = elementNodeList->item(i); if (node->getNodeType()==DOMNode::ELEMENT_NODE) { element = (DOMElement*)node; elementTagName = XMLString::transcode(element->getTagName()); wclog << ">>" << elementTagName.c_str() << ": "; wclog << XMLString::transcode(element->getAttribute(XMLString::transcode("id"))); if (XMLString::compareIString( elementTagName.c_str(), "region") == 0) { elementObject = parseRegion(element, parentObject); if (elementObject != NULL) { addRegionToRegion(parentObject, elementObject); } } } } return parentObject; }
void *NclImportParser::parseImportedDocumentBase( DOMElement *parentElement, void *objGrandParent) { void *parentObject; DOMNodeList *elementNodeList; DOMElement *element; DOMNode *node; string elementTagName; void *elementObject; //pre-compile attributes parentObject = createImportedDocumentBase( parentElement, objGrandParent); if (parentObject == NULL) { return NULL; } elementNodeList = parentElement->getChildNodes(); for (int i = 0; i < (int)elementNodeList->getLength(); i++) { node = elementNodeList->item(i); if(node->getNodeType()==DOMNode::ELEMENT_NODE){ element = (DOMElement*)node; elementTagName = XMLString::transcode( element->getTagName() ); if (XMLString::compareIString( elementTagName.c_str(), "importNCL") == 0) { elementObject = parseImportNCL(element, parentObject); if (elementObject != NULL) { addImportNCLToImportedDocumentBase( parentObject, elementObject); } } } } return parentObject; }
list<string> ClsSettingsReader::getListLastFiles() { #ifdef DEBUG_CLSSETTINGSREADER cout << "ClsSettingsReader::getListLastFiles()" << endl; #endif list<string> lstLFO; if(iSysSettingReaderState != PARSER_BUFFER_PARSED){ ClsSettingsReaderException clsSettingsReaderException(ClsSettingsReaderException::BUFFER_NOT_PARSED); throw clsSettingsReaderException; } DOMNodeList* dnlstTemp = ddocIqrSetting->getElementsByTagName(XMLString::transcode(ClsTagLibrary::lastFilesOpen())); DOMNode* dnTemp=NULL; if ( dnlstTemp->getLength() == 1){ dnTemp = dnlstTemp->item(0); } else if ( dnlstTemp->getLength() < 1) { ClsSettingsReaderException clsSettingsReaderException(ClsSettingsReaderException::ENTITY_NOT_FOUND); throw clsSettingsReaderException; } DOMNodeList* dnlstFiles = dnTemp->getChildNodes(); unsigned int ii = 0; while( ii< dnlstFiles->getLength()){ DOMNode* dnTempTemp = dnlstFiles->item(ii); if(dnTempTemp->getNodeType() == 1){ DOMNode* dnValue = dnTempTemp->getFirstChild(); if(dnValue!=NULL){ string strValue = XMLString::transcode(dnValue->getNodeValue()); lstLFO.push_back(strValue); } } ii++; } return lstLFO; };
DOMNode* Triggerconf::getChildOfType (DOMNode* root, short type, unsigned int index) { if (root == NULL) return NULL; if (! root->hasChildNodes ()) return NULL; DOMNodeList* childs = root->getChildNodes (); if (childs == NULL) return NULL; unsigned int idx = 0; for (unsigned int i=0; i<childs->getLength (); i++) { DOMNode* child = childs->item (i); if (child->getNodeType () == type) { if (idx == index) return child; else idx++; } } // for (unsigned int i=0; i<childs->getLength (); i++) return NULL; }
string Triggerconf::getSubmoduleAttributeValue (string module, string submodule, string attributename) { if (! existsSubmodule (module, submodule)) { setError ("invalid submodule"); return ""; } DOMNode* node = selectSubmodule (module, submodule); assert (node->getNodeType () == DOMNode::ELEMENT_NODE); DOMElement* elem = (DOMElement*) node; XMLCh* xattrname = XMLString::transcode (attributename.c_str ()); const XMLCh* xattrval = elem->getAttribute (xattrname); char* charstring = XMLString::transcode (xattrval); string ret = charstring; XMLString::release (&xattrname); XMLString::release (&charstring); resetError (); return ret; }
Triggerconf::STRING_LIST Triggerconf::getConfigAttributeNames (string module, string submodule, string configname) { STRING_LIST ret; if (! existsConfigElement (module, submodule, configname)) return ret; DOMNode* node = selectConfigElement (module, submodule, configname); if (node == NULL || node->getNodeType () != DOMNode::ELEMENT_NODE) return ret; DOMElement* elem = (DOMElement*) node; DOMNamedNodeMap* attributes = elem->getAttributes (); for (unsigned int i=0; i<attributes->getLength (); i++) { DOMNode* attr = attributes->item (i); const XMLCh* xname = attr->getNodeName (); char* cname = XMLString::transcode (xname); ret.push_back (cname); XMLString::release (&cname); } return ret; }
void docSetup(DOMDocument *doc) { // Print out the doc DOMPrintFormatTarget* formatTarget = new DOMPrintFormatTarget(); const XMLCh* encNameStr = XMLString::transcode("UTF-8"); DOMNode *aNode = doc->getFirstChild(); if (aNode->getNodeType() == DOMNode::ENTITY_NODE) { const XMLCh* aStr = ((DOMEntity *)aNode)-> #if defined XSEC_XERCES_DOMENTITYINPUTENCODING getInputEncoding(); #else getEncoding(); #endif if (!strEquals(aStr, "")) { encNameStr = aStr; } } xsecsize_t lent = XMLString::stringLen(encNameStr); gEncodingName = new XMLCh[lent + 1]; XMLString::copyNString(gEncodingName, encNameStr, lent); gEncodingName[lent] = 0; #if defined(XSEC_XERCES_FORMATTER_REQUIRES_VERSION) gFormatter = new XMLFormatter("UTF-8", 0, formatTarget, XMLFormatter::NoEscapes, gUnRepFlags); #else gFormatter = new XMLFormatter("UTF-8", formatTarget, XMLFormatter::NoEscapes, gUnRepFlags); #endif }
ReferenceData CADReader::homeinterface (DOMElement* element) throw(CADReadException) { std::string element_name; ReferenceData data; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = XMLString::transcode(child->getNodeName()); // // homeplacementref // if (element_name == "homeplacementref") { data.kind = HOMEID; data.name = homeplacementref((DOMElement*)(child)); } // // findby // else if (element_name == "findby") { data = findby((DOMElement*)(child)); } } // get next child child = child->getNextSibling(); } return data; }
std::string DTMReader::readConnection(std::string descriptor) throw(DTMReadException) { strConn_ = ""; DOMXMLParser parser; if ( parser.parse( ((char*)descriptor.c_str()) ) != 0 ) { std::cerr << "Error during XML parsing" << std::endl; throw DTMReadException(); } dtm_document_ = parser.getDocument(); DOMNode* child = dtm_document_->getDocumentElement()->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) // handle connection if ( !XMLString::compareString(child->getNodeName(), X("connection")) ) connection((DOMElement*)child); // get next child child = child->getNextSibling(); } for(unsigned int i=0; i<vName_.size(); i++) { strConn_ += vName_[i]; strConn_ += "="; strConn_ += vValue_[i]; strConn_ += ";"; } return strConn_; }
ScriptData CADReader::action (DOMElement* element) throw(CADReadException) { ScriptData data; data.language = Qedo::transcode(element->getAttribute(X("language"))); std::string element_name; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = Qedo::transcode(child->getNodeName()); // // fileinarchive // if (element_name == "fileinarchive") { FileData file_data = fileinarchive( (DOMElement*)child ); std::ifstream file; file.open( file_data.name.c_str() ); if (!file) { NORMAL_ERR2( "CADReader: cannot open file ", file_data.name ); throw CADReadException(); } file >> data.code; file.close(); // todo what to do with the extracted file? } // // scriptcode // else if (element_name == "scriptcode")
string InputHandler::getAttributeValueByName(const XMLCh* elementNode, const XMLCh* attribute, const XMLCh* name) { crusde_debug("%s, line: %d, InputHandler::getAttributeValueByName(%s) name = %s ", __FILE__, __LINE__, XMLString::transcode(elementNode), XMLString::transcode(name)); assert(doc); DOMElement *root = doc->getDocumentElement(); DOMNode *child = root->getFirstChild(); DOMNamedNodeMap *attributes = NULL; while (child) { if(child != NULL) if( child->getNodeType() == DOMNode::ELEMENT_NODE ) { if(child->hasAttributes()) { attributes = child->getAttributes(); if( XMLString::compareIString( child->getNodeName(), elementNode) == 0 && XMLString::compareIString( attributes->getNamedItem(ATTR_name.xmlStr())->getNodeValue(), name) == 0 ) { char *val = XMLString::transcode(attributes->getNamedItem(attribute)->getNodeValue()); string value(val); XMLString::release(&val); return value; } } } child = child->getNextSibling(); } return string(); }
void CCDReader4qxml::componentfeatures (DOMElement* element) throw(CCDReadException) { DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { // // ports // if (!XMLString::compareString(child->getNodeName(), X("ports"))) { ports((DOMElement*)child); } } // get next child child = child->getNextSibling(); } }
// Look at Xerces XSModel to parse XSD into tree SCMPrint void CXercesUtils::NagivateParseTree(xercesc::DOMElement* p, std::string tabs) { string name; short age; tabs+=" "; for (DOMNode* n = p->getFirstChild (); n != 0; n = n->getNextSibling ()) { if (n->getNodeType () != DOMNode::ELEMENT_NODE) continue; DOMElement* e = (DOMElement* ) n; std::string el_name = XMLString::transcode(n->getNodeName()); std::string el_value; if(e->getTextContent () && e->getChildElementCount() == (XMLSize_t) 0) el_value = XMLString::transcode(e->getTextContent ()); std::cerr << tabs.c_str() << el_name.c_str()<< "=" << el_value.c_str()<< endl; //DOMNode* node = n->getFirstChild (); NagivateParseTree((DOMElement*) n,tabs); } tabs=tabs.substr(1); }
std::string CADReader::homeproperties (DOMElement* element) throw(CADReadException) { std::string element_name; std::string file; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = XMLString::transcode(child->getNodeName()); // // fileinarchive // if (element_name == "fileinarchive") { file = fileinarchive((DOMElement*)(child)); } // // codebase // else if (element_name == "codebase") { // todo } } // get next child child = child->getNextSibling(); } return file; }
// Finds and returns the first child node with the given name. DOMElement* XUtil::getFirstChildElementNS(const DOMNode* const parent , const XMLCh** const elemNames , const XMLCh* const uriStr , unsigned int length) { // search for node DOMNode* child = parent->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { for (unsigned int i = 0; i < length; i++) { if (XMLString::equals(child->getNamespaceURI(), uriStr) && XMLString::equals(child->getLocalName(), elemNames[i])) return (DOMElement*)child; } } child = child->getNextSibling(); } // not found return 0; }
// Finds and returns the next sibling element node with the give name. DOMElement* XUtil::getNextSiblingElementNS(const DOMNode* const node , const XMLCh** const elemNames , const XMLCh* const uriStr , unsigned int length) { // search for node DOMNode* sibling = node->getNextSibling(); while (sibling != 0) { if (sibling->getNodeType() == DOMNode::ELEMENT_NODE) { for (unsigned int i = 0; i < length; i++) { if (XMLString::equals(sibling->getNamespaceURI(), uriStr) && XMLString::equals(sibling->getLocalName(), elemNames[i])) return (DOMElement*)sibling; } } sibling = sibling->getNextSibling(); } // not found return 0; }
XERCES_CPP_NAMESPACE_USE std::vector<DgFileTile> DgFileTile::getTiles(XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument* pDocument, const std::string& filename, unsigned int& height, unsigned int& width) { std::vector<DgFileTile> tiles; DOMElement* pRoot = pDocument->getDocumentElement(); if (pRoot == NULL || !XMLString::equals(pRoot->getNodeName(), X("isd"))) { return tiles; } DOMNodeList* pTilList = pRoot->getElementsByTagName(X("TIL")); if (pTilList == NULL || pTilList->getLength() != 1) { return tiles; } DOMNode* pTil = pTilList->item(0); if (pTil == NULL || pTil->getNodeType() != DOMNode::ELEMENT_NODE) { return tiles; } DOMElement* pTilElement = static_cast<DOMElement*>(pTil); DOMNodeList* pTilesList = pTilElement->getElementsByTagName(X("TILE")); if (pTilesList == NULL) { return tiles; } height = 0; width = 0; bool error = false; QFileInfo fileInfo(QString::fromStdString(filename)); QDir fileDir = fileInfo.dir(); for (unsigned int i = 0; i < pTilesList->getLength(); ++i) { DgFileTile curTile; DOMNode* pNode = pTilesList->item(i); if (pNode == NULL || pNode->getNodeType() != DOMNode::ELEMENT_NODE) { continue; } DOMElement* pElement = static_cast<DOMElement*>(pNode); DOMElement* pChildElement = pElement->getFirstElementChild(); while (pChildElement != NULL) { std::string textContent = A(pChildElement->getTextContent()); if (XMLString::equals(pChildElement->getNodeName(), X("FILENAME"))) { curTile.mTilFilename = fileDir.filePath(QString::fromStdString(textContent)).toStdString(); } if (XMLString::equals(pChildElement->getNodeName(), X("ULCOLOFFSET"))) { curTile.mStartCol = StringUtilities::fromXmlString<unsigned int>(textContent, &error); } if (XMLString::equals(pChildElement->getNodeName(), X("ULROWOFFSET"))) { curTile.mStartRow = StringUtilities::fromXmlString<unsigned int>(textContent, &error); } if (XMLString::equals(pChildElement->getNodeName(), X("LRCOLOFFSET"))) { curTile.mEndCol = StringUtilities::fromXmlString<unsigned int>(textContent, &error); } if (XMLString::equals(pChildElement->getNodeName(), X("LRROWOFFSET"))) { curTile.mEndRow = StringUtilities::fromXmlString<unsigned int>(textContent, &error); } pChildElement = pChildElement->getNextElementSibling(); } tiles.push_back(curTile); if (curTile.mEndCol > width) { width = curTile.mEndCol; } if (curTile.mEndRow > height) { height = curTile.mEndRow; } } return tiles; }