importfilemodel.h

Go to the documentation of this file.

#ifndef TEXTFILEMODEL_H
#define TEXTFILEMODEL_H

#include <QAbstractTableModel>
#include <QScopedPointer>
#include <QFile>
#include <QRegExp>
#include <QVector>
#include <QTextStream>

#include "tagcontainer.h"


class ImportFileModel : public QAbstractTableModel
{
    Q_OBJECT
public:
    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();

public slots:
    void setLimitedPreview(bool setLimitedPreview);
    void slot_syncFileParserWithTagContainer(TagContainer::GeneralTag tag, QString attrib);

private slots:
    void loadFile();

signals:
    void signal_maxColumns_changed(int oldValue, int newvalue);
    void signal_itemDropped(int column, TagContainer::ColumnTag role, QVariant data);

private:
    QScopedPointer<QFile> file;
    QScopedPointer<QTextStream> stream;

    QRegExp delimiter;
    int skipLines;
    QVector<int> mergeOnSplits;
    QRegExp rowFilter;

    int maxColumns;
    bool limitedPreview;

    QVector<QStringList> preview; //(int, QList) = (rownumber, columnitems)
};

class StrategySettings; //fwd decl

class Strategy
{
public:
    enum StrategyType{
        StrategyNone,
        StrategyTimestamp,
        StrategySensorData,
        StrategySensorSqlData
    };
    enum StrategyFormatTypes {
        FormatTimestamp,
        FormatOffset,
        FormatFactor,
        FormatUnitIdFrom,
        FormatTreeId
    };

    Strategy(StrategySettings &settings);
    virtual const QVariant process(const QVariant &input) const;
    virtual void reconfigure();
    virtual Strategy::StrategyType name() const;

protected:
    QVariant &setting(const Strategy::StrategyFormatTypes &fType) const;

private:
    StrategySettings &m_settings;
};

class StrategySettings : public QHash<Strategy::StrategyFormatTypes, QVariant> {};

#include "simpleparser.h"
#include "unitconvertor.h"

class TimestampStrategy : public Strategy
{
public:
    TimestampStrategy(StrategySettings &settings);
    const QVariant process(const QVariant &input) const;
    void reconfigure();
    Strategy::StrategyType name() const;

private:
    QString format;
    SimpleParser parser;
};

class DataStrategy : public Strategy
{
public:
    DataStrategy(StrategySettings &settings);
    const QVariant process(const QVariant &input) const;
    void reconfigure();
    Strategy::StrategyType name() const;

protected:
    UnitConvertor &unitConvertor();

private:
    UnitConvertor unitConvert;
};

class SqlDataStrategy : public DataStrategy
{
public:
    SqlDataStrategy(StrategySettings &settings);
    void reconfigure();
    Strategy::StrategyType name() const;
};
 // end of group column_manipulation_strategies

class Processor
{
public:
    Processor();
    Processor(const Processor &original);
    ~Processor();
    const QVariant operator()(const QVariant &input) const ;
    void setStrategy(const Strategy::StrategyType &type);
    void setStrategyFormat(const QVariant & data, const Strategy::StrategyFormatTypes & fType);
    const Strategy::StrategyType currentStrategy() const;

private:
    Strategy *strategy;
    StrategySettings m_settings;
};

#include <QVector>

class ImportFileProcessorModel : public ImportFileModel
{
    Q_OBJECT
public:
    ImportFileProcessorModel (QObject *parent = 0);
    QVariant data(const QModelIndex & index, int role = Qt::DisplayRole ) const;

public slots:
    void slot_syncProcessorWithTagContainer(int column, TagContainer::ColumnTag tag, QVariant data);
    void slot_maxColumns_changed(int oldValue, int newValue);

private:
    void processorCountAdjust(int &column);

private:
    QVector<Processor> processors;
};

#include <QFrame>

class QComboBox;
class QVBoxLayout;
class QLineEdit;
class QLabel;
class UnitComboBox;

class ImportFileHeaderSection : public QFrame
{
    Q_OBJECT
public:
    ImportFileHeaderSection(int column, QWidget *parent = 0);
    void adjustContent(const TagContainer::ColumnTag &role, const QVariant &data);

private slots:
    void slot_dataUnitTypeAssigned(int index);
    void slot_dataTypeAssigned(int index);
    void slot_timestampFormatChanged(QString data);

signals:
    void signal_userInteraction(int logicalIndex, TagContainer::ColumnTag tag, QVariant change);

private:
    void setupConnections();
    void setupUnitConversionLabel();

private:
    int logicalIndex;

    QComboBox *dataTypeComboBox;
    QLineEdit *timestampFormatEditor;
    UnitComboBox *unitComboBox;
    QLabel *unitConversionLabel;
    QVBoxLayout *dataTypeLayout;
    QVBoxLayout *mainLayout;

    QLabel *sectionName;
    QString defaultSectionName;

};

#include <QHeaderView>
#include <QHash>
#include <QPointer>

class ImportFileHeaderSection;

class ImportFileHeader : public QHeaderView
{
    Q_OBJECT
public:
    ImportFileHeader(QWidget *parent = 0);
    void setModel(ImportFileProcessorModel *model);
    ImportFileProcessorModel *model() const;
    void addSection(const int column);
    void deleteSection(const int column);
    bool sectionExists(const int column) const;
    QWidget *const sectionAt(const int column);
    int count() const;
    QSize sectionSizeFromContents(int logicalIndex) const;

public slots:
    void slot_syncSectionWithTagContainer(int section, TagContainer::ColumnTag columnTag, QVariant data);

private slots:
    void sectionCountAdjust(int oldCount, int newCount);
    void slot_sectionUserInteraction(int column, TagContainer::ColumnTag role, QVariant data);

protected:
    void paintSection(QPainter *painter, const QRect &rect, int logicalIndex) const;

signals:
    void signal_userInteraction(int column, TagContainer::ColumnTag role, QVariant data);

private:
    QHash< int, QPointer<ImportFileHeaderSection> > sections;
};

#include <QTableView>

class ImportFileView : public QTableView
{
    Q_OBJECT
public:
    ImportFileView(QWidget *parent = 0, TagContainer *tagContainer = 0);
    void setModel(ImportFileProcessorModel *model);
    ImportFileProcessorModel *model();
    ImportFileHeader *horizontalHeader();
    TagContainer *tagContainer();
    void dragMoveEvent(QDragMoveEvent *event);
    void dragLeaveEvent(QDragLeaveEvent *event);
    QMenu *contextMenu();
    void setupAsPreviewer(QString &spCode);

private:
    void contextMenuEvent(QContextMenuEvent *event);
    void setupConnections();

private:
    QMenu *menu;
    TagContainer *m_tagContainer;
};

#endif // TEXTFILEMODEL_H