struct Node * getParentNode(struct Node* root, int key)
{
if (root == NULL) return NULL;
struct Node* current = root;
if (current->key == key) return NULL;
if (key < current->key)
{
if (key == current->left->key)
{
return current;
} else {
current = current->left;
return getParentNode(current,key);
}
} else {
if (key == current->right->key)
{
return current;
} else {
current = current->right;
return getParentNode(current,key);
}
}
}
DOM_Node TreeWalkerImpl::nextNode () {
DOM_Node result;
if (fCurrentNode.isNull()) return result;
result = getFirstChild(fCurrentNode);
if (! result.isNull()) {
fCurrentNode = result;
return result;
}
result = getNextSibling(fCurrentNode);
if (! result.isNull()) {
fCurrentNode = result;
return result;
}
// return parent's 1st sibling.
DOM_Node parent = getParentNode(fCurrentNode);
while (! parent.isNull()) {
result = getNextSibling(parent);
if (! result.isNull()) {
fCurrentNode = result;
return result;
} else {
parent = getParentNode(parent);
}
}
// end , return null
return result;
}
DOMNode* DOMTreeWalkerImpl::nextNode () {
if (!fCurrentNode) return 0;
DOMNode* node = getFirstChild(fCurrentNode);
if (node != 0) {
fCurrentNode = node;
return node;
}
else {
node = getNextSibling(fCurrentNode);
if (node != 0) {
fCurrentNode = node;
return node;
}
else {
// return parent's 1st sibling.
DOMNode* parent = getParentNode(fCurrentNode);
while ( parent != 0) {
node = getNextSibling(parent);
if (node != 0) {
fCurrentNode = node;
return node;
} else {
parent = getParentNode(parent);
}
}
return node;
}
}
}
DOMNode* DOMTreeWalkerImpl::previousNode () {
if (!fCurrentNode) return 0;
// get sibling
DOMNode* node = getPreviousSibling(fCurrentNode);
if (node == 0) {
node = getParentNode(fCurrentNode);
if ( node != 0) {
fCurrentNode = node;
}
return node;
}
else {
// get the lastChild of result.
DOMNode* lastChild = getLastChild(node);
// if there is a lastChild which passes filters return it.
if (lastChild != 0) {
fCurrentNode = lastChild;
}
else {
fCurrentNode = node;
}
return fCurrentNode;
}
}
DOM_Node TreeWalkerImpl::previousNode () {
DOM_Node result;
if (fCurrentNode.isNull()) return result;
// get sibling
result = getPreviousSibling(fCurrentNode);
if (result.isNull()) {
result = getParentNode(fCurrentNode);
if (! result.isNull()) {
fCurrentNode = result;
return fCurrentNode;
}
return result;
}
// get the lastChild of result.
DOM_Node lastChild = getLastChild(result);
// if there is a lastChild which passes filters return it.
if (! lastChild.isNull()) {
fCurrentNode = lastChild;
return fCurrentNode;
}
// otherwise return the previous sibling.
if (! result.isNull()) {
fCurrentNode = result;
return fCurrentNode;
}
// otherwise return null.
return result;
}
bool EmulatePrecision::visitAggregate(Visit visit, TIntermAggregate *node)
{
if (visit != PreVisit)
return true;
switch (node->getOp())
{
case EOpCallInternalRawFunction:
case EOpCallFunctionInAST:
// User-defined function return values are not rounded. The calculations that produced
// the value inside the function definition should have been rounded.
break;
case EOpConstruct:
if (node->getBasicType() == EbtStruct)
{
break;
}
default:
TIntermNode *parent = getParentNode();
if (canRoundFloat(node->getType()) && ParentUsesResult(parent, node) &&
!ParentConstructorTakesCareOfRounding(parent, node))
{
TIntermNode *replacement = createRoundingFunctionCallNode(node);
queueReplacement(replacement, OriginalNode::BECOMES_CHILD);
}
break;
}
return true;
}
/**
* Release this node and resources associated with it, and also its children.
*/
void NCDElementImpl::release()
{
if (NULL != getParentNode())
{
throw new NCDException(NCDException::INVALID_ACCESS_ERR);
}
try
{
// release children
while (hasChildNodes())
{
NCDNode* childNode = getFirstChild();
removeChild(childNode);
childNode->release();
}
// dispose this node.
static_cast<NCDDocumentImpl*>(document)->disposeNode(this);
}
catch (NCDException* ex)
{
ASSERT(FALSE);
// ignore
ex->Delete();
}
}
bool EmulatePrecision::visitUnary(Visit visit, TIntermUnary *node)
{
switch (node->getOp())
{
case EOpNegative:
case EOpVectorLogicalNot:
case EOpLogicalNot:
break;
case EOpPostIncrement:
case EOpPostDecrement:
case EOpPreIncrement:
case EOpPreDecrement:
if (visit == PreVisit)
mInLValue = true;
else if (visit == PostVisit)
mInLValue = false;
break;
default:
if (canRoundFloat(node->getType()) && visit == PreVisit)
{
TIntermNode *parent = getParentNode();
TIntermNode *replacement = createRoundingFunctionCallNode(node);
mReplacements.push_back(NodeUpdateEntry(parent, node, replacement, true));
}
break;
}
return true;
}
//
// splitText. revist - factor into a common function for use
// here and in DOMTextImpl
//
DOMText *DOMCDATASectionImpl::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()->createCDATASection(
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;
}
//-----------------------------------------------------------------------
void VortexExtern::_preProcessParticles(ParticleTechnique* particleTechnique, Real timeElapsed)
{
if (isAttached())
{
position = getParentNode()->_getDerivedPosition();
mDerivedPosition = position;
}
}
bool Node::isAncestorNode(Node *node)
{
for (Node *parentNode = getParentNode(); parentNode; parentNode = parentNode->getParentNode()) {
if (node == parentNode)
return true;
}
return false;
}
void
ColladaGeometry::ColladaGeometryInstInfo::process(void)
{
Node *geoInstN = dynamic_cast<Node *>(
getColInst()->getTargetElem()->createInstance(this));
getParentNode()->addChild(geoInstN);
}
bool ThemeParser::parserCallback_widget(ParserNode *node) {
Common::String var;
if (getParentNode(node)->name == "globals") {
if (resolutionCheck(node->values["resolution"]) == false) {
node->ignore = true;
return true;
}
var = "Globals." + node->values["name"] + ".";
if (!parseCommonLayoutProps(node, var))
return parserError("Error parsing Layout properties of '%s'.", var.c_str());
} else {
// FIXME: Shouldn't we distinguish the name/id and the label of a widget?
var = node->values["name"];
int width = -1;
int height = -1;
bool enabled = true;
if (node->values.contains("enabled")) {
if (node->values["enabled"] == "false")
enabled = false;
else if (node->values["enabled"] != "true")
return parserError("Invalid value for Widget enabling (expecting true/false)");
}
if (node->values.contains("width")) {
if (_theme->getEvaluator()->hasVar(node->values["width"]) == true)
width = _theme->getEvaluator()->getVar(node->values["width"]);
else if (!parseIntegerKey(node->values["width"].c_str(), 1, &width))
return parserError("Corrupted width value in key for %s", var.c_str());
}
if (node->values.contains("height")) {
if (_theme->getEvaluator()->hasVar(node->values["height"]) == true)
height = _theme->getEvaluator()->getVar(node->values["height"]);
else if (!parseIntegerKey(node->values["height"].c_str(), 1, &height))
return parserError("Corrupted height value in key for %s", var.c_str());
}
Graphics::TextAlign alignH = Graphics::kTextAlignLeft;
if (node->values.contains("textalign")) {
if((alignH = parseTextHAlign(node->values["textalign"])) == Graphics::kTextAlignInvalid)
return parserError("Invalid value for text alignment.");
}
_theme->getEvaluator()->addWidget(var, width, height, node->values["type"], enabled, alignH);
}
return true;
}
/**-------------------------------------------------------------------------------
update
@brief
@return void
---------------------------------------------------------------------------------*/
void SensorDecoratorVector::update()
{
mSensor->update();
if (getDataValid())
{
std::vector<Ogre::Vector3> out;
getValue(out);
Ogre::Vector3 pos(out[0].x, out[0].y, out[0].z);
Ogre::Vector3 force(out[1].x, out[1].y, out[1].z);
getParentNode()->setPosition(pos);
setVisible(true);
Ogre::Vector3 posA(0, 0, 0);
Ogre::Vector3 posB = force / force.length() * 5;
Ogre::Vector3 t0 = posB - posA;
NxVec3 tan1, tan2;
NxVec3 v3 = NxOgre::NxConvert<NxVec3, Ogre::Vector3>(t0);
NxNormalToTangents(v3, tan1, tan2);
t0.normalise();
Ogre::Vector3 t1 = NxOgre::NxConvert<Ogre::Vector3, NxVec3>(tan1);
Ogre::Vector3 t2 = NxOgre::NxConvert<Ogre::Vector3, NxVec3>(tan2);
Ogre::Vector3 lobe1 = posB - t0 * ARROW_H + t1 * ARROW_H;
Ogre::Vector3 lobe2 = posB - t0 * ARROW_H - t1 * ARROW_H;
Ogre::Vector3 lobe3 = posB - t0 * ARROW_H + t2 * ARROW_H;
Ogre::Vector3 lobe4 = posB - t0 * ARROW_H - t2 * ARROW_H;
beginUpdate(0);
position(posA);
position(posB);
position(posB);
position(lobe1);
position(posB);
position(lobe2);
position(posB);
position(lobe3);
position(posB);
position(lobe4);
end();
}
else
{
setVisible(false);
}
// if drawing is not persistent remove it after one draw
if (getVisible() && !mPersistent && getDataValid())
{
setDataValid(false);
}
}
void BuddyListNode::update()
{
// cache the last_activity time
last_activity = purple_blist_node_get_int(blist_node, "last_activity");
BuddyListNode *parent_node = getParentNode();
// the parent could have changed, so re-parent the node
if (parent_node)
treeview->setNodeParent(ref, parent_node->getRefNode());
}
bool Node::isInlineChildNode()
{
Node *parentNode = getParentNode();
while (parentNode != NULL) {
if (parentNode->isInlineNode() == true)
return true;
parentNode = parentNode->getParentNode();
}
return false;
}
//-----------------------------------------------------------------------
void SphereColliderExtern::_preProcessParticles(ParticleTechnique* particleTechnique, Real timeElapsed)
{
if (isAttached())
{
// Use the position of the parent node in this case.
position = getParentNode()->_getDerivedPosition();
mDerivedPosition = position;
mSphere.setCenter(mDerivedPosition);
}
}
void EmulatePrecision::visitSymbol(TIntermSymbol *node)
{
if (canRoundFloat(node->getType()) &&
!mDeclaringVariables && !mInLValue && !mInFunctionCallOutParameter)
{
TIntermNode *parent = getParentNode();
TIntermNode *replacement = createRoundingFunctionCallNode(node);
mReplacements.push_back(NodeUpdateEntry(parent, node, replacement, true));
}
}
void
TerrainTileEditable::_notifyHeightModified(int xstart, int zstart, int xend, int zend)
{
assert(0 <= xstart && xstart < xend && xend <= mXSize+1);
assert(0 <= zstart && zstart < zend && zend <= mZSize+1);
if (mVertexDatas.empty())
{
// Nothing todo when buffer never initialised
return;
}
// TODO: (optimization) some grid may be need to recompute normal only
TerrainData* data = mOwner->getData();
Ogre::HardwareVertexBufferSharedPtr posNormBuffer = mVertexDatas.front()->vertexBufferBinding->getBuffer(0);
float* pPosNormBuffer = static_cast<float*>(posNormBuffer->lock(Ogre::HardwareBuffer::HBL_NORMAL));
float buffer[6];
int xsize = mXSize;
int zsize = mZSize;
int xbase = mXBase;
int zbase = mZBase;
for (int z = zstart; z < zend; ++z)
{
for (int x = xstart; x < xend; ++x)
{
Ogre::Vector3 v;
v = data->_getPosition(x+xbase, z+zbase);
buffer[0] = v.x; buffer[1] = v.y; buffer[2] = v.z;
v = data->_getNormal(x+xbase, z+zbase);
buffer[3] = v.x; buffer[4] = v.y; buffer[5] = v.z;
if (0 < z)
{
if (0 < x)
memcpy(pPosNormBuffer + (((z-1) * xsize + (x-1)) * 4 + 3) * 6, buffer, 6*sizeof(float));
if (x < xsize)
memcpy(pPosNormBuffer + (((z-1) * xsize + (x-0)) * 4 + 2) * 6, buffer, 6*sizeof(float));
}
if (z < zsize)
{
if (0 < x)
memcpy(pPosNormBuffer + (((z-0) * xsize + (x-1)) * 4 + 1) * 6, buffer, 6*sizeof(float));
if (x < xsize)
memcpy(pPosNormBuffer + (((z-0) * xsize + (x-0)) * 4 + 0) * 6, buffer, 6*sizeof(float));
}
}
}
posNormBuffer->unlock();
// re-compue bounding box
data->_computeTileBoundingBox(mBounds, xbase, zbase, xsize, zsize);
// trigger update of bounding box
getParentNode()->needUpdate();
}
bool XMLParser::parseActiveKey(bool closed) {
bool ignore = false;
assert(_activeKey.empty() == false);
ParserNode *key = _activeKey.top();
if (key->name == "xml" && key->header == true) {
assert(closed);
return parseXMLHeader(key) && closeKey();
}
XMLKeyLayout *layout = (_activeKey.size() == 1) ? _XMLkeys : getParentNode(key)->layout;
if (layout->children.contains(key->name)) {
key->layout = layout->children[key->name];
Common::StringMap localMap = key->values;
int keyCount = localMap.size();
for (Common::List<XMLKeyLayout::XMLKeyProperty>::const_iterator i = key->layout->properties.begin(); i != key->layout->properties.end(); ++i) {
if (i->required && !localMap.contains(i->name))
return parserError("Missing required property '%s' inside key '%s'", i->name.c_str(), key->name.c_str());
else if (localMap.contains(i->name))
keyCount--;
}
if (keyCount > 0)
return parserError("Unhandled property inside key '%s'.", key->name.c_str());
} else {
return parserError("Unexpected key in the active scope ('%s').", key->name.c_str());
}
// check if any of the parents must be ignored.
// if a parent is ignored, all children are too.
for (int i = _activeKey.size() - 1; i >= 0; --i) {
if (_activeKey[i]->ignore)
ignore = true;
}
if (ignore == false && keyCallback(key) == false) {
// HACK: People may be stupid and overlook the fact that
// when keyCallback() fails, a parserError() must be set.
// We set it manually in that case.
if (_state != kParserError)
parserError("Unhandled exception when parsing '%s' key.", key->name.c_str());
return false;
}
if (closed)
return closeKey();
return true;
}
/** Return the parent Node from the current node,
* after applying filter, whatToshow.
* If result is not null, set the current Node.
*/
DOMNode* DOMTreeWalkerImpl::parentNode () {
if (!fCurrentNode) return 0;
DOMNode* node = getParentNode(fCurrentNode);
if (node != 0) {
fCurrentNode = node;
}
return node;
}
//-------------------------------------------------------------------------
void Sound::_notifyMoved()
{
MovableObject::_notifyMoved();
SoundSystem::getSingleton().updateBstCenter(this);
if(mSoundPlayInfo && !mSoundPlayInfo->playContext.isNull()
&& m3D)
{
mSoundPlayInfo->playContext->setPosition(
getParentNode()->_getDerivedPosition());
}
}
//-----------------------------------------------------------------------
void BoxColliderExtern::_preProcessParticles(ParticleTechnique* particleTechnique, Real timeElapsed)
{
if (isAttached())
{
// Use the position of the parent node in this case.
position = getParentNode()->_getDerivedPosition();
mDerivedPosition = position;
populateAlignedBox(mBox, mDerivedPosition, mWidth, mHeight, mDepth);
_calculateBounds();
}
}
void EmulatePrecision::visitSymbol(TIntermSymbol *node)
{
TIntermNode *parent = getParentNode();
if (canRoundFloat(node->getType()) && ParentUsesResult(parent, node) &&
!ParentConstructorTakesCareOfRounding(parent, node) && !mDeclaringVariables &&
!isLValueRequiredHere())
{
TIntermNode *replacement = createRoundingFunctionCallNode(node);
queueReplacement(replacement, OriginalNode::BECOMES_CHILD);
}
}
/** Return the parent Node from the current node,
* after applying filter, whatToshow.
* If result is not null, set the current Node.
*/
DOM_Node TreeWalkerImpl::parentNode () {
DOM_Node result;
if (fCurrentNode.isNull()) return result;
DOM_Node node = getParentNode(fCurrentNode);
if (node != 0) {
fCurrentNode = node;
}
return node;
}
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;
}
}
long PANEElement::getLeftOffset(){
PANEElement * const parent = dynamic_cast< PANEElement * >( getParentNode() );
if( NULL == parent ) return 0;
PANEElement * const prevSibling = dynamic_cast< PANEElement * >( getPreviousSibling() );
if( NULL == prevSibling )
return parent->getLeftOffset();
const unsigned long availableWidth = getAvailableWidth();
if( availableWidth < getActualWidth( availableWidth ) )
return parent->getLeftOffset();
return prevSibling->getRightOffset();
}
DOMNode* DOMTreeWalkerImpl::getParentNode (DOMNode* node) {
if (!node || node == fRoot) return 0;
DOMNode* newNode = node->getParentNode();
if (!newNode) return 0;
short accept = acceptNode(newNode);
if (accept == DOMNodeFilter::FILTER_ACCEPT)
return newNode;
return getParentNode(newNode);
}
void
IntersectGrid::fillPosition( const PositionArray &posArray )
{
size_t posCount = posArray.size();
if ( posCount <= 0 )
return;
// if ( posCount > mCurrentVertexCount )
// {
// 如果缓冲区不够用了，就扩容一倍
// mCurrentVertexCount = posCount<<1;
// 如果不每帧创建缓冲区的话，由于lock时用的是discard，所以上次缓冲区中的内容还是会被显示
mCurrentVertexCount = posCount;
_createBuffer();
// }
Ogre::Vector3 vmax = posArray[posCount-1];
Ogre::Vector3 vmin = posArray[0];
vmin.y -= 100.0f;
vmax.y += 100.0f;
Real sqLen = std::max(vmax.squaredLength(), vmin.squaredLength());
mRadius = Ogre::Math::Sqrt(sqLen);//
mBox.setExtents(vmin,vmax);//
getParentNode()->needUpdate();//
float *vertexPos = static_cast<float*>(vbuf->lock(Ogre::HardwareBuffer::HBL_DISCARD));
for (size_t i = 0; i < posCount; ++i)
{
*vertexPos++ = posArray[i].x;
*vertexPos++ = posArray[i].y+1;
*vertexPos++ = posArray[i].z;
Ogre::RGBA *pCol;
pCol = static_cast<Ogre::RGBA*>(static_cast<void*>(vertexPos));
// 用diffuse来做为alpha来源
Ogre::Root::getSingleton().convertColourValue(mGridsColour, pCol++ ) ;
vertexPos = static_cast<float*>(static_cast<void*>(pCol));
}
vbuf->unlock();
}
std::string &uSQL::SQLSet::toString(std::string &buf)
{
std::ostringstream oss;
oss << name;
SQLNode *parentNode = getParentNode();
oss << ((isUnQLNode() && (parentNode->isColumnsNode() || parentNode->isValuesNode())) ? ":" : " = ");
std::string valueString;
oss << SQLExpression::toString(valueString);
buf = oss.str();
return buf;
}
