FlowVis/LayerManagerWidget.cpp

#include "LayerManagerWidget.h"
#include <QtGui>
#include <iostream>

#define MAX_LAYERS 5

LayerManagerWidget::LayerManagerWidget(QWidget *parent)
        : QWidget(parent)
{
        layout = new QVBoxLayout();
        stackedLayers = new QVBoxLayout();
        addLayerButton = new QPushButton("Add Layer");

        layout->addLayout(stackedLayers);
        layout->addStretch();
        layout->addWidget(addLayerButton,0,Qt::AlignRight);
        
        this->setLayout(layout);


        testAddLayers();
        this->setSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed);

        connectSignals();
}

void LayerManagerWidget::connectSignals()
{
        QObject::connect(addLayerButton,SIGNAL(clicked()),this,SLOT(addLayer()));
}

void LayerManagerWidget::layerTypeChanged(int type, LayerWidget *sender)
{
        int index = stackedLayers->indexOf(sender);
        if(index != -1)         //exists
                emit layerTypeChanged(type, index);
}

void LayerManagerWidget::layerChannelChanged(int channel, LayerWidget *sender)
{
        int index = stackedLayers->indexOf(sender);
        if(index != -1)         //exists
                emit layerChannelChanged(channel, index);
}

void LayerManagerWidget::layerTransferImageUpdated(const QImage& image, LayerWidget *sender)
{
        int index = stackedLayers->indexOf(sender);
        if(index != -1)         //exists
                emit layerTransferImageChanged(image,index);
}
LayerWidget* LayerManagerWidget::addLayerWidget()
{
        if(stackedLayers->count() == MAX_LAYERS)
                return NULL;

        LayerWidget *layer = new LayerWidget();
        //layers.append(layer);
        
        stackedLayers->addWidget(layer);

        QObject::connect(layer,SIGNAL(buttonClicked(int,LayerWidget*)),this,SLOT(layerButtonClicked(int,LayerWidget*)));
        QObject::connect(layer,SIGNAL(typeChanged(int,LayerWidget*)),this,SLOT(layerTypeChanged(int,LayerWidget*)));
        QObject::connect(layer,SIGNAL(channelChanged(int,LayerWidget*)),this,SLOT(layerChannelChanged(int,LayerWidget*)));
        QObject::connect(layer,SIGNAL(transferImageUpdated(const QImage,LayerWidget*)),this,SLOT(layerTransferImageUpdated(const QImage,LayerWidget*)));
        QObject::connect(this,SIGNAL(channelCountUpdated(int)),layer,SLOT(channelCountChanged(int)));
        emit layerAdded(stackedLayers->indexOf(layer));         //neuer layer
        layer->channelCountChanged(channelCount);
        this->update();

        //removeLayer(layer);

        return layer;
}

void LayerManagerWidget::addLayer()
{
        addLayerWidget();
}
void LayerManagerWidget::layerButtonClicked(int button,LayerWidget* sender)
{
        int pos = stackedLayers->indexOf(sender);
        switch(button)
        {
        case 0: //Down
                if(pos == stackedLayers->count()-1)
                        break;

                stackedLayers->removeWidget(sender);
                stackedLayers->insertWidget(pos+1,sender);
                
                emit layerPosChanged(pos, pos+1);
                break;

        case 1: //up
                if(pos == 0)
                        break;
                
                stackedLayers->removeWidget(sender);
                stackedLayers->insertWidget(pos-1,sender);

                emit layerPosChanged(pos, pos-1);
                break;

        case 2: //Remove
                
                removeLayer(sender);
                break;
        
        }
                
}
void LayerManagerWidget::removeLayer(LayerWidget *layer, bool check)
{
        int count = stackedLayers->count();
        if((stackedLayers->indexOf(layer) != -1) && (stackedLayers->count() > 1 || check == false))
        {

                emit layerRemoved(stackedLayers->indexOf(layer));
                stackedLayers->removeWidget(layer);

                delete layer;
                this->repaint();
        }
}
void LayerManagerWidget::testAddLayers()
{
        addLayer();
        
}

void LayerManagerWidget::channelCountChanged(int channels)
{
        channelCount = channels;
        emit channelCountUpdated(channels);
}
LayerManagerWidget::~LayerManagerWidget()
{
        delete layout;
}

void LayerManagerWidget::saveToFile()
{
        QString fileName = QFileDialog::getSaveFileName(this, tr("Save Config File"), ".", tr("Config Files (*.cfg)"));
        
        QFile file(fileName);

        file.open(QIODevice::WriteOnly);

        QDataStream out(&file);

        int count = stackedLayers->count();

        out << count;

        for(int i=0; i< count; i++)
                out << (LayerWidget*)stackedLayers->itemAt(i)->widget();

        file.close();

        std::cout << "Config saved to " << fileName.toStdString() << std::endl;
}

void LayerManagerWidget::loadFromFile()
{
        QString fileName = QFileDialog::getOpenFileName(this, tr("Open Config File"), ".", tr("Config Files (*.cfg)"));

        QFile file(fileName);
        if(file.exists()){
                file.open(QIODevice::ReadOnly);

                QDataStream in(&file);

                int count;
                
                while(stackedLayers->count() > 0)
                        removeLayer((LayerWidget*)stackedLayers->itemAt(0)->widget(),false);    //alle removen 
                
                in >> count;

                for(int i=0; i<count; i++)      //Layer einlesen
                {
                        LayerWidget* widget = addLayerWidget();
                        in >> widget;
                        widget->channelCountChanged(channelCount);
                }

                std::cout << "Config read from " << fileName.toStdString() << std::endl;
        }
}