]> Shamusworld >> Repos - architektonas/blobdiff - src/layerwidget.cpp
Whitespace changes. :-P
[architektonas] / src / layerwidget.cpp
index faaf5b999854423f546b39724f854e7419900fa3..1ab9d79f22ec815e80de126bc84fffe29d7d9a2f 100644 (file)
@@ -1,3 +1,4 @@
+//
 // layerwidget.cpp: Layer add/remove/use widget
 //
 // Part of the Architektonas Project
 #include "global.h"
 #include "layeritemwidget.h"
 
-
 LayerWidget::LayerWidget(void): QWidget(),
        addLayer(new QToolButton), removeLayer(new QToolButton),
        editLayer(new QToolButton), layerUp(new QToolButton),
        layerDown(new QToolButton), list(new QListWidget)
 {
-       LayerItemWidget * liw = new LayerItemWidget("Background");
        QListWidgetItem * qlwi = new QListWidgetItem(list);
+       LayerItemWidget * liw = new LayerItemWidget("Background", false, false, qlwi);
        list->setItemWidget(qlwi, liw);
 
-//     QToolButton * pb1 = new QToolButton;
-//     QToolButton * pb2 = new QToolButton;
-//     QToolButton * pb3 = new QToolButton;
-//     QToolButton * pb4 = new QToolButton;
-//     QToolButton * pb5 = new QToolButton;
-
        addLayer->setIcon(QIcon(":/res/layer-add.png"));
        removeLayer->setIcon(QIcon(":/res/layer-delete.png"));
        editLayer->setIcon(QIcon(":/res/layer-edit.png"));
@@ -58,48 +52,129 @@ LayerWidget::LayerWidget(void): QWidget(),
        setLayout(mainLayout);
 
        connect(list, SIGNAL(currentRowChanged(int)), this, SLOT(HandleLayerSelected(int)));
+       connect(list, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(HandleDblClick(QListWidgetItem *)));
        connect(addLayer, SIGNAL(clicked()), this, SLOT(AddLayer()));
        connect(removeLayer, SIGNAL(clicked()), this, SLOT(DeleteLayer()));
        connect(editLayer, SIGNAL(clicked()), this, SLOT(EditLayer()));
        connect(layerUp, SIGNAL(clicked()), this, SLOT(MoveLayerUp()));
        connect(layerDown, SIGNAL(clicked()), this, SLOT(MoveLayerDown()));
 
+       connect(liw, SIGNAL(HideToggled(QListWidgetItem *, bool)), this, SLOT(HandleHideToggle(QListWidgetItem *, bool)));
+       connect(liw, SIGNAL(LockToggled(QListWidgetItem *, bool)), this, SLOT(HandleLockToggle(QListWidgetItem *, bool)));
+
        list->setCurrentRow(0);
-}
 
+       // We set global variables here, since we are 'in charge' of them (mostly)
+       Global::activeLayer = 0;
+       Global::numLayers = 1;
+       Global::layerHidden.clear();
+       Global::layerLocked.clear();
+       Global::layerName.clear();
+       Global::layerHidden.push_back(false);
+       Global::layerLocked.push_back(false);
+       Global::layerName.push_back("Background");
+}
 
 LayerWidget::~LayerWidget()
 {
 }
 
+void LayerWidget::Reload(void)
+{
+       list->clear();
+
+       for(int i=0; i<Global::numLayers; i++)
+       {
+               QListWidgetItem * qlwi = new QListWidgetItem();
+               LayerItemWidget * liw = new LayerItemWidget(Global::layerName[i].c_str(), Global::layerHidden[i], Global::layerLocked[i], qlwi);
+               list->insertItem(0, qlwi);
+               list->setItemWidget(qlwi, liw);
+
+               // Set up SIGNAL/SLOTs for this LayerItemWidget
+               connect(liw, SIGNAL(HideToggled(QListWidgetItem *, bool)), this, SLOT(HandleHideToggle(QListWidgetItem *, bool)));
+               connect(liw, SIGNAL(LockToggled(QListWidgetItem *, bool)), this, SLOT(HandleLockToggle(QListWidgetItem *, bool)));
+       }
+
+       int layer = (Global::numLayers - Global::activeLayer) - 1;
+       list->setCurrentRow(layer, QItemSelectionModel::SelectCurrent);
+       SetButtonStates();
+}
 
 void LayerWidget::HandleLayerSelected(int currentRow)
 {
-//printf("LayerWidget::HandleLayerSelected(): currentRow = %i\n", currentRow);
-//     emit(LayerSelected(currentRow));
+       // If LayerWidget is empty, bail out
+       if (currentRow == -1)
+               return;
 
-       QListWidgetItem * qlwi = list->item(currentRow);
-       LayerItemWidget * li = (LayerItemWidget *)list->itemWidget(qlwi);
-       Global::activeLayer = currentRow;
-       Global::layerIsLocked = li->editibility->isChecked();
+       // This is numbered opposite of how it's presented. In other words, the
+       // bottom of the list is 0, and items above it count upwards. So like this:
+       //
+       // (2) Layer #2
+       // (1) Layer #1
+       // (0) Background
+       //
+       // which is the opposite of the internal numbering.
+       Global::activeLayer = (Global::numLayers - currentRow) - 1;
 
        // Set button states to sane values
        SetButtonStates();
 }
 
+//
+// What happens here is that for every QListWidgetItem we make, we connect it
+// to these handlers. But we only have to worry about that when adding and
+// moving a layer. However, when toggling states, we need to toggle the global
+// state variables too.
+//
+void LayerWidget::HandleHideToggle(QListWidgetItem * qlwi, bool state)
+{
+       int currentRow = list->row(qlwi);
+       int layer = (Global::numLayers - currentRow) - 1;
+       std::vector<bool>::iterator i = Global::layerHidden.begin() + layer;
+       (*i) = state;
+//printf("Item #%i, new hide state is %s\n", currentRow, (state ? "ON" : "off"));
+//printf("LayerWidget: New hide state of layer %i is %s.\n", layer, (state ? "ON" : "off"));
+       // We do this last, because otherwise the Document would get the wrong state
+       emit LayerToggled();
+}
+
+void LayerWidget::HandleLockToggle(QListWidgetItem * qlwi, bool state)
+{
+       int currentRow = list->row(qlwi);
+       int layer = (Global::numLayers - currentRow) - 1;
+       std::vector<bool>::iterator i = Global::layerLocked.begin() + layer;
+       (*i) = state;
+//     printf("Item #%i, new lock state is %s\n", list->row(qlwi), (state ? "ON" : "off"));
+}
+
+void LayerWidget::HandleDblClick(QListWidgetItem * /*qlwi*/)
+{
+       EditLayer();
+}
 
 void LayerWidget::AddLayer(void)
 {
+       // We always stick the newest layer at the top of the list (visually, the
+       // top of the list is the end, the bottom is the beginning)...
        int count = list->count();
        QString text = QString("Layer #%1").arg(count);
-       LayerItemWidget * liw = new LayerItemWidget(text);
        QListWidgetItem * qlwi = new QListWidgetItem();
+       LayerItemWidget * liw = new LayerItemWidget(text, false, false, qlwi);
        list->insertItem(0, qlwi);
        list->setItemWidget(qlwi, liw);
 
+       // Set up SIGNAL/SLOTs for this LayerItemWidget
+       connect(liw, SIGNAL(HideToggled(QListWidgetItem *, bool)), this, SLOT(HandleHideToggle(QListWidgetItem *, bool)));
+       connect(liw, SIGNAL(LockToggled(QListWidgetItem *, bool)), this, SLOT(HandleLockToggle(QListWidgetItem *, bool)));
+
        SetButtonStates();
-}
 
+       // Fix up the global state
+       Global::layerHidden.push_back(false);
+       Global::layerLocked.push_back(false);
+       Global::layerName.push_back(text.toUtf8().data());
+       Global::numLayers++;
+}
 
 void LayerWidget::DeleteLayer(void)
 {
@@ -108,16 +183,32 @@ void LayerWidget::DeleteLayer(void)
        if (numItems == 1)
                return;
 
+       // N.B.: This *must* go before the item removal because that causes
+       //       HandleLayerSelected() to be fired off which causes the numbers to
+       //       be off. You have been warned!
+       // Tell the DrawingView to delete this layer in its Container:
+       emit LayerDeleted(Global::activeLayer);
+
+       int currentRow = list->currentRow();
        QListWidgetItem * qlwi = list->currentItem();
        list->removeItemWidget(qlwi);
        delete qlwi;
 
        SetButtonStates();
 
-       // N.B.: Also, we need to delete the layer in the Drawing as well!
+       // Fix up the global state
+       int layer = (Global::numLayers - currentRow) - 1;
+       Global::layerHidden.erase(Global::layerHidden.begin() + layer);
+       Global::layerLocked.erase(Global::layerLocked.begin() + layer);
+       Global::layerName.erase(Global::layerName.begin() + layer);
+       Global::numLayers--;
+
+       // If we're deleting from the top of the list, we have to decrement the
+       // active layer # by 1 (since we count upward from the bottom of the list).
+       if (currentRow == 0)
+               Global::activeLayer--;
 }
 
-
 void LayerWidget::EditLayer(void)
 {
        // Get the LayerItemWidget so we can edit it (its name, anyway)...
@@ -129,9 +220,16 @@ void LayerWidget::EditLayer(void)
        QString result = QInputDialog::getText(this, tr("Edit Layer Name"), tr("Layer Name:"), QLineEdit::Normal, s, &ok);
 
        if (ok && !result.isEmpty())
+       {
                li->name->setText(result);
-}
 
+               // We don't reverse the layer # here, like elsewhere, because we're
+               // using the layer # directly instead of having to translate it from
+               // the widget.
+               std::vector<std::string>::iterator i = Global::layerName.begin() + Global::activeLayer;
+               (*i) = result.toUtf8().data();
+       }
+}
 
 void LayerWidget::MoveLayerUp(void)
 {
@@ -140,17 +238,36 @@ void LayerWidget::MoveLayerUp(void)
        QListWidgetItem * qlwi = list->currentItem();
        LayerItemWidget * li = (LayerItemWidget *)list->itemWidget(qlwi);
        QString s = li->name->text();
-       bool visible = li->visibility->isChecked();
-       bool editible = li->editibility->isChecked();
+       bool visible = li->invisible->isChecked();
+       bool editible = li->locked->isChecked();
 
        // We have to make a new LayerItemWidget because it destroys the old one!
        list->takeItem(currentRow);
        list->insertItem(currentRow - 1, qlwi);
-       li = new LayerItemWidget(s, visible, editible);
+       li = new LayerItemWidget(s, visible, editible, qlwi);
        list->setItemWidget(qlwi, li);
        list->setCurrentItem(qlwi);
-}
 
+       // Set up SIGNAL/SLOTs for this LayerItemWidget
+       connect(li, SIGNAL(HideToggled(QListWidgetItem *, bool)), this, SLOT(HandleHideToggle(QListWidgetItem *, bool)));
+       connect(li, SIGNAL(LockToggled(QListWidgetItem *, bool)), this, SLOT(HandleLockToggle(QListWidgetItem *, bool)));
+
+       // Fix up the global state...
+       // N.B.: Because we handle the button states correctly, we should never
+       //       have a situation where the reference in the vector is bad.
+       int layer = (Global::numLayers - currentRow) - 1;
+       bool old = Global::layerHidden[layer];
+       Global::layerHidden[layer] = Global::layerHidden[layer + 1];
+       Global::layerHidden[layer + 1] = old;
+       old = Global::layerLocked[layer];
+       Global::layerLocked[layer] = Global::layerLocked[layer + 1];
+       Global::layerLocked[layer + 1] = old;
+       std::string oldStr = Global::layerName[layer];
+       Global::layerName[layer] = Global::layerName[layer + 1];
+       Global::layerName[layer + 1] = oldStr;
+       // We also have to tell the document to shuffle its layers too
+       emit LayersSwapped(layer, layer + 1);
+}
 
 void LayerWidget::MoveLayerDown(void)
 {
@@ -159,17 +276,36 @@ void LayerWidget::MoveLayerDown(void)
        QListWidgetItem * qlwi = list->currentItem();
        LayerItemWidget * li = (LayerItemWidget *)list->itemWidget(qlwi);
        QString s = li->name->text();
-       bool visible = li->visibility->isChecked();
-       bool editible = li->editibility->isChecked();
+       bool visible = li->invisible->isChecked();
+       bool editible = li->locked->isChecked();
 
        // We have to make a new LayerItemWidget because it destroys the old one!
        list->takeItem(currentRow);
        list->insertItem(currentRow + 1, qlwi);
-       li = new LayerItemWidget(s, visible, editible);
+       li = new LayerItemWidget(s, visible, editible, qlwi);
        list->setItemWidget(qlwi, li);
        list->setCurrentItem(qlwi);
-}
 
+       // Set up SIGNAL/SLOTs for this LayerItemWidget
+       connect(li, SIGNAL(HideToggled(QListWidgetItem *, bool)), this, SLOT(HandleHideToggle(QListWidgetItem *, bool)));
+       connect(li, SIGNAL(LockToggled(QListWidgetItem *, bool)), this, SLOT(HandleLockToggle(QListWidgetItem *, bool)));
+
+       // Fix up the global state...
+       // N.B.: Because we handle the button states correctly, we should never
+       //       have a situation where the reference in the vector is bad.
+       int layer = (Global::numLayers - currentRow) - 1;
+       bool old = Global::layerHidden[layer];
+       Global::layerHidden[layer] = Global::layerHidden[layer - 1];
+       Global::layerHidden[layer - 1] = old;
+       old = Global::layerLocked[layer];
+       Global::layerLocked[layer] = Global::layerLocked[layer - 1];
+       Global::layerLocked[layer - 1] = old;
+       std::string oldStr = Global::layerName[layer];
+       Global::layerName[layer] = Global::layerName[layer - 1];
+       Global::layerName[layer - 1] = oldStr;
+       // We also have to tell the document to shuffle its layers too
+       emit LayersSwapped(layer, layer - 1);
+}
 
 //
 // Set button states in this widget to sane values
@@ -183,4 +319,3 @@ void LayerWidget::SetButtonStates(void)
        layerUp->setEnabled(currentRow == 0 ? false : true);
        removeLayer->setEnabled(numItems == 1 ? false : true);
 }
-