source: projectionDesigner/trunk/projdesigner/src/gui/QChannelWidget.cpp @ 361

#include "ProjectionModel.h"
#include "Channel.h"
#include "Warp.h"
#include "gui/QChannelWidget.h"
#include "gui/QDesignViewWindow.h"

using namespace projection;

QChannelWidget::QChannelWidget(QWidget* pParent, Qt::WFlags flags)
    : QWidget(pParent, flags), m_pChannel(NULL)
{
    ui.setupUi(this);

    ui.pluginComboBox->clear();

                foreach (ProjectorInterface *projector_interface, ProjectionModel::projector_interfaces)
                                {
                                                foreach (QString projector_name, projector_interface->projectors())
                                                                {
                                                                                ProjectorWidget* projector_widget = projector_interface->newProjectorWidget(projector_name);
                                                                                Q_ASSERT (NULL!=projector_widget);
                                                                                ui.stackedWidget->addWidget(projector_widget);
                                                                                ui.pluginComboBox->addItem(projector_widget->data().getFullName());
                                                                }
                                }

                // If we only have the default plugin, the combo is not displayed.
                if (ui.pluginComboBox->count()==1) 
                {
                                ui.pluginComboBox->hide();
                                ui.pluginLabel->hide();
                }
                

                connect(ui.pluginComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(on_pluginComboBox_currentIndexChanged(int)));

    ui.toolBox->setAutoFillBackground(false);

    setEnabled(false);

                ui.projectionTransformWidget->disconnect();
                connect(ui.projectionTransformWidget, SIGNAL(matrixChanged(const TransformMatrix&)),
                                                this, SLOT(on_projectionTransformWidget_matrixChanged(const TransformMatrix&)));

                ui.projectionTransformWidget->setUseScale(false);
                ui.viewTransformWidget->setUseScale(false);
}

QChannelWidget::~QChannelWidget()
{
}

void QChannelWidget::setChannel(Channel* pChannel)
{
                if (m_pChannel==pChannel) return;

    m_pChannel = pChannel;

                if (pChannel) 
                {
                                Q_ASSERT(NULL!=pChannel->getProjector());
                                QString fullname=pChannel->getProjector()->getFullName();
                                int next_index=ui.pluginComboBox->findText(fullname);
                                ui.pluginComboBox->setCurrentIndex(next_index);

                                // In some case, the on_pluginComboBox_currentIndexChanged is not called at first time (because the index does not change indeed).
                                // So, we force the connection
                                ProjectorWidget* projector_widget=qobject_cast<ProjectorWidget*>(ui.stackedWidget->currentWidget());
                                projector_widget->disconnect();
                                m_pChannel->disconnect();

                                connect(projector_widget, SIGNAL(dataChanged(const ProjectorData&)), m_pChannel, SLOT(updatePluginData(const ProjectorData&)));
                                
                }
                else ui.pluginComboBox->setCurrentIndex(0);
                updateGUI();

                setEnabled(NULL!=pChannel);
}

Channel* QChannelWidget::getChannel() const
{
    return m_pChannel;
}

void QChannelWidget::updateGUI()
{
    if (m_pChannel)
    {
        ui.nameEdit->setText(m_pChannel->getName());
        ui.overlayNameCheckBox->setChecked(m_pChannel->getOverlayName());
        ui.remoteHostNameEdit->setText(m_pChannel->getRemoteHostName());
        ui.remoteFullScreenCheckBox->setChecked(m_pChannel->getRemoteFullScreen());
        ui.remoteScreenComboBox->setCurrentIndex(ui.remoteScreenComboBox->findText(QString::number(m_pChannel->getRemoteScreen())));
        ui.overlayImageEdit->setText(m_pChannel->getOverlayImageFileName());

                                // On s'occupe de la partie Projection
                                // Inutile si elle n'est pas selectionnee, d'ailleurs.

                                // On met a jour les donnees.
                                const ProjectorData* projector_data=m_pChannel->getProjector();
                                ProjectorWidget* projector_widget=qobject_cast<ProjectorWidget*>(ui.stackedWidget->currentWidget());
                                projector_widget->updateGUI(projector_data);

                                ui.projectionTransformWidget->setMatrix(m_pChannel->getProjectorTransformMatrix());

        ui.warpCheckBox->setChecked(m_pChannel->getDistWarpEnabled());
        ui.warpResSpinBox->setValue(m_pChannel->getDistWarp()->getNumCtrlPoints());




                                // On s'occupe de la partie View
                                // Inutile si elle n'est pas selectionnee, d'ailleurs.


                                ui.viewProjectionWidget->disconnect();
                                ui.viewTransformWidget->disconnect();

                                connect(ui.viewProjectionWidget, SIGNAL(matrixChanged(const ProjectionMatrix&)),
                                                                this, SLOT(on_viewProjectionWidget_matrixChanged(const ProjectionMatrix&)));
                                connect(ui.viewTransformWidget, SIGNAL(matrixChanged(const TransformMatrix&)),
                                                                this, SLOT(on_viewTransformWidget_matrixChanged(const TransformMatrix&)));
                                ui.viewProjectionWidget->setMatrix(m_pChannel->getView()->getProjectionMatrix());
                                ui.viewTransformWidget->setMatrix(m_pChannel->getView()->getTransformMatrix());

    }
    else
    {
        ui.nameEdit->setText("");
        ui.overlayNameCheckBox->setChecked(false);
        ui.remoteHostNameEdit->setText("");
        ui.remoteFullScreenCheckBox->setChecked(false);
        ui.remoteScreenComboBox->setCurrentIndex(0);
        ui.overlayImageEdit->setText("");

                                ui.projectionTransformWidget->clear();
                                ui.viewProjectionWidget->clear();
                                ui.viewTransformWidget->clear();

                                Q_ASSERT(NULL!=ui.stackedWidget);
                                if (NULL!=ui.stackedWidget->currentWidget())
                                {
                                                ProjectorWidget* projector_widget=qobject_cast<ProjectorWidget*>(ui.stackedWidget->currentWidget());
                                                Q_ASSERT(NULL!=projector_widget);
                                                projector_widget->clear();
                                                
                                }
                }
}

void QChannelWidget::on_nameEdit_editingFinished()
{
    if (m_pChannel)
    {
        if (m_pChannel->getName() != ui.nameEdit->text())
        {
            m_pChannel->setName(ui.nameEdit->text());
            ui.nameEdit->setText(m_pChannel->getName());
        }
    }
}

void QChannelWidget::on_overlayNameCheckBox_toggled(bool checked)
{
    if (m_pChannel)
    {
        m_pChannel->setOverlayName(checked);
    }
}

void QChannelWidget::on_remoteHostNameEdit_editingFinished()
{
    if (m_pChannel)
    {
        if (m_pChannel->getRemoteHostName() != ui.remoteHostNameEdit->text())
            m_pChannel->setRemoteHostName(ui.remoteHostNameEdit->text());
    }
}

void QChannelWidget::on_remoteFullScreenCheckBox_toggled(bool checked)
{
    if (m_pChannel)
    {
        m_pChannel->setRemoteFullScreen(checked);
    }
}

void QChannelWidget::on_remoteScreenComboBox_activated(int)
{
    if (m_pChannel)
    {
        m_pChannel->setRemoteScreen(ui.remoteScreenComboBox->currentText().toInt());
    }
}

void QChannelWidget::on_overlayImageEdit_editingFinished()
{
    if (m_pChannel)
    {
        if (m_pChannel->getOverlayImageFileName() != ui.overlayImageEdit->text())
            m_pChannel->setOverlayImageFileName(ui.overlayImageEdit->text());
    }
}

void QChannelWidget::on_overlayImageBrowseButton_clicked()
{
    if (m_pChannel)
    {
        QString fileName = QFileDialog::getOpenFileName(this, "Choose a file to open", ui.overlayImageEdit->text(), "Image files (*.*)");
        if (!fileName.isEmpty()) {
            ui.overlayImageEdit->setText(fileName);
            on_overlayImageEdit_editingFinished();
        }
    }
}

void QChannelWidget::on_warpCheckBox_toggled(bool checked)
{
    if (m_pChannel)
    {
        m_pChannel->setDistWarpEnabled(checked);
    }
}

void QChannelWidget::on_warpResSpinBox_valueChanged(int value)
{
    if (m_pChannel)
    {
        m_pChannel->getDistWarp()->setNumCtrlPoints(value);
        m_pChannel->updateData();
    }
}

void QChannelWidget::on_warpResetButton_clicked()
{
    if (m_pChannel)
    {
        m_pChannel->getDistWarp()->reset();
        m_pChannel->updateData();
    }
}

void QChannelWidget::on_calibrateButton_clicked()
{
}

void QChannelWidget::on_fitButton_clicked()
{
    if (m_pChannel)
    {
        m_pChannel->fitView();
    }
}

void QChannelWidget::on_windowButton_clicked()
{
    if (m_pChannel)
    {
        m_pChannel->showProjectorWindow();
    }
}

void QChannelWidget::on_projectionTransformWidget_matrixChanged(const TransformMatrix& matrix)
{
                m_pChannel->setProjectorTransformMatrix(matrix);
}

void QChannelWidget::on_viewProjectionWidget_matrixChanged(const ProjectionMatrix& matrix)
{
                m_pChannel->setViewProjectionMatrix(matrix);
}

void QChannelWidget::on_viewTransformWidget_matrixChanged(const TransformMatrix& matrix)
{
                m_pChannel->setViewTransformMatrix(matrix);
}

void QChannelWidget::on_pluginComboBox_currentIndexChanged(int current_index)
{
                ui.stackedWidget->currentWidget()->disconnect();
                ui.stackedWidget->setCurrentIndex(current_index);
                ui.stackedWidget->currentWidget()->disconnect();
                if (m_pChannel)
                {
                                m_pChannel->setProjector (ui.pluginComboBox->currentText());
                                ProjectorWidget* projector_widget=qobject_cast<ProjectorWidget*>(ui.stackedWidget->currentWidget());
                                m_pChannel->disconnect();
                                connect(projector_widget, SIGNAL(dataChanged(const ProjectorData&)), m_pChannel, SLOT(updatePluginData(const ProjectorData&)));
                                m_pChannel->updateData();
                                
                }
                updateGUI();
}