const wchar_t* ImplAAFTypeDefExtEnum::elementName(OMUInt32 index) const
{
TRACE("ImplAAFTypeDefExtEnum::elementName");
PRECONDITION( "Valid index", index < elementCount() );
// Get the element names buffer and the number of characters in the buffer
const wchar_t* namesBuffer =
reinterpret_cast<const wchar_t*>(_ElementNames.bits());
const size_t namesBufferSize = _ElementNames.bitsSize() / sizeof(wchar_t);
// Allocate an array that will contain the pointers to the element names
const size_t nameCount =
ImplAAFTypeDef::stringArrayStringCount( namesBuffer, namesBufferSize );
ASSERT( "Valid name count", nameCount == elementCount() );
const wchar_t** names = new const wchar_t*[ nameCount ];
// Get the pointers to the element names
ImplAAFTypeDef::getStringArrayStrings( namesBuffer,
namesBufferSize,
names,
nameCount );
// The reguested element name
const wchar_t* result = names[index];
delete[] names;
names = 0;
POSTCONDITION( "Valid result", result != 0 );
return result;
}
Uniform::Uniform(GLenum type, GLenum precision, const std::string &name, unsigned int arraySize)
: type(type), precision(precision), name(name), arraySize(arraySize)
{
int bytes = gl::UniformInternalSize(type) * elementCount();
data = new unsigned char[bytes];
memset(data, 0, bytes);
dirty = true;
psRegisterIndex = -1;
vsRegisterIndex = -1;
registerCount = VariableRowCount(type) * elementCount();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigFemPart::findIntersectingCells(const cvf::BoundingBox& inputBB, std::vector<size_t>* elementIndices) const
{
if (m_elementSearchTree.isNull())
{
// build tree
size_t elmCount = elementCount();
std::vector<cvf::BoundingBox> cellBoundingBoxes;
cellBoundingBoxes.resize(elmCount);
for (size_t elmIdx = 0; elmIdx < elmCount; ++elmIdx)
{
const int* cellIndices = connectivities(elmIdx);
cvf::BoundingBox& cellBB = cellBoundingBoxes[elmIdx];
cellBB.add(m_nodes.coordinates[cellIndices[0]]);
cellBB.add(m_nodes.coordinates[cellIndices[1]]);
cellBB.add(m_nodes.coordinates[cellIndices[2]]);
cellBB.add(m_nodes.coordinates[cellIndices[3]]);
cellBB.add(m_nodes.coordinates[cellIndices[4]]);
cellBB.add(m_nodes.coordinates[cellIndices[5]]);
cellBB.add(m_nodes.coordinates[cellIndices[6]]);
cellBB.add(m_nodes.coordinates[cellIndices[7]]);
}
m_elementSearchTree = new cvf::BoundingBoxTree;
m_elementSearchTree->buildTreeFromBoundingBoxes(cellBoundingBoxes, NULL);
}
m_elementSearchTree->findIntersections(inputBB, elementIndices);
}
void CSenLayeredXmlProperties::ElementsL(RPointerArray<CSenElement>& aProps) const
{
if ( ipChildProperties )
{
ipChildProperties->ElementsL(aProps);
}
RPointerArray<CSenElement>& elements = ipFragment->AsElement().ElementsL();
TInt elementCount(elements.Count());
TInt propsCount(0);
TBool found;
for (TInt i=0; i<elementCount; i++)
{
found = EFalse;
propsCount = aProps.Count();
for (TInt j=0; j<propsCount; j++)
{
if ( elements[i]->LocalName() == aProps[j]->LocalName() )
{
found = ETrue;
break;
}
}
if ( !found )
{
#ifdef EKA2
aProps.AppendL(elements[i]);
#else
User::LeaveIfError(aProps.Append(elements[i]));
#endif
}
}
}
void
for_each_host(TInView aInView, TFunctor aOperator, TPolicy aPolicy)
{
for (int i = 0; i < elementCount(aInView); ++i) {
aOperator(linear_access(aInView, i));
}
}
void CSketcherDoc::Serialize(CArchive& ar)
{
if (ar.IsStoring()) {
ar << m_Color // Store the current color
<< static_cast<int>(m_Element) // the current element type as an integer
<< m_PenWidth // and the current pen width
<< m_DocSize; // and the current document size
ar << m_ElementList.size(); // Store the number of elements in the list
// Now store the elements from the list
for (auto iter = m_ElementList.begin() ; iter != m_ElementList.end() ; ++iter)
ar << *iter; // Store the element
} else {
int elementType(0); // Stores element type
ar >> m_Color // Retrieve the current color
>> elementType // the current element type as an integer
>> m_PenWidth // and the current pen width
>> m_DocSize; // and the current document size
m_Element = static_cast<ElementType>(elementType);
size_t elementCount(0); // Count of number of elements
CElement* pElement(nullptr); // Element pointer
ar >> elementCount; // retrieve the element count
// Now retrieve all the elements and store in the list
for (size_t i = 0 ; i < elementCount ; ++i) {
ar >> pElement;
m_ElementList.push_back(pElement);
}
}
}
void DrawExecution::drawElements() const
{
gl::glBindVertexArray(m_drawImpl.glVertexArray);
gl::glDrawElements(m_drawImpl.state.rasterizerState().primitive(),
elementCount(),
elementType(),
nullptr);
}
XmlElement *
XmlElement::elementAt( int index ) const
{
if ( index < 0 || index >= elementCount() )
throw std::invalid_argument( "XmlElement::elementAt(), out of range index" );
return m_elements[ index ];
}
void
for_each_position_host(TInView aInView, TFunctor aOperator, TPolicy aPolicy)
{
for (int i = 0; i < elementCount(aInView); ++i) {
auto index = index_from_linear_access_index(aInView, i);
aOperator(aInView[index], index);
}
}
OMUniqueObjectIdentification
ImplAAFTypeDefExtEnum::elementValue( aafUInt32 index ) const
{
TRACE("ImplAAFTypeDefExtEnum::elementValue");
PRECONDITION("Valid index", index < elementCount());
const aafUID_t& value = _ElementValues.getAt(index);
const OMObjectIdentification& result =
*reinterpret_cast<const OMObjectIdentification*>(&value);
return result;
}
/******************************************************************************
* Renders the geometry as triangle mesh with normals.
******************************************************************************/
void OpenGLArrowPrimitive::renderWithNormals(ViewportSceneRenderer* renderer)
{
QOpenGLShaderProgram* shader = renderer->isPicking() ? _pickingShader : _shader;
if(!shader->bind())
throw Exception(QStringLiteral("Failed to bind OpenGL shader."));
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
shader->setUniformValue("modelview_projection_matrix", (QMatrix4x4)(renderer->projParams().projectionMatrix * renderer->modelViewTM()));
if(!renderer->isPicking())
shader->setUniformValue("normal_matrix", (QMatrix3x3)(renderer->modelViewTM().linear().inverse().transposed()));
GLint pickingBaseID;
if(renderer->isPicking()) {
pickingBaseID = renderer->registerSubObjectIDs(elementCount());
renderer->activateVertexIDs(shader, _chunkSize * _verticesPerElement, true);
}
for(int chunkIndex = 0; chunkIndex < _verticesWithNormals.size(); chunkIndex++, pickingBaseID += _chunkSize) {
int chunkStart = chunkIndex * _chunkSize;
int chunkSize = std::min(_elementCount - chunkStart, _chunkSize);
if(renderer->isPicking())
shader->setUniformValue("pickingBaseID", pickingBaseID);
_verticesWithNormals[chunkIndex].bindPositions(renderer, shader, offsetof(VertexWithNormal, pos));
if(!renderer->isPicking()) {
_verticesWithNormals[chunkIndex].bindNormals(renderer, shader, offsetof(VertexWithNormal, normal));
_verticesWithNormals[chunkIndex].bindColors(renderer, shader, 4, offsetof(VertexWithNormal, color));
}
int stripPrimitivesPerElement = _stripPrimitiveVertexCounts.size() / _chunkSize;
int stripVerticesPerElement = std::accumulate(_stripPrimitiveVertexCounts.begin(), _stripPrimitiveVertexCounts.begin() + stripPrimitivesPerElement, 0);
OVITO_CHECK_OPENGL(shader->setUniformValue("verticesPerElement", (GLint)stripVerticesPerElement));
OVITO_CHECK_OPENGL(renderer->glMultiDrawArrays(GL_TRIANGLE_STRIP, _stripPrimitiveVertexStarts.data(), _stripPrimitiveVertexCounts.data(), stripPrimitivesPerElement * chunkSize));
int fanPrimitivesPerElement = _fanPrimitiveVertexCounts.size() / _chunkSize;
int fanVerticesPerElement = std::accumulate(_fanPrimitiveVertexCounts.begin(), _fanPrimitiveVertexCounts.begin() + fanPrimitivesPerElement, 0);
OVITO_CHECK_OPENGL(shader->setUniformValue("verticesPerElement", (GLint)fanVerticesPerElement));
OVITO_CHECK_OPENGL(renderer->glMultiDrawArrays(GL_TRIANGLE_FAN, _fanPrimitiveVertexStarts.data(), _fanPrimitiveVertexCounts.data(), fanPrimitivesPerElement * chunkSize));
_verticesWithNormals[chunkIndex].detachPositions(renderer, shader);
if(!renderer->isPicking()) {
_verticesWithNormals[chunkIndex].detachNormals(renderer, shader);
_verticesWithNormals[chunkIndex].detachColors(renderer, shader);
}
}
if(renderer->isPicking())
renderer->deactivateVertexIDs(shader, true);
shader->release();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
float RigFemPart::characteristicElementSize()
{
if (m_characteristicElementSize != std::numeric_limits<float>::infinity()) return m_characteristicElementSize;
// take 100 elements
float elmIdxJump = elementCount() / 100.0f;
int elmIdxIncrement = elmIdxJump < 1 ? 1: (int) elmIdxJump;
int elmsToAverageCount = 0;
float sumMaxEdgeLength = 0;
for (int elmIdx = 0; elmIdx < elementCount(); elmIdx += elmIdxIncrement)
{
RigElementType eType = this->elementType(elmIdx);
if (eType == HEX8 || eType == HEX8P)
{
const int* elmentConn = this->connectivities(elmIdx);
cvf::Vec3f nodePos0 = this->nodes().coordinates[elmentConn[0]];
cvf::Vec3f nodePos1 = this->nodes().coordinates[elmentConn[1]];
cvf::Vec3f nodePos3 = this->nodes().coordinates[elmentConn[3]];
cvf::Vec3f nodePos4 = this->nodes().coordinates[elmentConn[4]];
float l1 = (nodePos1-nodePos0).length();
float l3 = (nodePos3-nodePos0).length();
float l4 = (nodePos4-nodePos0).length();
float maxLength = l1 > l3 ? l1: l3;
maxLength = maxLength > l4 ? maxLength: l4;
sumMaxEdgeLength += maxLength;
++elmsToAverageCount;
}
}
CVF_ASSERT(elmsToAverageCount);
m_characteristicElementSize = sumMaxEdgeLength/elmsToAverageCount;
return m_characteristicElementSize;
}
THtmlElement &THtmlParser::insertNewElement(int parent, int index)
{
if (elementCount() > 1 && last().isEmpty()) {
// Re-use element
changeParent(lastIndex(), parent, index);
} else {
elements.resize(elements.size() + 1);
last().parent = parent;
if (index >= 0 && index < elements[parent].children.count()) {
elements[parent].children.insert(index, lastIndex());
} else {
elements[parent].children.append(lastIndex());
}
}
return last();
}
float HdfDataset::readFloat() const
{
if ( elementCount() != 1 )
{
MDAL::debug( "Not scalar!" );
return 0;
}
float value;
herr_t status = H5Dread( d->id, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &value );
if ( status < 0 )
{
MDAL::debug( "Failed to read data!" );
return 0;
}
return value;
}
std::string HdfDataset::readString() const
{
if ( elementCount() != 1 )
{
MDAL::debug( "Not scalar!" );
return std::string();
}
char name[HDF_MAX_NAME];
hid_t datatype = H5Tcopy( H5T_C_S1 );
H5Tset_size( datatype, HDF_MAX_NAME );
herr_t status = H5Dread( d->id, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, name );
if ( status < 0 )
{
MDAL::debug( "Failed to read data!" );
return std::string();
}
H5Tclose( datatype );
return std::string( name );
}
void THtmlParser::merge(const THtmlParser &other)
{
if (elementCount() <= 1 || other.elementCount() <= 1 || at(1).tag != other.at(1).tag) {
return;
}
// Adds attributes
for (int i = 0; i < other.at(1).attributes.count(); ++i) {
const QPair<QString, QString> &p = other.at(1).attributes[i];
at(1).setAttribute(p.first, THttpUtility::trimmedQuotes(p.second));
}
if (!other.at(1).text.isEmpty()
|| (at(1).children.isEmpty() && !other.at(1).children.isEmpty())) {
at(1).text = other.at(1).text;
}
// Merges the elements
for (int i = 0; i < other.at(1).children.count(); ++i) {
prepend(1, other.mid(other.at(1).children[i]));
}
}
QString ArrayPin::toString() const
{
return( QString( "<p>Type: %1</p><p>Count: %2</p><p>Size: %3</p><p>Total Size: %4</p>" ).arg( QString( QMetaType::typeName( type() ) ) ).arg( count() ).arg( elementCount() ).arg( byteCount() ) );
}
void CSenLayeredXmlProperties::WriteToL(RWriteStream& aWriteStream)
{
// Find out whether we should declare the namespace
TPtrC8 nsPrefix = ipFragment->NsPrefix();
// Element name
aWriteStream.WriteL(KSenLessThan);
if ( nsPrefix.Length() > 0 )
{
aWriteStream.WriteL(nsPrefix);
aWriteStream.WriteL(KSenColon);
}
aWriteStream.WriteL(ipFragment->AsElement().LocalName());
RPointerArray<CSenBaseAttribute>& attrs = ipFragment->AsElement().AttributesL();
RPointerArray<CSenNamespace>& namespaces = ipFragment->AsElement().NamespacesL();
if ( ( attrs.Count() > 0 ) || ( namespaces.Count() > 0 ) )
{
CSenNamespace* ns = NULL;
TInt count = namespaces.Count();
for (TInt i=0; i < count; i++)
{
ns = (namespaces)[i];
if (ns)
{
aWriteStream.WriteL(KSenSpaceXmlns);
if (ns->Prefix().Length() > 0)
{
aWriteStream.WriteL(KSenColon);
aWriteStream.WriteL(ns->Prefix());
}
aWriteStream.WriteL(KSenEqualsDblQuot);
aWriteStream.WriteL(ns->URI());
aWriteStream.WriteL(KSenDblQuot);
}
}
count = attrs.Count();
for (TInt j = 0; j < count; j++)
{
aWriteStream.WriteL(KSenSpace);
aWriteStream.WriteL((attrs)[j]->Name());
aWriteStream.WriteL(KSenEqualsDblQuot);
aWriteStream.WriteL((attrs)[j]->Value());
aWriteStream.WriteL(KSenDblQuot);
}
}
// Elements and content
RPointerArray<CSenElement> elements;
ElementsL(elements);
if ( (elements.Count() > 0) || ipFragment->AsElement().HasContent() )
{
aWriteStream.WriteL(KSenGreaterThan);
// Body
TInt elementCount(elements.Count());
for (TInt k=0; k<elementCount; k++)
{
elements[k]->WriteAsXMLToL(aWriteStream);
}
aWriteStream.WriteL(ipFragment->AsElement().Content());
// Closing element
aWriteStream.WriteL(KSenLessThanSlash);
if (nsPrefix.Length() > 0)
{
aWriteStream.WriteL(nsPrefix);
aWriteStream.WriteL(KSenColon);
}
aWriteStream.WriteL(ipFragment->AsElement().LocalName());
aWriteStream.WriteL(KSenGreaterThan);
}
else
{
aWriteStream.WriteL(KSenSlashGreaterThan);
}
elements.Close();
}
bool
ShaderValidator::CanLinkTo(const ShaderValidator* prev, nsCString* const out_log) const
{
if (!prev) {
nsPrintfCString error("Passed in NULL prev ShaderValidator.");
*out_log = error;
return false;
}
{
const std::vector<sh::Uniform>* vertPtr = ShGetUniforms(prev->mHandle);
const std::vector<sh::Uniform>* fragPtr = ShGetUniforms(mHandle);
if (!vertPtr || !fragPtr) {
nsPrintfCString error("Could not create uniform list.");
*out_log = error;
return false;
}
for (auto itrFrag = fragPtr->begin(); itrFrag != fragPtr->end(); ++itrFrag) {
for (auto itrVert = vertPtr->begin(); itrVert != vertPtr->end(); ++itrVert) {
if (itrVert->name != itrFrag->name)
continue;
if (!itrVert->isSameUniformAtLinkTime(*itrFrag)) {
nsPrintfCString error("Uniform `%s`is not linkable between"
" attached shaders.",
itrFrag->name.c_str());
*out_log = error;
return false;
}
break;
}
}
}
{
const std::vector<sh::Varying>* vertPtr = ShGetVaryings(prev->mHandle);
const std::vector<sh::Varying>* fragPtr = ShGetVaryings(mHandle);
if (!vertPtr || !fragPtr) {
nsPrintfCString error("Could not create varying list.");
*out_log = error;
return false;
}
nsTArray<ShVariableInfo> staticUseVaryingList;
for (auto itrFrag = fragPtr->begin(); itrFrag != fragPtr->end(); ++itrFrag) {
const ShVariableInfo varInfo = { itrFrag->type,
(int)itrFrag->elementCount() };
static const char prefix[] = "gl_";
if (StartsWith(itrFrag->name, prefix)) {
if (itrFrag->staticUse)
staticUseVaryingList.AppendElement(varInfo);
continue;
}
bool definedInVertShader = false;
bool staticVertUse = false;
for (auto itrVert = vertPtr->begin(); itrVert != vertPtr->end(); ++itrVert) {
if (itrVert->name != itrFrag->name)
continue;
if (!itrVert->isSameVaryingAtLinkTime(*itrFrag)) {
nsPrintfCString error("Varying `%s`is not linkable between"
" attached shaders.",
itrFrag->name.c_str());
*out_log = error;
return false;
}
definedInVertShader = true;
staticVertUse = itrVert->staticUse;
break;
}
if (!definedInVertShader && itrFrag->staticUse) {
nsPrintfCString error("Varying `%s` has static-use in the frag"
" shader, but is undeclared in the vert"
" shader.", itrFrag->name.c_str());
*out_log = error;
return false;
}
if (staticVertUse && itrFrag->staticUse)
staticUseVaryingList.AppendElement(varInfo);
}
if (!ShCheckVariablesWithinPackingLimits(mMaxVaryingVectors,
staticUseVaryingList.Elements(),
staticUseVaryingList.Length()))
{
*out_log = "Statically used varyings do not fit within packing limits. (see"
" GLSL ES Specification 1.0.17, p111)";
return false;
}
}
return true;
}
/******************************************************************************
* Renders the geometry as with extra information passed to the vertex shader.
******************************************************************************/
void OpenGLArrowPrimitive::renderWithElementInfo(ViewportSceneRenderer* renderer)
{
QOpenGLShaderProgram* shader = renderer->isPicking() ? _pickingShader : _shader;
if(!shader)
return;
if(!shader->bind())
throw Exception(QStringLiteral("Failed to bind OpenGL shader."));
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
shader->setUniformValue("modelview_matrix",
(QMatrix4x4)renderer->modelViewTM());
shader->setUniformValue("modelview_uniform_scale", (float)pow(std::abs(renderer->modelViewTM().determinant()), (FloatType(1.0/3.0))));
shader->setUniformValue("modelview_projection_matrix",
(QMatrix4x4)(renderer->projParams().projectionMatrix * renderer->modelViewTM()));
shader->setUniformValue("projection_matrix", (QMatrix4x4)renderer->projParams().projectionMatrix);
shader->setUniformValue("inverse_projection_matrix", (QMatrix4x4)renderer->projParams().inverseProjectionMatrix);
shader->setUniformValue("is_perspective", renderer->projParams().isPerspective);
AffineTransformation viewModelTM = renderer->modelViewTM().inverse();
Vector3 eye_pos = viewModelTM.translation();
shader->setUniformValue("eye_pos", eye_pos.x(), eye_pos.y(), eye_pos.z());
Vector3 viewDir = viewModelTM * Vector3(0,0,1);
shader->setUniformValue("parallel_view_dir", viewDir.x(), viewDir.y(), viewDir.z());
GLint viewportCoords[4];
glGetIntegerv(GL_VIEWPORT, viewportCoords);
shader->setUniformValue("viewport_origin", (float)viewportCoords[0], (float)viewportCoords[1]);
shader->setUniformValue("inverse_viewport_size", 2.0f / (float)viewportCoords[2], 2.0f / (float)viewportCoords[3]);
GLint pickingBaseID;
if(renderer->isPicking()) {
pickingBaseID = renderer->registerSubObjectIDs(elementCount());
renderer->activateVertexIDs(shader, _chunkSize * _verticesPerElement, true);
OVITO_CHECK_OPENGL(shader->setUniformValue("verticesPerElement", (GLint)_verticesPerElement));
}
for(int chunkIndex = 0; chunkIndex < _verticesWithElementInfo.size(); chunkIndex++, pickingBaseID += _chunkSize) {
int chunkStart = chunkIndex * _chunkSize;
int chunkSize = std::min(_elementCount - chunkStart, _chunkSize);
if(renderer->isPicking())
shader->setUniformValue("pickingBaseID", pickingBaseID);
_verticesWithElementInfo[chunkIndex].bindPositions(renderer, shader, offsetof(VertexWithElementInfo, pos));
_verticesWithElementInfo[chunkIndex].bind(renderer, shader, "cylinder_base", GL_FLOAT, offsetof(VertexWithElementInfo, base), 3, sizeof(VertexWithElementInfo));
_verticesWithElementInfo[chunkIndex].bind(renderer, shader, "cylinder_axis", GL_FLOAT, offsetof(VertexWithElementInfo, dir), 3, sizeof(VertexWithElementInfo));
_verticesWithElementInfo[chunkIndex].bind(renderer, shader, "cylinder_radius", GL_FLOAT, offsetof(VertexWithElementInfo, radius), 1, sizeof(VertexWithElementInfo));
if(!renderer->isPicking())
_verticesWithElementInfo[chunkIndex].bindColors(renderer, shader, 4, offsetof(VertexWithElementInfo, color));
if(_usingGeometryShader && (shadingMode() == FlatShading || renderingQuality() == HighQuality)) {
OVITO_CHECK_OPENGL(glDrawArrays(GL_POINTS, 0, chunkSize));
}
else {
int stripPrimitivesPerElement = _stripPrimitiveVertexCounts.size() / _chunkSize;
OVITO_CHECK_OPENGL(renderer->glMultiDrawArrays(GL_TRIANGLE_STRIP, _stripPrimitiveVertexStarts.data(), _stripPrimitiveVertexCounts.data(), stripPrimitivesPerElement * chunkSize));
int fanPrimitivesPerElement = _fanPrimitiveVertexCounts.size() / _chunkSize;
OVITO_CHECK_OPENGL(renderer->glMultiDrawArrays(GL_TRIANGLE_FAN, _fanPrimitiveVertexStarts.data(), _fanPrimitiveVertexCounts.data(), fanPrimitivesPerElement * chunkSize));
}
_verticesWithElementInfo[chunkIndex].detachPositions(renderer, shader);
_verticesWithElementInfo[chunkIndex].detach(renderer, shader, "cylinder_base");
_verticesWithElementInfo[chunkIndex].detach(renderer, shader, "cylinder_axis");
_verticesWithElementInfo[chunkIndex].detach(renderer, shader, "cylinder_radius");
if(!renderer->isPicking())
_verticesWithElementInfo[chunkIndex].detachColors(renderer, shader);
}
shader->enableAttributeArray("cylinder_base");
shader->enableAttributeArray("cylinder_axis");
shader->enableAttributeArray("cylinder_radius");
if(renderer->isPicking())
renderer->deactivateVertexIDs(shader, true);
shader->release();
}
TInt CSenLayeredXmlProperties::AllPropertiesByTypeL(const TDesC8& aType,
RPointerArray<MSenProperty>& aArray)
{
TInt retVal(KErrNotFound);
if ( ipChildProperties )
{
retVal = ipChildProperties->AllPropertiesByTypeL(aType, aArray);
}
CSenElement& element = ipFragment->AsElement();
RPointerArray<CSenElement>& elements = element.ElementsL();
TInt elementCount(elements.Count());
TInt propsCount(0);
TBool found(EFalse);
for (TInt i=0; i<elementCount; i++)
{
CSenElement* pElement = elements[i];
found = EFalse;
// Go through properties which are already added into returned array.
// => If property is already in the array
// it won't be added into array for the second time.
propsCount = aArray.Count();
for (TInt j=0; j<propsCount; j++)
{
MSenProperty* pProperty = aArray[j];
if ( pElement->LocalName() == pProperty->Name() )
{
found = ETrue;
break;
}
}
if ( !found )
{
const TDesC8* propertyType =
pElement->AttrValue(KSenTypeAttributeName);
if ( propertyType )
{
if ( *propertyType == aType )
{
#ifdef EKA2
CSenPropertiesElement* pPropElement
= (CSenPropertiesElement*)pElement;
aArray.AppendL(pPropElement);
#else
CSenPropertiesElement* pPropElement
= (CSenPropertiesElement*)pElement;
User::LeaveIfError(aArray.Append(pPropElement));
#endif
}
}
}
}
if ( aArray.Count() > 0 )
{
retVal=KErrNone;
}
return retVal;
}
