X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flayerwidget.cpp;h=9ac85a87379fab084125300448db2f32ccb2429a;hb=ff2a28347dc30eccc28e7cd7298cccde7aa49d2c;hp=faaf5b999854423f546b39724f854e7419900fa3;hpb=ea7712f342020baf61cf33ba98b12140da6aecf7;p=architektonas diff --git a/src/layerwidget.cpp b/src/layerwidget.cpp index faaf5b9..9ac85a8 100644 --- a/src/layerwidget.cpp +++ b/src/layerwidget.cpp @@ -21,16 +21,10 @@ LayerWidget::LayerWidget(void): QWidget(), 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,13 +52,25 @@ 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::layerHidden.push_back(false); + Global::layerLocked.push_back(false); } @@ -78,26 +84,76 @@ void LayerWidget::HandleLayerSelected(int currentRow) //printf("LayerWidget::HandleLayerSelected(): currentRow = %i\n", currentRow); // emit(LayerSelected(currentRow)); - 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; +//printf("LayerWidget::HandleLayerSelected(): currentRow = %i, numLayers = %i, active = %i\n", currentRow, Global::numLayers, Global::activeLayer); // 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::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::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... 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.insert(Global::layerHidden.begin(), false); + Global::layerLocked.insert(Global::layerLocked.begin(), false); + Global::numLayers++; } @@ -108,13 +164,29 @@ 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::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--; } @@ -140,15 +212,32 @@ 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; + // We also have to tell the document to shuffle its layers too + emit(LayersSwapped(layer, layer + 1)); } @@ -159,15 +248,32 @@ 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; + // We also have to tell the document to shuffle its layers too + emit(LayersSwapped(layer, layer - 1)); }