LimeReport/limereport/items/lrchartitemeditor.cpp

#include "lrchartitemeditor.h"
#include "ui_lrchartitemeditor.h"

#include "lrchartitem.h"
#include "lrpagedesignintf.h"

#include <QColorDialog>

ChartItemEditor::ChartItemEditor(LimeReport::ChartItem* item, LimeReport::PageDesignIntf* page,
                                 QSettings* settings, QWidget* parent):
    QWidget(parent),
    ui(new Ui::ChartItemEditor),
    m_charItem(item),
    m_page(page),
    m_settings(settings),
    m_ownedSettings(false),
    m_isReadingSetting(false)
{
    ui->setupUi(this);
    QHBoxLayout* colorLayout = new QHBoxLayout();
    colorLayout->setContentsMargins(0, 0, 0, 0);
    m_colorButton = new QToolButton();
    m_colorButton->setText("...");
    m_colorButton->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
    m_colorIndicator = new ColorIndicator();
    m_colorIndicator->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
    ui->colorWidget->setLayout(colorLayout);
    colorLayout->addWidget(m_colorIndicator);
    colorLayout->addWidget(m_colorButton);
    colorLayout->insertStretch(0);
    readSetting();
    init();
    connect(m_colorButton, SIGNAL(clicked(bool)), this, SLOT(slotChangeSeriesColor()));
}

ChartItemEditor::~ChartItemEditor()
{
#ifdef Q_OS_WIN
    writeSetting();
#endif
#ifdef Q_OS_MAC
    writeSetting();
#endif
    delete ui;
}

QSettings* ChartItemEditor::settings()
{
    if (m_settings) {
        return m_settings;
    } else {
        m_settings = new QSettings("LimeReport", QCoreApplication::applicationName());
        m_ownedSettings = true;
        return m_settings;
    }
}

void ChartItemEditor::readSetting()
{
    if (settings() == 0)
        return;

    m_isReadingSetting = true;

    settings()->beginGroup("ChartItemEditor");
    QVariant v = settings()->value("Geometry");
    if (v.isValid()) {
        restoreGeometry(v.toByteArray());
    }
    v = settings()->value("State");
    if (v.isValid()) {
        ui->splitter->restoreState(v.toByteArray());
    }

    settings()->endGroup();

    m_isReadingSetting = false;
}

void ChartItemEditor::writeSetting()
{
    if (settings() != 0) {
        settings()->beginGroup("ChartItemEditor");
        settings()->setValue("Geometry", saveGeometry());
        settings()->setValue("State", ui->splitter->saveState());
        settings()->endGroup();
    }
}

void ChartItemEditor::rebuildTable()
{
    ui->tableWidget->clearContents();
    ui->tableWidget->setRowCount(m_charItem->series().count());
    for (int i = 0; i < m_charItem->series().count(); ++i) {
        QTableWidgetItem* newRow = new QTableWidgetItem(m_charItem->series().at(i)->name());
        ui->tableWidget->setItem(i, 0, newRow);
    }
}

void ChartItemEditor::init()
{
    m_initing = true;

    ui->tableWidget->setColumnCount(1);
    ui->tableWidget->setRowCount(m_charItem->series().count());
    ui->tableWidget->horizontalHeader()->setStretchLastSection(true);
    ui->tableWidget->setHorizontalHeaderItem(0, new QTableWidgetItem(tr("Series name")));

    rebuildTable();

    if (!m_charItem->datasource().isEmpty()) {
        if (m_page && m_page->datasourceManager()) {
            LimeReport::IDataSource* ds
                = m_page->datasourceManager()->dataSource(m_charItem->datasource());
            if (ds) {
                for (int i = 0; i < ds->columnCount(); ++i) {
                    ui->valuesFieldComboBox->addItem(ds->columnNameByIndex(i));
                    ui->labelsFieldComboBox->addItem(ds->columnNameByIndex(i));
                    ui->xAxisFieldComboBox->addItem(ds->columnNameByIndex(i));
                }
            }
        }
    }

    static int enumIndex
        = LimeReport::SeriesItem::staticMetaObject.indexOfEnumerator("SeriesItemPreferredType");
    QMetaEnum enumerator = LimeReport::SeriesItem::staticMetaObject.enumerator(enumIndex);
    for (int i = 0; i < enumerator.keyCount(); ++i) {
        ui->seriesTypeComboBox->addItem(enumerator.key(i));
    }

#if QT_VERSION < 0x050000
    ui->labelsFieldComboBox->setCurrentIndex(
        ui->labelsFieldComboBox->findText(m_charItem->labelsField()));
    ui->xAxisFieldComboBox->setCurrentIndex(
        ui->xAxisFieldComboBox->findText(m_charItem->xAxisField()));
#else
    ui->labelsFieldComboBox->setCurrentText(m_charItem->labelsField());
    ui->xAxisFieldComboBox->setCurrentText(m_charItem->xAxisField());
#endif
    if (!m_charItem->series().isEmpty()) {
        enableSeriesEditor();
        ui->tableWidget->selectRow(0);
    } else {
        disableSeriesEditor();
    }

    m_initing = false;
}

void ChartItemEditor::enableSeriesEditor()
{
    ui->seriesNameLineEdit->setEnabled(true);
    ui->valuesFieldComboBox->setEnabled(true);
    ui->seriesTypeComboBox->setEnabled(true);
    m_colorButton->setEnabled(true);
    m_colorIndicator->setEnabled(true);
}

void ChartItemEditor::disableSeriesEditor()
{
    ui->seriesNameLineEdit->setText("");
    ui->seriesNameLineEdit->setDisabled(true);
    ui->valuesFieldComboBox->setDisabled(true);
    m_colorButton->setDisabled(true);
    m_colorIndicator->setDisabled(true);
#if QT_VERSION < 0x050000
    ui->valuesFieldComboBox->setEditText("");
#else
    ui->valuesFieldComboBox->setCurrentText("");
#endif
    ui->seriesTypeComboBox->setDisabled(true);
}

LimeReport::SeriesItem* ChartItemEditor::currentSeries()
{
    int curRow = ui->tableWidget->currentRow();
    if ((curRow > -1) && !m_charItem->series().isEmpty() && m_charItem->series().count() > curRow) {
        return m_charItem->series().at(curRow);
    }
    return 0;
}

void ChartItemEditor::resizeEvent(QResizeEvent*)
{
#ifdef Q_OS_UNIX
    writeSetting();
#endif
}

void ChartItemEditor::moveEvent(QMoveEvent*)
{
#ifdef Q_OS_UNIX
    writeSetting();
#endif
}

void ChartItemEditor::on_splitter_splitterMoved(int, int)
{
#ifdef Q_OS_UNIX
    writeSetting();
#endif
}

void ChartItemEditor::on_pbOk_clicked()
{
    emit editingFinished();
    close();
}

void ChartItemEditor::slotAddSeries()
{
    LimeReport::SeriesItem* series = new LimeReport::SeriesItem();
    int curSeriesNumber = m_charItem->series().count();
    while (m_charItem->isSeriesExists("Series" + QString::number(curSeriesNumber)))
        curSeriesNumber++;
    series->setName("Series" + QString::number(curSeriesNumber));
    series->setValuesColumn("");
    series->setLabelsColumn("");
    series->setColor((m_charItem->series().count() < 32)
                         ? LimeReport::color_map[m_charItem->series().count()]
                         : LimeReport::generateColor());
    m_charItem->series().append(series);
    ui->tableWidget->setRowCount(m_charItem->series().count());
    ui->tableWidget->setItem(m_charItem->series().count() - 1, 0,
                             new QTableWidgetItem(series->name()));
    ui->tableWidget->selectRow(m_charItem->series().count() - 1);
#if QT_VERSION < 0x050000
    ui->valuesFieldComboBox->setEditText("");
#else
    ui->valuesFieldComboBox->setCurrentText("");
#endif
}

void ChartItemEditor::slotDeleteSeries()
{
    QList<LimeReport::SeriesItem*> itemsToRemove;
    foreach (QModelIndex index, ui->tableWidget->selectionModel()->selectedRows()) {
        itemsToRemove.append(m_charItem->series().at(index.row()));
    };
    foreach (LimeReport::SeriesItem* series, itemsToRemove) {
        m_charItem->series().removeOne(series);
        delete series;
    }
    rebuildTable();
    disableSeriesEditor();
}

void ChartItemEditor::on_tableWidget_itemSelectionChanged()
{
    if (ui->tableWidget->selectionModel()->hasSelection()) {
        LimeReport::SeriesItem* series
            = m_charItem->series().at(ui->tableWidget->selectionModel()->currentIndex().row());
        ui->seriesNameLineEdit->setText(series->name());
#if QT_VERSION < 0x050000
        ui->valuesFieldComboBox->setCurrentIndex(
            ui->valuesFieldComboBox->findText(series->valuesColumn()));
#else
        ui->valuesFieldComboBox->setCurrentText(series->valuesColumn());
#endif
        m_colorIndicator->setColor(series->color());
        static int enumIndex
            = LimeReport::SeriesItem::staticMetaObject.indexOfEnumerator("SeriesItemPreferredType");
        QMetaEnum enumerator = LimeReport::SeriesItem::staticMetaObject.enumerator(enumIndex);
#if QT_VERSION < 0x050000
        ui->seriesTypeComboBox->setCurrentIndex(
            ui->seriesTypeComboBox->findText(enumerator.valueToKey(series->preferredType())));
#else
        ui->seriesTypeComboBox->setCurrentText(enumerator.valueToKey(series->preferredType()));
#endif
        enableSeriesEditor();
    }
}

void ChartItemEditor::on_seriesNameLineEdit_textChanged(const QString& arg1)
{
    if (currentSeries()) {
        currentSeries()->setName(arg1);
        ui->tableWidget->currentItem()->setText(arg1);
    }
}

void ChartItemEditor::on_valuesFieldComboBox_currentTextChanged(const QString& arg1)
{
    if (currentSeries()) {
        currentSeries()->setValuesColumn(arg1);
    }
}

void ChartItemEditor::on_labelsFieldComboBox_currentTextChanged(const QString& arg1)
{
    if (!m_initing)
        m_charItem->setLabelsField(arg1);
}

void ChartItemEditor::slotChangeSeriesColor()
{
    QColorDialog colorDialog;
    if (colorDialog.exec()) {
        currentSeries()->setColor(colorDialog.selectedColor());
        m_colorIndicator->setColor(colorDialog.selectedColor());
    }
}

void ChartItemEditor::on_seriesTypeComboBox_currentIndexChanged(const QString& arg1)
{
    static int enumIndex
        = LimeReport::SeriesItem::staticMetaObject.indexOfEnumerator("SeriesItemPreferredType");
    QMetaEnum enumerator = LimeReport::SeriesItem::staticMetaObject.enumerator(enumIndex);
    if (currentSeries()) {
        currentSeries()->setPreferredType(
            static_cast<LimeReport::SeriesItem::SeriesItemPreferredType>(
                enumerator.keysToValue(arg1.toLatin1())));
    }
}

void ChartItemEditor::on_xAxisFieldComboBox_currentTextChanged(const QString& arg1)
{
    if (!m_initing)
        m_charItem->setXAxisField(arg1);
}
void ChartItemEditor::on_tableWidget_itemChanged(QTableWidgetItem* item)
{
    if (ui->seriesNameLineEdit->hasFocus())
        return;

    const QString dataStr = item->data(Qt::DisplayRole).toString();
    if (dataStr == ui->seriesNameLineEdit->text())
        return;

    ui->seriesNameLineEdit->setText(dataStr);
}