bool SelectionBase::ExpressionPart::match(const SPFeatureI &feature,SelectionBase *operation) const
{
if ( _type == ExpressionPart::ptFEATURETYPE){
return hasType(feature->geometryType(), _geometryType);
}
if ( _type == ExpressionPart::ptENVELOPE && _envelope.isValid()) {
return _envelope.contains(feature->geometry().get());
}
if ( _type == ExpressionPart::ptPOLYGON && _polygon.get() != 0) {
return _polygon->contains(feature->geometry().get());
}
if ( _type == ExpressionPart::ptATTRIBUTESELECTION ) {
QVariant val = feature(_leftSide);
ColumnDefinition coldef = feature->attributedefinition(_leftSide);
if ( coldef.datadef().domain()->ilwisType() == itITEMDOMAIN){
val = coldef.datadef().domain()->impliedValue(val);
}
if ( QString(val.typeName()) == "QString" && QString(_rightSide.typeName()) == "QString"){
return operation->compare1(_operator,val.toString(), _rightSide.toString());
} else {
bool ok1,ok2;
double v1 = val.toDouble(&ok1);
double v2 = _rightSide.toDouble(&ok2);
bool ok3 = operation->compare2(_operator, v1, v2, true);
return ok1&& ok2 && ok3;
}
}
return false;
}
Qt::ItemFlags TableModel::flags(const QModelIndex &index) const
{
Qt::ItemFlags flags = QAbstractTableModel::flags(index);
if(index.isValid()) {
bool can_edit = false;
ColumnDefinition cd = m_columns.value(index.column());
if(!cd.isNull()) {
can_edit = !cd.isReadOnly();
if(!cd.isVirtual()) {
qfu::Table::Field field = tableField(index.column());
if(!field.isNull()) {
can_edit = can_edit && field.canUpdate();
int type = columnType(index.column());
// BLOB fields cannot be edited in grid.
//can_edit = can_edit && (type != QVariant::ByteArray);
if(type == QVariant::Bool) {
flags |= Qt::ItemIsUserCheckable;// << Qt::ItemIsEnabled;
}
}
else {
can_edit = false;
}
}
}
if(can_edit)
flags |= Qt::ItemIsEditable;
else
flags &= ~Qt::ItemIsEditable;
//qfInfo() << cd.fieldName() << flags << "checkable:" << (flags & Qt::ItemIsUserCheckable);
}
return flags;
}
QString IlwisObjectModel::valuetype() const
{
try{
if ( !_ilwisobject.isValid())
return "";
IlwisTypes objectype = _ilwisobject->ilwisType();
IlwisTypes valueType = itUNKNOWN;
if ( hasType( objectype, itCOVERAGE|itDOMAIN)){
if ( objectype == itRASTER){
IRasterCoverage raster = _ilwisobject.as<RasterCoverage>();
valueType = raster->datadef().domain()->valueType();
} else if ( hasType( objectype , itFEATURE)){
IFeatureCoverage features = _ilwisobject.as<FeatureCoverage>();
ColumnDefinition coldef = features->attributeDefinitions().columndefinition(COVERAGEKEYCOLUMN);
if ( coldef.isValid()){
valueType = coldef.datadef().domain()->valueType();
}
} else if ( hasType( objectype , itDOMAIN)){
IDomain dom = _ilwisobject.as<Domain>();
valueType = dom->valueType();
}
}
QString typeName = TypeHelper::type2HumanReadable(valueType);
return typeName == sUNDEF ? "" : typeName;
}catch(const ErrorObject& ){
// no exceptions may escape here
}
return "";
}
bool Ilwis::Postgresql::PostgresqlDatabaseUtil::exists(Ilwis::SPFeatureI feature) const
{
PostgresqlDatabaseUtil pgUtil(_resource,_options);
SqlStatementHelper sqlHelper(pgUtil);
QString where;
QList<QString> primaryKeys;
getPrimaryKeys(primaryKeys);
Record record = feature->record();
foreach (QString primaryKey, primaryKeys) {
if (where.isEmpty()) {
where.append(" WHERE ");
} else {
where.append(" AND ");
}
ColumnDefinition coldef = feature->attributedefinition(primaryKey);
QVariant value = record.cell(coldef.columnindex());
where.append(primaryKey).append(" = ");
where.append(sqlHelper.createInsertValueString(value, coldef));
}
QString sql = "SELECT ";
//sql.append(" count(").append(primaryKeys.at(0)).append(") ");
sql.append(QStringList(primaryKeys).join(","));
sql.append(" FROM ").append(qTableFromTableResource());
sql.append(where);
QSqlQuery query = doQuery(sql, "exists");
return query.next();
}
ColumnDefinition::ColumnDefinition(const ColumnDefinition& coldef){
if(coldef.__bool__())
{
Ilwis::ColumnDefinition* ilwDef = coldef.ptr().get();
if(ilwDef->isValid())
_ilwisColDef.reset(new Ilwis::ColumnDefinition(*ilwDef));
}
}
Qt::ItemFlags RunsTableModel::flags(const QModelIndex &index) const
{
Qt::ItemFlags flgs = Super::flags(index);
ColumnDefinition cd = columnDefinition(index.column());
if(cd.matchesSqlId(QStringLiteral("startTimeMs"))) {
flgs = Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | flgs;
//qfInfo() << flgs;
}
return flgs;
}
void
Grid::PostRender (Context *ctx, Region *region, bool skip_children)
{
// render our chidren if we need to
if (!skip_children) {
VisualTreeWalker walker = VisualTreeWalker (this, ZForward, false);
while (UIElement *child = walker.Step ())
child->DoRender (ctx, region);
}
if (GetShowGridLines () && ctx->IsMutable ()) {
double offset = 0;
double dash = 4;
ColumnDefinitionCollection *cols = GetColumnDefinitionsNoAutoCreate ();
RowDefinitionCollection *rows = GetRowDefinitionsNoAutoCreate ();
cairo_t *cr = ctx->Cairo ();
int col_count = cols ? cols->GetCount () : 0;
int row_count = rows ? rows->GetCount () : 0;
cairo_save (cr);
RenderLayoutClip (cr);
cairo_set_line_width(cr, 1.0);
// Initially render a blue color
cairo_set_dash (cr, &dash, 1, offset);
cairo_set_source_rgb (cr, 0.4, 0.4, 1.0);
cairo_new_path (cr);
// Draw gridlines between each pair of columns/rows
for (int count = 0; count < 2; count++) {
for (int i = 0, offset = 0; i < col_count - 1; i++) {
ColumnDefinition *def = cols->GetValueAt (i)->AsColumnDefinition ();
offset += def->GetActualWidth ();
cairo_move_to (cr, offset, 0);
cairo_line_to (cr, offset, GetActualHeight ());
}
for (int i = 0, offset = 0; i < row_count - 1; i++) {
RowDefinition *def = rows->GetValueAt (i)->AsRowDefinition ();
offset += def->GetActualHeight ();
cairo_move_to (cr, 0, offset);
cairo_line_to (cr, GetActualWidth (), offset);
}
cairo_stroke (cr);
// For the second pass render a yellow color in the gaps between the previous dashes
cairo_set_dash (cr, &dash, 1, dash);
cairo_set_source_rgb (cr, 1.0, 1.0, 0.3);
}
cairo_restore (cr);
}
// Chain up, but skip children since we've already rendered them here.
UIElement::PostRender (ctx, region, true);
}
bool BaseTable::addColumn(const ColumnDefinition& def){
if ( _columnDefinitionsByName.contains(def.name())) {
kernel()->issues()->log(TR("Adding duplicate column %1").arg(name()),IssueObject::itWarning);
return false;
}
_columnDefinitionsByName[def.name()] = def;
_columnDefinitionsByIndex[def.id()] = _columnDefinitionsByName[def.name()];
_columns = _columnDefinitionsByName.size();
return true;
}
void SqlTableModel::removeAllColumnsFunction(QQmlListProperty<TableModelColumn> *list_property)
{
qfLogFuncFrame();
SqlTableModel *that = static_cast<SqlTableModel*>(list_property->object);
while (that->columnCount()) {
ColumnDefinition cd = that->removeColumn(0);
QF_ASSERT(cd.isNull(), "Error removing column", break);
}
qDeleteAll(that->m_columns);
that->m_columns.clear();
}
bool AttributeDefinition::addColumn(const ColumnDefinition& def){
if ( _columnDefinitionsByName.find(def.name()) != _columnDefinitionsByName.end()) { // no duplicates
return false;
}
ColumnDefinition coldef = def;
coldef.columnindex(_columnDefinitionsByIndex.size());
_columnDefinitionsByName[coldef.name()] = _columnDefinitionsByIndex.size();
_columnDefinitionsByIndex.push_back(coldef);
return true;
}
QString IlwisObjectModel::rangeDefinition(bool defaultRange, bool calc, const QString& columnName) {
try {
IlwisTypes objectype = _ilwisobject->ilwisType();
QString rangeString;
if ( hasType( objectype, itCOVERAGE|itDOMAIN)){
if ( objectype == itRASTER){
IRasterCoverage raster = _ilwisobject.as<RasterCoverage>();
if ( defaultRange){
rangeString = raster->datadef().domain()->range()->toString();
}else{
if ( calc){
raster->loadData();
raster->statistics(NumericStatistics::pBASIC);
}
rangeString = raster->datadef().range()->toString();
}
} else if ( hasType( objectype , itFEATURE)){
IFeatureCoverage features = _ilwisobject.as<FeatureCoverage>();
ColumnDefinition coldef = features->attributeDefinitions().columndefinition(COVERAGEKEYCOLUMN);
if ( coldef.isValid()){
if ( defaultRange)
rangeString = coldef.datadef().domain()->range()->toString();
else{
if ( calc){
features->loadData();
std::vector<QVariant> data = features->attributeTable()->column(columnName);
if ( data.size() != 0){
std::vector<double> values(data.size());
int i=0;
for(auto v : data)
values[i++] = v.toDouble();
NumericStatistics stats; // realy like to do this with a template specialization of the proper calculate function, but the syntax was unclear to me
stats.calculate(values.begin(), values.end());
NumericRange *rng = new NumericRange(stats.prop(NumericStatistics::pMIN),stats.prop(NumericStatistics::pMAX));
features->attributeDefinitionsRef().columndefinitionRef(columnName).datadef().range(rng);
}
}
rangeString = coldef.datadef().range()->toString();
}
}
} else if ( hasType( objectype , itDOMAIN)){
rangeString = _ilwisobject.as<Domain>()->range()->toString();
}
}
return rangeString;
}catch(const ErrorObject& ){
// no exceptions may escape here
}
return "";
}
void CreateTableSqlStatementBuilder::addColumnDefinition(const Utf8String &columnName,
ColumnType columnType,
bool isPrimaryKey)
{
sqlStatementBuilder.clear();
ColumnDefinition columnDefinition;
columnDefinition.setName(columnName);
columnDefinition.setType(columnType);
columnDefinition.setIsPrimaryKey(isPrimaryKey);
columnDefinitions.append(columnDefinition);
}
QVariant TableModel::headerData(int section, Qt::Orientation orientation, int role) const
{
static QIcon ico_dirty(QPixmap(":/qf/core/images/pencil.png"));
//static QIcon ico_filter(QPixmap(":/libqfgui/images/filter.png"));
QVariant ret;
if(orientation == Qt::Horizontal) {
if(role == Qt::DisplayRole || role == Qt::EditRole) {
ColumnDefinition cd = m_columns.value(section);
QF_ASSERT(!cd.isNull(),
QString("Invalid horizontal section number: %1").arg(section),
return ret);
ret = cd.caption();
}
else if(role == Qt::DecorationRole) {
UINT TableDefinition::adjustOffset(ColumnDefinition &colDef) {
colDef.m_offset = m_recSize;
ULONG fieldSize = colDef.size();
switch(colDef.getType()) {
case DBTYPE_VARCHAR :
case DBTYPE_VARCHARN:
break;
default:
colDef.m_len = fieldSize;
break;
}
if(isNullAllowed(colDef.getType())) {
fieldSize++; /* make space for the indicator */
}
return fieldSize;
}
QString PostgresqlTableConnector::createInsertValueString(QVariant value, const ColumnDefinition &coldef) const {
IDomain domain = coldef.datadef().domain<>();
if (hasType(domain->valueType(),itINTEGER)) {
return QString::number(value.toInt());
} else if (hasType(domain->valueType(),itDOUBLE | itFLOAT)) {
return QString::number(value.toDouble());
} else if (hasType(domain->valueType(),itTHEMATICITEM | itNAMEDITEM | itINDEXEDITEM | itNUMERICITEM | itTIMEITEM)) {
return domain->impliedValue(value).toString();
} else if (hasType(domain->valueType(), itDATETIME)) {
if ( QString(value.typeName()).compare("Ilwis::Time") != 0){
ERROR2(ERR_COULD_NOT_CONVERT_2,value.toString(), "time");
Time time(0,0,0,0,0);
return time.toString(itDATE);
} else{
Time time = value.value<Ilwis::Time>();
return time.toString(itDATETIME);
}
} else if (hasType(domain->valueType(),itSTRING)){
return QString("'%1'").arg(value.toString());
} else {
ERROR0("Could not determine data type.");
return QString("");
}
}
Ilwis::OperationImplementation::State SetAttributeTable::prepare(ExecutionContext *ctx, const SymbolTable &st)
{
OperationImplementation::prepare(ctx,st);
OperationHelper::check([&] ()->bool { return _inputTable.prepare(_expression.input<QString>(0), itTABLE); },
{ERR_COULD_NOT_LOAD_2,_expression.input<QString>(0), "" } );
OperationHelper::check([&] ()->bool { return _inputRaster.prepare(_expression.input<QString>(1), itRASTER); },
{ERR_COULD_NOT_LOAD_2,_expression.input<QString>(1), "" } );
_primaryKey = _expression.input<QString>(2);
int index = _inputTable->columnIndex(_primaryKey);
if ( index == iUNDEF){
kernel()->issues()->log(TR("Table doesnt contain column ") + _primaryKey);
return sPREPAREFAILED;
}
std::vector<QVariant> values = _inputTable->column(_primaryKey);
std::set<QVariant> uniques;
int undefs = 0;
for(QVariant v : values){
if ( isNumericalUndef(v.toDouble()))
++undefs;
else
uniques.insert(v);
}
if ( (uniques.size() + undefs ) != values.size()){
kernel()->issues()->log(TR("Key column must not contain duplicate values"));
return sPREPAREFAILED;
}
ColumnDefinition coldef = _inputTable->columndefinition(index);
if ( !coldef.datadef().domain()->isCompatibleWith(_inputRaster->datadef().domain().ptr())){
kernel()->issues()->log(TR("Key column doesnt match raster domain ") + _primaryKey);
return sPREPAREFAILED;
}
OperationHelperRaster helper;
helper.initialize(_inputRaster, _outputRaster, itRASTERSIZE | itENVELOPE | itCOORDSYSTEM | itGEOREF|itDOMAIN);
for(quint32 i = 0; i < _outputRaster->size().zsize(); ++i){
QString index = _outputRaster->stackDefinition().index(i);
DataDefinition datadef = _outputRaster->datadef(i);
_outputRaster->setBandDefinition(index,DataDefinition(datadef.domain(), datadef.range()->clone()));
}
return sPREPARED;
}
QVariant SqlTableModel::data(const QModelIndex &index, int role) const
{
if(role == Qt::DisplayRole) {
ColumnDefinition cd = columnDefinition(index.column());
int cast_type = cd.castType();
if(cast_type == qMetaTypeId<qf::core::sql::DbEnum>()) {
DbEnumCastProperties props(cd.castProperties());
QString group_name = props.groupName();
if(!group_name.isEmpty()) {
QVariant v = data(index, Qt::EditRole);
sql::DbEnumCache& db_enum_cache = qf::core::sql::DbEnumCache::instanceForConnection(connectionName());
QString group_id = v.toString();
sql::DbEnum dbe = db_enum_cache.dbEnum(group_name, group_id);
QString caption_format = props.captionFormat();
QString caption = dbe.fillInPlaceholders(caption_format);
return caption;
}
}
}
else if(role == Qt::BackgroundColorRole) {
ColumnDefinition cd = columnDefinition(index.column());
int cast_type = cd.castType();
if(cast_type == qMetaTypeId<qf::core::sql::DbEnum>()) {
DbEnumCastProperties props(cd.castProperties());
QString group_name = props.groupName();
if(!group_name.isEmpty()) {
QVariant v = data(index, Qt::EditRole);
QString group_id = v.toString();
if(!group_id.isEmpty()) {
sql::DbEnumCache& db_enum_cache = qf::core::sql::DbEnumCache::instanceForConnection(connectionName());
sql::DbEnum dbe = db_enum_cache.dbEnum(group_name, group_id);
QColor color = dbe.color();
if(color.isValid())
return color;
}
}
return QVariant();
}
}
else if(role == Qt::TextColorRole) {
ColumnDefinition cd = columnDefinition(index.column());
int cast_type = cd.castType();
if(cast_type == qMetaTypeId<qf::core::sql::DbEnum>()) {
QVariant v = data(index, Qt::BackgroundRole);
if(v.isValid()) {
QColor bgr_color = v.value<QColor>();
if(bgr_color.isValid()) {
return contrastTextColor(bgr_color);
}
}
}
}
QVariant ret = Super::data(index, role);
return ret;
}
bool FeatureConnector::storeMetaData(FeatureCoverage *fcov, IlwisTypes type) {
if ( type == 0)
return false;
DataDefinition datadef;
ITable attTable = fcov->attributeTable();
ColumnDefinition coldef = attTable->columndefinition(COVERAGEKEYCOLUMN);
if ( coldef.isValid()) {
datadef = coldef.datadef();
} else {
IIndexedIdDomain indexdom;
indexdom.prepare();
indexdom->setRange(IndexedIdentifierRange(type2Prefix(type),fcov->featureCount(type)));
datadef.domain(indexdom);
}
bool ok = CoverageConnector::storeMetaData(fcov, type, datadef);
if ( !ok)
return false;
QString dataFile = fcov->name();
int index = dataFile.lastIndexOf(".");
if ( index != -1) {
dataFile = dataFile.left(index);
}
_odf->setKeyValue("Domain","Type","DomainUniqueID");
_odf->setKeyValue("DomainSort","Sorting","AlphaNumeric");
_odf->setKeyValue("DomainSort","Prefix","feature");
_odf->setKeyValue("DomainSort","Class","Domain UniqueID");
_odf->setKeyValue("DomainIdentifier","Nr",QString::number(fcov->featureCount(type)));
if ( fcov->featureTypes() & itPOLYGON){
ok = storeMetaPolygon(fcov, dataFile);
}
if ( fcov->featureTypes() & itLINE){
ok = storeMetaLine(fcov, dataFile);
}
_odf->store();
return ok;
}
QVariant FlatTable::cell(const quint32 index, quint32 rec, bool asRaw) const
{
if (!const_cast<FlatTable *>(this)->initLoad()) {
return QVariant();
}
if ( !isColumnIndexValid(index)) {
return QVariant();
}
if ( rec < recordCount()) {
QVariant var = _datagrid[rec].cell(index);
if ( !asRaw) {
ColumnDefinition coldef = columndefinition(index);
return coldef.datadef().domain<>()->impliedValue(var);
}
return var;
}
kernel()->issues()->log(TR(ERR_INVALID_RECORD_SIZE_IN).arg(name()),IssueObject::itWarning);
return QVariant();
}
void TableSelector::stringCase(const LogicalExpressionPart& part, const ColumnDefinition& coldef, const QVariant& var, std::vector<bool>::iterator& iter) {
QString text = part.value();
QString fieldtxt = var.toString();
if ( coldef.datadef().domain<>()->valueType() == itTHEMATICITEM){
quint32 raw = var.toUInt();
INamedIdDomain domainid = coldef.datadef().domain<>().as<NamedIdDomain>();
SPDomainItem item = domainid->item(raw);
fieldtxt = item->name();
}
LogicalOperator lconnector = part.logicalConnector();
switch(part.condition()){
case loEQ:{
switch(lconnector){
case loNONE:
*iter = fieldtxt == text;break;
case loOR:
*iter = *iter || fieldtxt == text;break;
case loAND:
*iter = *iter && fieldtxt == text;break;
default:
*iter = false;break;
}
break;
}
case loNEQ:{
switch(lconnector){
case loNONE:
*iter = fieldtxt != text;break;
case loOR:
*iter = *iter || fieldtxt != text;break;
case loAND:
*iter = *iter && fieldtxt != text;break;
default:
*iter = false;break;
}
break;
}
default:
*iter = false;
}
}
void BaseTable::initValuesColumn(const QString& colname){
ColumnDefinition def = columndefinition(colname);
if ( !def.isValid()){
ERROR2(WARN_INVALID_OBJECT,TR("column definition"), name());
return;
}
IlwisTypes valueType = def.datadef().domain<>()->valueType();
std::vector<QVariant> col(recordCount());
for(auto& var : col) {
if ( hasType(valueType, itINTEGER | itDOMAINITEM))
var = QVariant((int)iUNDEF);
else if ( hasType(valueType, itDOUBLE | itFLOAT))
var = QVariant(rUNDEF);
else if ( hasType(valueType, itSTRING))
var = QVariant(sUNDEF);
else if ( hasType(valueType, itCOORDINATE))
var.setValue(crdUNDEF);
}
column(def.name(),col);
}
bool RunsTableModel::setValue(int row_ix, int column_ix, const QVariant &val)
{
bool ret;
ColumnDefinition cd = columnDefinition(column_ix);
if(cd.matchesSqlId(QStringLiteral("finishTimeMs"))) {
QVariant start_ms = value(row_ix, "startTimeMs");
if(!start_ms.isNull()) {
int time_ms = val.toInt() - start_ms.toInt();
if(time_ms > 0) {
Super::setValue(row_ix, "timeMs", time_ms);
}
}
}
else if(cd.matchesSqlId(QStringLiteral("timeMs"))) {
QVariant start_ms = value(row_ix, "startTimeMs");
if(!start_ms.isNull()) {
int finish_ms = val.toInt() + start_ms.toInt();
if(finish_ms > 0) {
Super::setValue(row_ix, columnIndex("finishTimeMs"), finish_ms);
}
}
}
else if(cd.matchesSqlId(QStringLiteral("startTimeMs"))) {
if(!val.isNull()) {
int start_ms = val.toInt();
int finish_ms = value(row_ix, "finishTimeMs").toInt();
int time_ms = value(row_ix, "timeMs").toInt();
if(finish_ms > 0) {
int time_ms = finish_ms - start_ms;
Super::setValue(row_ix, columnIndex("timeMs"), time_ms);
}
else if(time_ms > 0) {
finish_ms = start_ms + time_ms;
Super::setValue(row_ix, "finishTimeMs", finish_ms);
}
}
}
ret = Super::setValue(row_ix, column_ix, val);
return ret;
}
bool BaseTable::addColumn(const ColumnDefinition& def){
if ( !def.isValid())
return false;
if ( isReadOnly())
return false;
changed(true);
bool ok =_attributeDefinition.addColumn(def);
_columns = std::max(_columns, _attributeDefinition.definitionCount());
return ok;
}
ColumnDefinition AppColumnDefinitionFactory::getDefinition(ColumnType type)
{
ColumnDefinition definition;
switch (type) {
case ColumnType::Text:
definition = ColumnDefinition(new TextDefinition);
break;
case ColumnType::DateTime:
definition = ColumnDefinition(new DateTimeDefinition);
break;
case ColumnType::Selection:
definition = ColumnDefinition(new SelectionDefinition);
break;
case ColumnType::None:
break;
}
if (definition) {
definition->setType(type);
}
return definition;
}
void AttributeDefinition::columndefinition(const ColumnDefinition &coldef)
{
if ( coldef.id() >= _columnDefinitionsByIndex.size()) {
addColumn({coldef.name(), coldef.datadef().domain<>()});
} else {
auto iter1 = _columnDefinitionsByName.find(coldef.name());
if ( iter1 != _columnDefinitionsByName.end()) {
ColumnDefinition cdef = coldef;
cdef.columnindex((*iter1).second);
_columnDefinitionsByIndex[cdef.columnindex()] = cdef;
(*iter1).second = cdef.columnindex();
}else {
addColumn(coldef);
}
}
}
bool FlatTable::addColumn(const ColumnDefinition &def)
{
bool ok = BaseTable::addColumn(def);
if(!ok) {
return false;
}
if ( isDataLoaded()) {
for(Record& row : _datagrid) {
row.addColumn();
row.changed(true);
}
initValuesColumn(def.name());
}
return true;
}
bool Table::addColumn(ColumnDefinition& coldef){
Ilwis::ColumnDefinition* ilwDef = coldef.ptr().get();
return this->ptr()->as<Ilwis::Table>()->addColumn(*ilwDef);
}
void Table::setColumnDefinition(ColumnDefinition& coldef){
Ilwis::ColumnDefinition* ilwDef = coldef.ptr().get();
this->ptr()->as<Ilwis::Table>()->columndefinition(*ilwDef);
}
bool NumericRepresentationSetter::canUse(const IIlwisObject &obj, const ColumnDefinition &coldef) const
{
if ( coldef.isValid())
return hasType(coldef.datadef().domain()->ilwisType(), itNUMERICDOMAIN);
return false;
}
QVariant TableModel::data(const QModelIndex &index, int role) const
{
QVariant ret;
if(!index.isValid())
return ret;
if(role == RawValueRole) {
ret = value(index.row(), index.column());
}
else if(role == ValueIsDirtyRole) {
ret = isDirty(index.row(), index.column());
}
else if(role == SortRole) {
int type = columnType(index.column());
if(type == QVariant::Bool)
ret = value(index.row(), index.column()).toBool();
else
ret = data(index, Qt::DisplayRole);
}
else if(role == Qt::DisplayRole) {
ColumnDefinition cd = m_columns.value(index.column());
if(cd.isNull()) {
return QString("!%1").arg(index.column());
}
if(data(index, ValueIsNullRole).toBool()) {
if(isNullReportedAsString())
return QStringLiteral("null");
return QVariant();
}
ret = data(index, Qt::EditRole);
int type = columnType(index.column());
if(type == QVariant::Invalid)
type = ret.type(); /// pokud jsou sloupce virtualni (sloupce se pocitaji, nemusi byt pro ne definovan typ)
if(type == QVariant::ByteArray) {
const static QString blob_string = "{blob %1%2}";
int size = ret.toByteArray().size();
if(size < 1024) ret = blob_string.arg(size).arg(" B");
else ret = blob_string.arg(size/1024).arg("kB");
}
else if(type == QVariant::Bool) {
/// display check
ret = QString();
}
QString format = cd.format();
if(format.isEmpty()) {
if(type == QVariant::Date) {
format = m_defaultDateFormat;
}
else if(type == QVariant::Time) {
format = m_defaultTimeFormat;
//qfInfo() << "format" << format;
}
else if(type == QVariant::DateTime) {
format = m_defaultDateTimeFormat;
//qfInfo() << "format" << format;
}
}
if(!format.isEmpty()) {
if(type == QVariant::Time) {
QTime t = ret.toTime();
ret = t.toString(format);
}
else if(type == QVariant::Date) {
QDate d = ret.toDate();
ret = d.toString(format);
}
else if(type == QVariant::DateTime) {
QDateTime dt = ret.toDateTime();
ret = dt.toString(format);
}
}
}
else if(role == Qt::EditRole) {
ret = data(index, RawValueRole);
ret = rawValueToEdit(index.column(), ret);
}
else if (role == ValueIsNullRole) {
ret = data(index, RawValueRole);
return ret.isNull() && ret.isValid();
}
else if (role == Qt::TextAlignmentRole) {
const ColumnDefinition cd = m_columns.value(index.column());
Qt::Alignment al = cd.alignment();
if(!!al)
ret = (int)al;
else {
if(!data(index, ValueIsNullRole).toBool()) {
ret = data(index, RawValueRole);
if(ret.type() > QVariant::Bool && ret.type() <= QVariant::Double)
ret = Qt::AlignRight;
else
ret = Qt::AlignLeft;
}
}
}
else if(role == Qt::TextColorRole) {
int type = columnType(index.column());
if(type == QVariant::ByteArray)
return QColor(Qt::blue);
if(data(index, ValueIsNullRole).toBool()) {
return QColor(Qt::blue);
}
ret = QVariant();
}
else if (role == Qt::BackgroundColorRole) {
/// delegate does it
}
else if (role == Qt::CheckStateRole) {
int type = columnType(index.column());
if(type == QVariant::Bool) {
//qfInfo() << "BOOL";
return (data(index, Qt::EditRole).toBool()? Qt::Checked: Qt::Unchecked);
}
return QVariant();
}
else if (role == Qt::ToolTipRole) {
QString s = data(index, Qt::DisplayRole).toString();
//s = "<pre>" + s + "</pre>"; /// kvuli chybe v Qt 4.6.3, kdy aplikace pada pokud je v textu za sebou 0x09 0x0A
s.replace("\t\n", "\n");
ret = s;
//ret = data(index, Qt::DisplayRole);
//qfInfo() << ret.toString();
}
return ret;
}