DOMElementType*
FormatterToXercesDOM::createElement(
const XalanDOMChar* theElementName,
AttributeListType& attrs)
{
DOMElementType* theElement = 0;
if (m_prefixResolver == 0)
{
theElement = m_doc->createElement(theElementName);
addAttributes(theElement, attrs);
}
else
{
// Check for the namespace...
const XalanDOMString* const theNamespace =
DOMServices::getNamespaceForPrefix(theElementName, *m_prefixResolver, false, m_buffer);
if (theNamespace == 0 || length(*theNamespace) == 0)
{
theElement = m_doc->createElement(theElementName);
}
else
{
theElement = m_doc->createElementNS(theNamespace->c_str(), theElementName);
}
addAttributes(theElement, attrs);
}
return theElement;
}
// Returns NULL to indicate error
Element* newElement(Elm type, int size, const char** attr) {
Element* e = (Element*)calloc(1, size);
if (!checkPointer(e)) return NULL;
e->type = type;
e->attributes = NULL;
e->n=0;
if (!addAttributes(e, attr)) return NULL;
return e;
}
MyClass() {
QString xres("{ 'var' : 'xres', 'name' : 'Image Width', 'type' : 'int', 'min' : 1, 'max' : 4096, 'value' : 1024 }");
QString yres("{ 'var' : 'yres', 'name' : 'Image Height', 'type' : 'int', 'min' : 1, 'max' : 4096, 'value' : 768 }");
QString samplingWidth("{ 'var' : 'samplingWidth', 'name' : 'Sampling Width', 'type' : 'float', 'min' : 1, 'max' : 8, 'value' : 3 }");
QString exposure("{ 'var' : 'exposure', 'name' : 'Exposure', 'type' : 'float', 'min' : 0.001, 'max' : 1000, 'value' : 1.0 }");
QStringList atts;
atts << xres << yres << samplingWidth << exposure;
addAttributes(atts);
}
///////////////////////////////////////////////////////////////////////////////
/// Add an new element.
///
///\param type Type of the element.
///\param size Size of the element.
///\param attr Attributes of the element.
///\return The point of the element if ther is no error occurred.
/// Otherwise, return NULL to indicate an error.
///////////////////////////////////////////////////////////////////////////////
Element* newElement(Elm type, int size, const char** attr) {
Element* e = (Element*)calloc(1, size);
printfIntDebug("Allocated 1 element with %d bytes of memory in newElement()\n", size);
if (checkPointer(e)) return NULL;
e->type = type;
e->attributes = NULL;
e->n=0;
printDebug("Start to add new elmement to attr");
if (addAttributes(e, attr)) return NULL;
printDebug("Added new elmement to attr");
return e;
}
AmbientLight::AmbientLight()
{
QString color("{ 'var' : 'lightColor', 'name' : 'Color', 'type' : 'color', 'value' : '#eeeeff', 'glslFragmentConstant' : true }");
QString intensity("{ 'var' : 'lightIntensity', 'name' : 'Intensity', 'type' : 'float', 'min' : 0.0, 'max' : 1.0, 'value' : 0.2, 'glslFragmentConstant' : true }");
QStringList atts;
atts << color << intensity;
addAttributes(atts);
Attribute position = attributeByName("Position");
removeAttribute(position);
//QString glslFragmentBegin();
//QString glslFragmentEnd();
}
PointLight::PointLight()
{
QString color("{ 'var' : 'lightColor', 'name' : 'Color', 'type' : 'color', 'value' : '#ffffff', 'glslFragmentConstant' : true }");
QString intensity("{ 'var' : 'uniformLightIntensity', 'name' : 'Intensity', 'type' : 'float', 'min' : 0.0, 'max' : 1.0, 'value' : 1.0, 'glslFragmentConstant' : true }");
QString castShadows("{ 'var' : 'castShadows', 'name' : 'Casts Shadows', 'type' : 'bool', 'value' : true }");
QStringList atts;
atts << color << intensity << castShadows;
addAttributes(atts);
Attribute position = attributeByName("Position");
position->setProperty("glslFragmentConstant", "lightPos");
//renameAttributeVar("position", "lightPos");
}
SpotLight::SpotLight()
{
QString color("{ 'var' : 'lightColor', 'name' : 'Color', 'type' : 'color', 'value' : '#ffffff', 'glslFragmentConstant' : true }");
QString intensity("{ 'var' : 'uniformLightIntensity', 'name' : 'Intensity', 'type' : 'float', 'min' : 0.0, 'max' : 1000.0, 'value' : 10.0, 'glslFragmentConstant' : true }");
QString coneAngle("{ 'var' : 'coneAngle', 'name' : 'Cone Angle', 'type' : 'float', 'min' : 1.0, 'max' : 150.0, 'value' : 60.0, 'glslFragmentConstant' : true }");
QString castShadows("{ 'var' : 'castShadows', 'name' : 'Casts Shadows', 'type' : 'bool', 'value' : true }");
//QString shadowBias("{ 'var' : 'shadowBias', 'name' : 'Shadow Bias', 'type' : 'float', 'min' : -100.0, 'max' : 100.0, 'value' : 0.1 }");
//QString spotDir("{ 'var' : 'spotDir', 'name' : 'Spot Direction', 'type' : 'vector3', 'getter' : 'spotDir', 'glslFragmentConstant' : true }");
QString shadowResolution("{ 'var' : 'shadowResolution', 'name' : 'Shadow Resolution', 'type' : 'int', 'min' : 32, 'max' : 4096, 'value' : 1024 }");
QStringList atts;
atts << color << intensity << coneAngle << castShadows << shadowResolution;// << shadowBias;// << spotDir;
addAttributes(atts);
Attribute position = attributeByName("Position");
position->setProperty("glslFragmentConstant", "lightPos");
}
void XMLWriter::writeStartElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const Attributes& attributes)
{
if (!_nsContextPushed)
_namespaces.pushContext();
_nsContextPushed = false;
++_elementCount;
writeMarkup(MARKUP_LT);
if (!localName.empty() && (qname.empty() || localName == qname))
{
XMLString prefix;
if (!namespaceURI.empty() && !_namespaces.isMapped(namespaceURI))
{
prefix = newPrefix();
_namespaces.declarePrefix(prefix, namespaceURI);
}
else prefix = _namespaces.getPrefix(namespaceURI);
writeName(prefix, localName);
}
else if (namespaceURI.empty() && localName.empty() && !qname.empty())
{
writeXML(qname);
}
else if (!localName.empty() && !qname.empty())
{
XMLString local;
XMLString prefix;
Name::split(qname, prefix, local);
if (prefix.empty()) prefix = _namespaces.getPrefix(namespaceURI);
const XMLString& uri = _namespaces.getURI(prefix);
if ((uri.empty() || uri != namespaceURI) && !namespaceURI.empty())
{
_namespaces.declarePrefix(prefix, namespaceURI);
}
writeName(prefix, localName);
}
else throw XMLException("Tag mismatch", nameToString(localName, qname));
declareAttributeNamespaces(attributes);
AttributeMap attributeMap;
addNamespaceAttributes(attributeMap);
addAttributes(attributeMap, attributes, namespaceURI);
writeAttributes(attributeMap);
_unclosedStartTag = true;
}
bool QgsVectorDataProvider::addAttributes( const QMap<QString, QString> &attributes )
{
const QList< NativeType > &types = nativeTypes();
QList< QgsField > list;
for ( QMap<QString, QString>::const_iterator it = attributes.constBegin(); it != attributes.constEnd(); it++ )
{
int i;
for ( i = 0; i < types.size() && types[i].mTypeName != it.value(); i++ )
;
if ( i == types.size() )
return false;
list << QgsField( it.key(), types[i].mType, it.value() );
}
return addAttributes( list );
}
void QgsGrassEdit::addCat( int line )
{
int mode = mCatModeBox->currentIndex();
int field = mFieldBox->currentText().toInt();
int cat = mCatEntry->text().toInt();
int type = mProvider->readLine( mPoints, mCats, line );
if ( mode == CAT_MODE_NEXT || mode == CAT_MODE_MANUAL )
{
Vect_cat_set( mCats, field, cat );
}
line = mProvider->rewriteLine( line, type, mPoints, mCats );
mSelectedLine = line;
if ( mAttributes )
mAttributes->setLine( line );
updateSymb();
increaseMaxCat();
// Insert new DB record if link is defined and the record for this cat does not exist
QString *key = mProvider->key( field );
if ( !key->isEmpty() ) // Database link defined
{
QgsAttributeMap *atts = mProvider->attributes( field, cat );
if ( atts->size() == 0 ) // Nothing selected
{
QString *error = mProvider->insertAttributes( field, cat );
if ( !error->isEmpty() )
{
QMessageBox::warning( 0, tr( "Warning" ), *error );
}
delete error;
}
delete atts;
}
addAttributes( field, cat );
}
AttributeWidget::AttributeWidget(TreeItem *item) : QWidget(), ui(new Ui::AttributeWidget)
{
itemEditing = item;
m_attributes = item->getAttributes();
setAttribute(Qt::WA_DeleteOnClose);
ui->setupUi(this);
ui->twAttributes->horizontalHeader()->setResizeMode(1, QHeaderView::Stretch);
connect(ui->pbAdd, SIGNAL(clicked()), this, SLOT(addAttributes()));
connect(ui->pbRemove, SIGNAL(clicked()), this, SLOT(removeAttributes()));
connect(ui->pbSave, SIGNAL(clicked()), this, SLOT(saveData()));
connect(ui->twAttributes, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(modifyTable(QModelIndex)));
setWindowTitle("Attributes of node: " + itemEditing->getName());
addAction(ui->actionClose);
if (m_attributes.size() > 0)
fillAttTable();
}
void IndexEntry::saveOdf(KoXmlWriter* writer) const
{
switch (name) {
case LINK_START:
writer->startElement("text:index-entry-link-start");
break;
case CHAPTER:
writer->startElement("text:index-entry-chapter");
break;
case BIBLIOGRAPHY:
writer->startElement("text:index-entry-bibliography");
break;
case SPAN:
writer->startElement("text:index-entry-span");
break;
case TEXT:
writer->startElement("text:index-entry-text");
break;
case TAB_STOP:
writer->startElement("text:index-entry-tab-stop");
break;
case PAGE_NUMBER:
writer->startElement("text:index-entry-page-number");
break;
case LINK_END:
writer->startElement("text:index-entry-link-end");
break;
case UNKNOWN:
break;
}
if (!styleName.isNull()) {
writer->addAttribute("text:style-name", styleName);
}
addAttributes(writer);
writer->endElement();
}
QgsMemoryProvider::QgsMemoryProvider( QString uri )
: QgsVectorDataProvider( uri )
, mSpatialIndex( 0 )
{
// Initialize the geometry with the uri to support old style uri's
// (ie, just 'point', 'line', 'polygon')
QUrl url = QUrl::fromEncoded( uri.toUtf8() );
QString geometry;
if ( url.hasQueryItem( "geometry" ) )
{
geometry = url.queryItemValue( "geometry" );
}
else
{
geometry = url.path();
}
geometry = geometry.toLower();
if ( geometry == "point" )
mWkbType = QGis::WKBPoint;
else if ( geometry == "linestring" )
mWkbType = QGis::WKBLineString;
else if ( geometry == "polygon" )
mWkbType = QGis::WKBPolygon;
else if ( geometry == "multipoint" )
mWkbType = QGis::WKBMultiPoint;
else if ( geometry == "multilinestring" )
mWkbType = QGis::WKBMultiLineString;
else if ( geometry == "multipolygon" )
mWkbType = QGis::WKBMultiPolygon;
else
mWkbType = QGis::WKBUnknown;
if ( url.hasQueryItem( "crs" ) )
{
QString crsDef = url.queryItemValue( "crs" );
mCrs.createFromString( crsDef );
}
mNextFeatureId = 1;
mNativeTypes
<< QgsVectorDataProvider::NativeType( tr( "Whole number (integer)" ), "integer", QVariant::Int, 0, 10 )
// Decimal number from OGR/Shapefile/dbf may come with length up to 32 and
// precision up to length-2 = 30 (default, if width is not specified in dbf is length = 24 precision = 15)
// We know that double (QVariant::Double) has only 15-16 significant numbers,
// but setting that correct limits would disable the use of memory provider with
// data from Shapefiles. In any case, the data are handled as doubles.
// So the limits set here are not correct but enable use of data from Shapefiles.
<< QgsVectorDataProvider::NativeType( tr( "Decimal number (real)" ), "double", QVariant::Double, 0, 32, 0, 30 )
<< QgsVectorDataProvider::NativeType( tr( "Text (string)" ), "string", QVariant::String, 0, 255 )
// date type
<< QgsVectorDataProvider::NativeType( tr( "Date" ), "date", QVariant::Date, -1, -1, -1, -1 )
// integer types
<< QgsVectorDataProvider::NativeType( tr( "Whole number (smallint - 16bit)" ), "int2", QVariant::Int, -1, -1, 0, 0 )
<< QgsVectorDataProvider::NativeType( tr( "Whole number (integer - 32bit)" ), "int4", QVariant::Int, -1, -1, 0, 0 )
<< QgsVectorDataProvider::NativeType( tr( "Whole number (integer - 64bit)" ), "int8", QVariant::LongLong, -1, -1, 0, 0 )
<< QgsVectorDataProvider::NativeType( tr( "Decimal number (numeric)" ), "numeric", QVariant::Double, 1, 20, 0, 20 )
<< QgsVectorDataProvider::NativeType( tr( "Decimal number (decimal)" ), "decimal", QVariant::Double, 1, 20, 0, 20 )
// floating point
<< QgsVectorDataProvider::NativeType( tr( "Decimal number (real)" ), "real", QVariant::Double, -1, -1, -1, -1 )
<< QgsVectorDataProvider::NativeType( tr( "Decimal number (double)" ), "double precision", QVariant::Double, -1, -1, -1, -1 )
// string types
<< QgsVectorDataProvider::NativeType( tr( "Text, unlimited length (text)" ), "text", QVariant::String, -1, -1, -1, -1 )
;
if ( url.hasQueryItem( "field" ) )
{
QList<QgsField> attributes;
QRegExp reFieldDef( "\\:"
"(int|integer|real|double|string|date)" // type
"(?:\\((\\d+)" // length
"(?:\\,(\\d+))?" // precision
"\\))?"
"$", Qt::CaseInsensitive );
QStringList fields = url.allQueryItemValues( "field" );
for ( int i = 0; i < fields.size(); i++ )
{
QString name = fields.at( i );
QVariant::Type type = QVariant::String;
QString typeName( "string" );
int length = 255;
int precision = 0;
int pos = reFieldDef.indexIn( name );
if ( pos >= 0 )
{
name = name.mid( 0, pos );
typeName = reFieldDef.cap( 1 ).toLower();
if ( typeName == "int" || typeName == "integer" )
{
type = QVariant::Int;
typeName = "integer";
length = 10;
}
else if ( typeName == "real" || typeName == "double" )
{
type = QVariant::Double;
typeName = "double";
length = 20;
precision = 5;
}
else if ( typeName == "date" )
{
type = QVariant::Date;
typeName = "date";
length = 10;
}
if ( reFieldDef.cap( 2 ) != "" )
{
length = reFieldDef.cap( 2 ).toInt();
}
if ( reFieldDef.cap( 3 ) != "" )
{
precision = reFieldDef.cap( 3 ).toInt();
}
}
if ( name != "" )
attributes.append( QgsField( name, type, typeName, length, precision ) );
}
addAttributes( attributes );
}
if ( url.hasQueryItem( "index" ) && url.queryItemValue( "index" ) == "yes" )
{
createSpatialIndex();
}
}
QgsMemoryProvider::QgsMemoryProvider( const QString &uri, const ProviderOptions &options )
: QgsVectorDataProvider( uri, options )
{
// Initialize the geometry with the uri to support old style uri's
// (ie, just 'point', 'line', 'polygon')
QUrl url = QUrl::fromEncoded( uri.toUtf8() );
QString geometry;
if ( url.hasQueryItem( QStringLiteral( "geometry" ) ) )
{
geometry = url.queryItemValue( QStringLiteral( "geometry" ) );
}
else
{
geometry = url.path();
}
if ( geometry.toLower() == QLatin1String( "none" ) )
{
mWkbType = QgsWkbTypes::NoGeometry;
}
else
{
mWkbType = QgsWkbTypes::parseType( geometry );
}
if ( url.hasQueryItem( QStringLiteral( "crs" ) ) )
{
QString crsDef = url.queryItemValue( QStringLiteral( "crs" ) );
mCrs.createFromString( crsDef );
}
mNextFeatureId = 1;
setNativeTypes( QList< NativeType >()
<< QgsVectorDataProvider::NativeType( tr( "Whole number (integer)" ), QStringLiteral( "integer" ), QVariant::Int, 0, 10 )
// Decimal number from OGR/Shapefile/dbf may come with length up to 32 and
// precision up to length-2 = 30 (default, if width is not specified in dbf is length = 24 precision = 15)
// We know that double (QVariant::Double) has only 15-16 significant numbers,
// but setting that correct limits would disable the use of memory provider with
// data from Shapefiles. In any case, the data are handled as doubles.
// So the limits set here are not correct but enable use of data from Shapefiles.
<< QgsVectorDataProvider::NativeType( tr( "Decimal number (real)" ), QStringLiteral( "double" ), QVariant::Double, 0, 32, 0, 30 )
<< QgsVectorDataProvider::NativeType( tr( "Text (string)" ), QStringLiteral( "string" ), QVariant::String, 0, 255 )
// date type
<< QgsVectorDataProvider::NativeType( tr( "Date" ), QStringLiteral( "date" ), QVariant::Date, -1, -1, -1, -1 )
<< QgsVectorDataProvider::NativeType( tr( "Time" ), QStringLiteral( "time" ), QVariant::Time, -1, -1, -1, -1 )
<< QgsVectorDataProvider::NativeType( tr( "Date & Time" ), QStringLiteral( "datetime" ), QVariant::DateTime, -1, -1, -1, -1 )
// integer types
<< QgsVectorDataProvider::NativeType( tr( "Whole number (smallint - 16bit)" ), QStringLiteral( "int2" ), QVariant::Int, -1, -1, 0, 0 )
<< QgsVectorDataProvider::NativeType( tr( "Whole number (integer - 32bit)" ), QStringLiteral( "int4" ), QVariant::Int, -1, -1, 0, 0 )
<< QgsVectorDataProvider::NativeType( tr( "Whole number (integer - 64bit)" ), QStringLiteral( "int8" ), QVariant::LongLong, -1, -1, 0, 0 )
<< QgsVectorDataProvider::NativeType( tr( "Decimal number (numeric)" ), QStringLiteral( "numeric" ), QVariant::Double, 1, 20, 0, 20 )
<< QgsVectorDataProvider::NativeType( tr( "Decimal number (decimal)" ), QStringLiteral( "decimal" ), QVariant::Double, 1, 20, 0, 20 )
// floating point
<< QgsVectorDataProvider::NativeType( tr( "Decimal number (real)" ), QStringLiteral( "real" ), QVariant::Double, -1, -1, -1, -1 )
<< QgsVectorDataProvider::NativeType( tr( "Decimal number (double)" ), QStringLiteral( "double precision" ), QVariant::Double, -1, -1, -1, -1 )
// string types
<< QgsVectorDataProvider::NativeType( tr( "Text, unlimited length (text)" ), QStringLiteral( "text" ), QVariant::String, -1, -1, -1, -1 )
);
if ( url.hasQueryItem( QStringLiteral( "field" ) ) )
{
QList<QgsField> attributes;
QRegExp reFieldDef( "\\:"
"(int|integer|long|int8|real|double|string|date|time|datetime)" // type
"(?:\\((\\-?\\d+)" // length
"(?:\\,(\\d+))?" // precision
"\\))?(\\[\\])?" // array
"$", Qt::CaseInsensitive );
QStringList fields = url.allQueryItemValues( QStringLiteral( "field" ) );
for ( int i = 0; i < fields.size(); i++ )
{
QString name = QUrl::fromPercentEncoding( fields.at( i ).toUtf8() );
QVariant::Type type = QVariant::String;
QVariant::Type subType = QVariant::Invalid;
QString typeName( QStringLiteral( "string" ) );
int length = 255;
int precision = 0;
int pos = reFieldDef.indexIn( name );
if ( pos >= 0 )
{
name = name.mid( 0, pos );
typeName = reFieldDef.cap( 1 ).toLower();
if ( typeName == QLatin1String( "int" ) || typeName == QLatin1String( "integer" ) )
{
type = QVariant::Int;
typeName = QStringLiteral( "integer" );
length = -1;
}
else if ( typeName == QLatin1String( "int8" ) || typeName == QLatin1String( "long" ) )
{
type = QVariant::LongLong;
typeName = QStringLiteral( "int8" );
length = -1;
}
else if ( typeName == QLatin1String( "real" ) || typeName == QLatin1String( "double" ) )
{
type = QVariant::Double;
typeName = QStringLiteral( "double" );
length = 20;
precision = 5;
}
else if ( typeName == QLatin1String( "date" ) )
{
type = QVariant::Date;
typeName = QStringLiteral( "date" );
length = -1;
}
else if ( typeName == QLatin1String( "time" ) )
{
type = QVariant::Time;
typeName = QStringLiteral( "time" );
length = -1;
}
else if ( typeName == QLatin1String( "datetime" ) )
{
type = QVariant::DateTime;
typeName = QStringLiteral( "datetime" );
length = -1;
}
if ( !reFieldDef.cap( 2 ).isEmpty() )
{
length = reFieldDef.cap( 2 ).toInt();
}
if ( !reFieldDef.cap( 3 ).isEmpty() )
{
precision = reFieldDef.cap( 3 ).toInt();
}
if ( !reFieldDef.cap( 4 ).isEmpty() )
{
//array
subType = type;
type = ( subType == QVariant::String ? QVariant::StringList : QVariant::List );
}
}
if ( !name.isEmpty() )
attributes.append( QgsField( name, type, typeName, length, precision, QLatin1String( "" ), subType ) );
}
addAttributes( attributes );
}
if ( url.hasQueryItem( QStringLiteral( "index" ) ) && url.queryItemValue( QStringLiteral( "index" ) ) == QLatin1String( "yes" ) )
{
createSpatialIndex();
}
}
void ossimXmlNode::setAttributes(ossimXmlNode::AttributeListType& children)
{
clearAttributes();
addAttributes(children);
}
PrimaryRecord::PrimaryRecord(const char * const * names)
: Record(primaryAttributes)
{
addAttributes(names);
}
DLCommonFields::DLCommonFields(const char * const * names)
: Record(commonAttributes)
{
addAttributes(names);
}
