Model which represents the currently loaded file for upload. More...

#include <importfilemodel.h>

Inheritance diagram for ImportFileModel:

Collaboration diagram for ImportFileModel:

[legend]

Public Slots
void	setLimitedPreview (bool setLimitedPreview)
void	slot_syncFileParserWithTagContainer (TagContainer::GeneralTag tag, QString attrib)
Signals
void	signal_maxColumns_changed (int oldValue, int newvalue)
void	signal_itemDropped (int column, TagContainer::ColumnTag role, QVariant data)
Public Member Functions
	ImportFileModel (QObject *parent=0)
bool	setFile (const QString &path)
int	rowCount (const QModelIndex &parent=QModelIndex()) const
int	columnCount (const QModelIndex &parent=QModelIndex()) const
QVariant	data (const QModelIndex &index, int role=Qt::DisplayRole) const
QVariant	headerData (int section, Qt::Orientation orientation, int role=Qt::DisplayRole) const
bool	dropMimeData (const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
Qt::DropActions	supportedDropActions () const
Qt::ItemFlags	flags (const QModelIndex &index) const
QStringList	mimeTypes () const
void	setSkipLinesCount (int newSkipLinesCount)
void	setDelimiter (QRegExp newDelimiter)
void	setMergeOnSplits (QVector< int > &mergeOnSplits)
void	setRowFilter (const QRegExp &regExp)
void	unloadFile ()

Detailed Description

Model which represents the currently loaded file for upload.

Todo:

Currently files are cached completely before shown, but a better aproach would be to load only that which is shown.

QTextStream allows many adjustments and those could be adjusted through the GUI and saved through TagContainer.

Constructor & Destructor Documentation

ImportFileModel::ImportFileModel ( QObject * parent = 0 )

                                                          : QAbstractTableModel(parent) , skipLines(0), limitedPreview(true)
{
    maxColumns = 0;
}

Member Function Documentation

int ImportFileModel::columnCount ( const QModelIndex & parent = QModelIndex() ) const

Referenced by ImportFileHeader::paintSection().

{
    return maxColumns;
}

QVariant ImportFileModel::data	(	const QModelIndex &	index,
		int	role = `Qt::DisplayRole`
	)			const

Reimplemented in ImportFileProcessorModel.

{
    if (!index.isValid()) return QVariant();
    if (index.column() >= preview[index.row()].count()) return QVariant();
    if (role==Qt::DisplayRole){
        return preview[index.row()].at(index.column());
    }
    else return QVariant();
}

bool ImportFileModel::dropMimeData	(	const QMimeData *	data,
		Qt::DropAction	action,
		int	row,
		int	column,
		const QModelIndex &	parent
	)

Reimplemented from QAbstractTableModel.

{
    //qDebug() << "Column nr: " << column << " " << row;
    //qDebug() << "Parent Column nr: " << parent.column();
    if (action == Qt::IgnoreAction)
        return true;
    if (!(data->hasFormat("appobj/treeitem.pointer"))) return false;
    if (parent.column() == -1) return false;

    if (data->hasFormat("appobj/treeitem.pointer")){
        QByteArray encodedData = data->data("appobj/treeitem.pointer");
        QDataStream stream(&encodedData, QIODevice::ReadOnly);
        while (!stream.atEnd()) {
            qint64 p;
            stream >> p;
            TreeItem *droppedTree = reinterpret_cast<TreeItem*>(p);
            if (droppedTree->data(TreeItem::TreeItemColumnName).toString() != QString("sens_chan_nr"))
                return false;
            qDebug() << "Dropped treepointer: " << reinterpret_cast<TreeItem*>(QVariant::fromValue(p).value<qint64>()) << "with tree_id: " << droppedTree->data(TreeItem::TreeItemId).toInt();
            emit signal_itemDropped(parent.column(), TagContainer::ColumnTagTreeId, droppedTree->data(TreeItem::TreeItemId));
        }
    }
    return true;
}

Qt::ItemFlags ImportFileModel::flags ( const QModelIndex & index ) const

{
    Qt::ItemFlags defaultFlags = QAbstractTableModel::flags(index);
    if (index.row()==-1 && index.column()==-1) return defaultFlags;
    else return defaultFlags | Qt::ItemIsDropEnabled;
}

QVariant ImportFileModel::headerData	(	int	section,
		Qt::Orientation	orientation,
		int	role = `Qt::DisplayRole`
	)			const

{
    if (orientation == Qt::Horizontal) return QVariant();
    else return QAbstractTableModel::headerData(section, orientation, role);
}

QStringList ImportFileModel::mimeTypes ( ) const

{
    QStringList types;
    types << "appobj/treeitem.pointer";
    return types;
}

int ImportFileModel::rowCount ( const QModelIndex & parent = QModelIndex() ) const

Referenced by ImportFileProcessorModel::slot_syncProcessorWithTagContainer().

{
    return preview.count();
}

void ImportFileModel::setDelimiter ( QRegExp newDelimiter )

Referenced by slot_syncFileParserWithTagContainer().

{delimiter = newDelimiter; loadFile();};

bool ImportFileModel::setFile ( const QString & path )

{
    unloadFile();

    qDebug() << "Loading " + path + " file in ImportFileModel: " << path;

    if (!QFile::exists(path)){
        qWarning() << "File does not exist: " << path;
        return false;
    }

    stream.reset(new QTextStream());
    file.reset(new QFile(path));

    if (!file->open(QIODevice::ReadOnly | QIODevice::Text))
    {
        qWarning() << "ImportFileModel: Error: Cannot read file: "
                << path
                << file->errorString();
        return false;
    }

    stream->setDevice(file.data());
    loadFile();

    qDebug() << "File " + file->fileName() + " successfully loaded in ImportFileModel";

    return true;
}

void ImportFileModel::setLimitedPreview ( bool setLimitedPreview ) [slot]

{
    limitedPreview = setLimitedPreview; loadFile();
}

void ImportFileModel::setMergeOnSplits ( QVector< int > & mergeOnSplits )

Referenced by slot_syncFileParserWithTagContainer().

{this->mergeOnSplits = mergeOnSplits; loadFile();};

void ImportFileModel::setRowFilter ( const QRegExp & regExp )

Referenced by slot_syncFileParserWithTagContainer().

{
    if (regExp.isValid()) rowFilter = regExp;
    else rowFilter = QRegExp();
    loadFile();
}

void ImportFileModel::setSkipLinesCount ( int newSkipLinesCount )

Referenced by slot_syncFileParserWithTagContainer().

{skipLines =  newSkipLinesCount; loadFile();}

void ImportFileModel::signal_itemDropped	(	int	column,
		TagContainer::ColumnTag	role,
		QVariant	data
	)			`[signal]`

Referenced by dropMimeData().

void ImportFileModel::signal_maxColumns_changed	(	int	oldValue,
		int	newvalue
	)			`[signal]`

Referenced by ImportFileProcessorModel::ImportFileProcessorModel().

void ImportFileModel::slot_syncFileParserWithTagContainer	(	TagContainer::GeneralTag	tag,
		QString	attrib
	)			`[slot]`

{
    switch (tag){
    case TagContainer::GeneralTagColumnDelimiter:{
            setDelimiter(QRegExp(attrib));
        } break;
    case TagContainer::GeneralTagSkipLines:{
            setSkipLinesCount(attrib.toInt());
        }  break;
    case TagContainer::GeneralTagMergeOnSplits:{
            QStringList sList = attrib.split(MERGE_DELIMITER);
            QVector<int> iList;
            bool ok;
            foreach(QString s, sList){
                int i = s.toInt(&ok);
                if (ok == true) iList.append(i);
                Q_ASSERT(ok);
            }
            setMergeOnSplits(iList);
        } break;
    case TagContainer::GeneralTagRowFilter:{
            setRowFilter(QRegExp(attrib));
        } break;
    }
}

Qt::DropActions ImportFileModel::supportedDropActions ( ) const

{
    return Qt::CopyAction | Qt::MoveAction | Qt::LinkAction;
}

void ImportFileModel::unloadFile ( )

Referenced by setFile().

                                {
    beginResetModel();
    preview.clear();
    maxColumns = 0;
    endResetModel();
}

The documentation for this class was generated from the following files:

ImportFileModel Class Reference

Public Slots

Signals

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation