Layers Class Reference

Widget which shows a list of layers. More...

#include <layers.h>

Inheritance diagram for Layers:

Collaboration diagram for Layers:

Signals
void	layerChanged (lc::Layer_CSPtr layer)

Public Member Functions
	Layers (CadMdiChild *mdiChild=nullptr, QWidget *parent=0)
	Create widget. More...
	~Layers ()
void	setMdiChild (CadMdiChild *mdiChild=nullptr)
	Set new document. More...

Protected Member Functions
void	createLayer (lc::Layer_CSPtr layer)
void	deleteLayer (lc::Layer_CSPtr layer)
void	replaceLayer (lc::Layer_CSPtr oldLayer, lc::Layer_CSPtr newLayer)

Protected Attributes
Ui::Layers *	ui
LayerModel *	model

Private Slots
void	onSelectionChanged (const QItemSelection &selected, const QItemSelection &deselected)
void	on_newButton_clicked ()
void	on_deleteButton_clicked ()
void	on_layerList_clicked (const QModelIndex &index)
void	changeLayerName (lc::Layer_CSPtr &layer, const std::string &name)

Private Member Functions
void	updateLayerList ()
void	on_addLayerEvent (const lc::AddLayerEvent &)
void	on_removeLayerEvent (const lc::RemoveLayerEvent &)
void	on_replaceLayerEvent (const lc::ReplaceLayerEvent &)

Private Attributes
CadMdiChild *	_mdiChild

Detailed Description

Widget which shows a list of layers.

Definition at line 22 of file layers.h.

Constructor & Destructor Documentation

Layers::Layers	(	CadMdiChild *	mdiChild = nullptr,
		QWidget *	parent = 0
	)

Create widget.

Definition at line 6 of file layers.cpp.

                                                     :
    QDockWidget(parent),
    ui(new Ui::Layers),
    _mdiChild(nullptr) {

    ui->setupUi(this);

    model = new LayerModel(this);
    setMdiChild(mdiChild);

    ui->layerList->setModel(model);
    ui->layerList->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
    ui->layerList->horizontalHeader()->setSectionResizeMode(LayerModel::NAME, QHeaderView::Stretch);

    connect(model, &LayerModel::nameChanged, this, &Layers::changeLayerName);
    connect(ui->layerList->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
            this, SLOT(onSelectionChanged(const QItemSelection &, const QItemSelection &)));
}

Layers::~Layers

(

)

Definition at line 25 of file layers.cpp.

                {
    delete ui;
}

Member Function Documentation

void Layers::changeLayerName ( lc::Layer_CSPtr &  layer, const std::string &  name  )

privateslot

Definition at line 100 of file layers.cpp.

                                                                        {
    if(name.empty()) {
        return;
    }

    auto newLayer = std::make_shared<const lc::Layer>(
        name,
        layer->lineWidth(),
        layer->color(),
        layer->linePattern(),
        layer->isFrozen()
    );

    replaceLayer(layer, newLayer);
}

void Layers::createLayer ( lc::Layer_CSPtr  layer )

protected

Definition at line 116 of file layers.cpp.

                                            {
    if(_mdiChild != nullptr) {
        auto operation = std::make_shared<lc::operation::AddLayer>(_mdiChild->document(), layer);
        operation->execute();
    }
}

void Layers::deleteLayer ( lc::Layer_CSPtr  layer )

protected

Definition at line 123 of file layers.cpp.

                                            {
    if(_mdiChild != nullptr) {
        try {
            auto operation = std::make_shared<lc::operation::RemoveLayer>(_mdiChild->document(), layer);
            operation->execute();
        }
        catch(const char* message) {
            QMessageBox::critical(nullptr, "Error", message);
        }
    }
}

void Layers::layerChanged ( lc::Layer_CSPtr  layer )

signal

void Layers::on_addLayerEvent ( const lc::AddLayerEvent &  event )

private

Definition at line 163 of file layers.cpp.

                                                          {
    _mdiChild->setActiveLayer(event.layer());

    updateLayerList();
}

void Layers::on_deleteButton_clicked ( )

privateslot

Definition at line 60 of file layers.cpp.

                                     {
    QModelIndexList selection = ui->layerList->selectionModel()->selectedRows();

    deleteLayer(model->layerAt(selection.first().row()));
}

void Layers::on_layerList_clicked ( const QModelIndex &  index )

privateslot

Definition at line 66 of file layers.cpp.

                                                          {
    if(!index.isValid() || _mdiChild == nullptr) {
        return;
    }

    auto layer = model->layerAt(index.row());
    if(index.column() != LayerModel::NAME) {
        auto locked = layer->isFrozen();

        switch (index.column()) {
            case LayerModel::LOCKED:
                locked = !locked;
                break;

            case LayerModel::EDIT:
                auto dialog = new AddLayerDialog(layer, _mdiChild->document(), this);
                dialog->show();

                connect(dialog, &AddLayerDialog::editLayer, this, &Layers::replaceLayer);
                return;
        }

        auto newLayer = std::make_shared<const lc::Layer>(
                layer->name(),
                layer->lineWidth(),
                layer->color(),
                layer->linePattern(),
                locked
        );

        replaceLayer(layer, newLayer);
    }
}

void Layers::on_newButton_clicked ( )

privateslot

Definition at line 49 of file layers.cpp.

                                  {
    if(_mdiChild == nullptr) {
        return;
    }

    auto dialog = new AddLayerDialog(_mdiChild->document(), this);
    dialog->show();

    connect(dialog, &AddLayerDialog::newLayer, this, &Layers::createLayer);
}

void Layers::on_removeLayerEvent ( const lc::RemoveLayerEvent &  event )

private

Definition at line 169 of file layers.cpp.

                                                                {
    if(_mdiChild->activeLayer() == event.layer()) {
        _mdiChild->setActiveLayer(_mdiChild->document()->layerByName("0"));
    }

    updateLayerList();
}

void Layers::on_replaceLayerEvent ( const lc::ReplaceLayerEvent &  event )

private

Definition at line 177 of file layers.cpp.

                                                                  {
    if(_mdiChild->activeLayer() == event.oldLayer()) {
        _mdiChild->setActiveLayer(event.newLayer());
    }

    updateLayerList();
}

void Layers::onSelectionChanged ( const QItemSelection &  selected, const QItemSelection &  deselected  )

privateslot

Definition at line 185 of file layers.cpp.

                                                                                                {
    if(selected.isEmpty()) {
        return;
    }

    auto layer = model->layerAt(selected.first().top());
    _mdiChild->setActiveLayer(layer);
    emit layerChanged(layer);
}

void Layers::replaceLayer ( lc::Layer_CSPtr  oldLayer, lc::Layer_CSPtr  newLayer  )

protected

Definition at line 135 of file layers.cpp.

                                                                        {
    if(_mdiChild != nullptr) {
        auto operation = std::make_shared<lc::operation::ReplaceLayer>(_mdiChild->document(), oldLayer, newLayer);
        operation->execute();
    }
}

void Layers::setMdiChild

(

CadMdiChild *

mdiChild = nullptr

)

Set new document.

Parameters

document

New document Update the layer list.

Definition at line 29 of file layers.cpp.

                                              {
    if(_mdiChild != nullptr) {
        auto document = _mdiChild->document();
        document->addLayerEvent().disconnect<Layers, &Layers::on_addLayerEvent>(this);
        document->removeLayerEvent().disconnect<Layers, &Layers::on_removeLayerEvent>(this);
        document->replaceLayerEvent().disconnect<Layers, &Layers::on_replaceLayerEvent>(this);
    }

    _mdiChild = mdiChild;

    if(mdiChild != nullptr) {
        auto document = mdiChild->document();
        document->addLayerEvent().connect<Layers, &Layers::on_addLayerEvent>(this);
        document->removeLayerEvent().connect<Layers, &Layers::on_removeLayerEvent>(this);
        document->replaceLayerEvent().connect<Layers, &Layers::on_replaceLayerEvent>(this);
    }

    updateLayerList();
}

void Layers::updateLayerList ( )

private

Definition at line 142 of file layers.cpp.

                             {
    std::vector<lc::Layer_CSPtr> layersVector;

    if (_mdiChild != nullptr) {
        auto layersMap = _mdiChild->document()->allLayers();

        for (auto layer : layersMap) {
            layersVector.insert(layersVector.begin(), layer.second);
        }
    }

    model->setLayers(layersVector);

    if(_mdiChild != nullptr && _mdiChild->activeLayer() != nullptr) {
        auto layer = _mdiChild->activeLayer();
        ui->layerList->selectRow(model->indexOf(layer));

        emit layerChanged(layer);
    }
}

Member Data Documentation

CadMdiChild* Layers::_mdiChild

private

Definition at line 59 of file layers.h.

LayerModel* Layers::model

protected

Definition at line 52 of file layers.h.

Ui::Layers* Layers::ui

protected

Definition at line 51 of file layers.h.

---

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

• lcUI/widgets/layers.h
• lcUI/widgets/layers.cpp