Shamusworld >> Repos - architektonas/blob - src/layerwidget.cpp

   1 // layerwidget.cpp: Layer add/remove/use widget
   2 //
   3 // Part of the Architektonas Project
   4 // (C) 2011 Underground Software
   5 // See the README and GPLv3 files for licensing and warranty information
   6 //
   7 // JLH = James Hammons <jlhamm@acm.org>
   8 //
   9 // WHO  WHEN        WHAT
  10 // ---  ----------  ------------------------------------------------------------
  11 // JLH  07/11/2013  Created this file
  12 //
  13
  14 #include "layerwidget.h"
  15 #include "global.h"
  16 #include "layeritemwidget.h"
  17
  18
  19 LayerWidget::LayerWidget(void): QWidget(),
  20         addLayer(new QToolButton), removeLayer(new QToolButton),
  21         editLayer(new QToolButton), layerUp(new QToolButton),
  22         layerDown(new QToolButton), list(new QListWidget)
  23 {
  24         QListWidgetItem * qlwi = new QListWidgetItem(list);
  25         LayerItemWidget * liw = new LayerItemWidget("Background", false, false, qlwi);
  26         list->setItemWidget(qlwi, liw);
  27
  28         addLayer->setIcon(QIcon(":/res/layer-add.png"));
  29         removeLayer->setIcon(QIcon(":/res/layer-delete.png"));
  30         editLayer->setIcon(QIcon(":/res/layer-edit.png"));
  31         layerUp->setIcon(QIcon(":/res/layer-up.png"));
  32         layerDown->setIcon(QIcon(":/res/layer-down.png"));
  33
  34         addLayer->setToolTip(tr("Add layer"));
  35         removeLayer->setToolTip(tr("Remove layer"));
  36         editLayer->setToolTip(tr("Edit layer"));
  37         layerUp->setToolTip(tr("Move layer up"));
  38         layerDown->setToolTip(tr("Move layer down"));
  39
  40         QHBoxLayout * hbox1 = new QHBoxLayout;
  41         hbox1->addWidget(addLayer);
  42         hbox1->addWidget(removeLayer);
  43         hbox1->addWidget(editLayer);
  44         hbox1->addWidget(layerUp);
  45         hbox1->addWidget(layerDown);
  46         hbox1->addStretch();
  47
  48         QVBoxLayout * mainLayout = new QVBoxLayout;
  49         mainLayout->addWidget(list);
  50         mainLayout->addLayout(hbox1);
  51
  52         setLayout(mainLayout);
  53
  54         connect(list, SIGNAL(currentRowChanged(int)), this, SLOT(HandleLayerSelected(int)));
  55         connect(list, SIGNAL(itemDoubleClicked(QListWidgetItem *)), this, SLOT(HandleDblClick(QListWidgetItem *)));
  56         connect(addLayer, SIGNAL(clicked()), this, SLOT(AddLayer()));
  57         connect(removeLayer, SIGNAL(clicked()), this, SLOT(DeleteLayer()));
  58         connect(editLayer, SIGNAL(clicked()), this, SLOT(EditLayer()));
  59         connect(layerUp, SIGNAL(clicked()), this, SLOT(MoveLayerUp()));
  60         connect(layerDown, SIGNAL(clicked()), this, SLOT(MoveLayerDown()));
  61
  62         connect(liw, SIGNAL(HideToggled(QListWidgetItem *, bool)), this, SLOT(HandleHideToggle(QListWidgetItem *, bool)));
  63         connect(liw, SIGNAL(LockToggled(QListWidgetItem *, bool)), this, SLOT(HandleLockToggle(QListWidgetItem *, bool)));
  64
  65         list->setCurrentRow(0);
  66
  67         // We set global variables here, since we are 'in charge' of them (mostly)
  68         Global::activeLayer = 0;
  69         Global::numLayers = 1;
  70         Global::layerHidden.clear();
  71         Global::layerLocked.clear();
  72         Global::layerHidden.push_back(false);
  73         Global::layerLocked.push_back(false);
  74 }
  75
  76
  77 LayerWidget::~LayerWidget()
  78 {
  79 }
  80
  81
  82 void LayerWidget::HandleLayerSelected(int currentRow)
  83 {
  84 //printf("LayerWidget::HandleLayerSelected(): currentRow = %i\n", currentRow);
  85 //      emit(LayerSelected(currentRow));
  86
  87         // This is numbered opposite of how it's presented. In other words, the
  88         // bottom of the list is 0, and items above it count upwards. So like this:
  89         //
  90         // (2) Layer #2
  91         // (1) Layer #1
  92         // (0) Background
  93         //
  94         // which is the opposite of the internal numbering.
  95         Global::activeLayer = (Global::numLayers - currentRow) - 1;
  96 //printf("LayerWidget::HandleLayerSelected(): currentRow = %i, numLayers = %i, active = %i\n", currentRow, Global::numLayers, Global::activeLayer);
  97         // Set button states to sane values
  98         SetButtonStates();
  99 }
 100
 101
 102 //
 103 // What happens here is that for every QListWidgetItem we make, we connect it
 104 // to these handlers. But we only have to worry about that when adding and
 105 // moving a layer. However, when toggling states, we need to toggle the global
 106 // state variables too.
 107 //
 108 void LayerWidget::HandleHideToggle(QListWidgetItem * qlwi, bool state)
 109 {
 110         int currentRow = list->row(qlwi);
 111         int layer = (Global::numLayers - currentRow) - 1;
 112         std::vector<bool>::iterator i = Global::layerHidden.begin() + layer;
 113         (*i) = state;
 114 //printf("Item #%i, new hide state is %s\n", currentRow, (state ? "ON" : "off"));
 115 //printf("LayerWidget: New hide state of layer %i is %s.\n", layer, (state ? "ON" : "off"));
 116         // We do this last, because otherwise the Document would get the wrong state
 117         emit(LayerToggled());
 118 }
 119
 120
 121 void LayerWidget::HandleLockToggle(QListWidgetItem * qlwi, bool state)
 122 {
 123         int currentRow = list->row(qlwi);
 124         int layer = (Global::numLayers - currentRow) - 1;
 125         std::vector<bool>::iterator i = Global::layerLocked.begin() + layer;
 126         (*i) = state;
 127 //      printf("Item #%i, new lock state is %s\n", list->row(qlwi), (state ? "ON" : "off"));
 128 }
 129
 130
 131 void LayerWidget::HandleDblClick(QListWidgetItem * /*qlwi*/)
 132 {
 133         EditLayer();
 134 }
 135
 136
 137 void LayerWidget::AddLayer(void)
 138 {
 139         // We always stick the newest layer at the top of the list...
 140         int count = list->count();
 141         QString text = QString("Layer #%1").arg(count);
 142         QListWidgetItem * qlwi = new QListWidgetItem();
 143         LayerItemWidget * liw = new LayerItemWidget(text, false, false, qlwi);
 144         list->insertItem(0, qlwi);
 145         list->setItemWidget(qlwi, liw);
 146
 147         // Set up SIGNAL/SLOTs for this LayerItemWidget
 148         connect(liw, SIGNAL(HideToggled(QListWidgetItem *, bool)), this, SLOT(HandleHideToggle(QListWidgetItem *, bool)));
 149         connect(liw, SIGNAL(LockToggled(QListWidgetItem *, bool)), this, SLOT(HandleLockToggle(QListWidgetItem *, bool)));
 150
 151         SetButtonStates();
 152
 153         // Fix up the global state
 154         Global::layerHidden.insert(Global::layerHidden.begin(), false);
 155         Global::layerLocked.insert(Global::layerLocked.begin(), false);
 156         Global::numLayers++;
 157 }
 158
 159
 160 void LayerWidget::DeleteLayer(void)
 161 {
 162         int numItems = list->count();
 163
 164         if (numItems == 1)
 165                 return;
 166
 167         // N.B.: This *must* go before the item removal because that causes
 168         //       HandleLayerSelected() to be fired off which causes the numbers to
 169         //       be off. You have been warned!
 170         // Tell the DrawingView to delete this layer in its Container:
 171         emit(LayerDeleted(Global::activeLayer));
 172
 173         int currentRow = list->currentRow();
 174         QListWidgetItem * qlwi = list->currentItem();
 175         list->removeItemWidget(qlwi);
 176         delete qlwi;
 177
 178         SetButtonStates();
 179
 180         // Fix up the global state
 181         int layer = (Global::numLayers - currentRow) - 1;
 182         Global::layerHidden.erase(Global::layerHidden.begin() + layer);
 183         Global::layerLocked.erase(Global::layerLocked.begin() + layer);
 184         Global::numLayers--;
 185
 186         // If we're deleting from the top of the list, we have to decrement the
 187         // active layer # by 1 (since we count upward from the bottom of the list).
 188         if (currentRow == 0)
 189                 Global::activeLayer--;
 190 }
 191
 192
 193 void LayerWidget::EditLayer(void)
 194 {
 195         // Get the LayerItemWidget so we can edit it (its name, anyway)...
 196         QListWidgetItem * qlwi = list->currentItem();
 197         LayerItemWidget * li = (LayerItemWidget *)list->itemWidget(qlwi);
 198         QString s = li->name->text();
 199
 200         bool ok;
 201         QString result = QInputDialog::getText(this, tr("Edit Layer Name"), tr("Layer Name:"), QLineEdit::Normal, s, &ok);
 202
 203         if (ok && !result.isEmpty())
 204                 li->name->setText(result);
 205 }
 206
 207
 208 void LayerWidget::MoveLayerUp(void)
 209 {
 210         // Get information out of the LayerItemWidget (& get it from the list!)
 211         int currentRow = list->currentRow();
 212         QListWidgetItem * qlwi = list->currentItem();
 213         LayerItemWidget * li = (LayerItemWidget *)list->itemWidget(qlwi);
 214         QString s = li->name->text();
 215         bool visible = li->invisible->isChecked();
 216         bool editible = li->locked->isChecked();
 217
 218         // We have to make a new LayerItemWidget because it destroys the old one!
 219         list->takeItem(currentRow);
 220         list->insertItem(currentRow - 1, qlwi);
 221         li = new LayerItemWidget(s, visible, editible, qlwi);
 222         list->setItemWidget(qlwi, li);
 223         list->setCurrentItem(qlwi);
 224
 225         // Set up SIGNAL/SLOTs for this LayerItemWidget
 226         connect(li, SIGNAL(HideToggled(QListWidgetItem *, bool)), this, SLOT(HandleHideToggle(QListWidgetItem *, bool)));
 227         connect(li, SIGNAL(LockToggled(QListWidgetItem *, bool)), this, SLOT(HandleLockToggle(QListWidgetItem *, bool)));
 228
 229         // Fix up the global state...
 230         // N.B.: Because we handle the button states correctly, we should never
 231         //       have a situation where the reference in the vector is bad.
 232         int layer = (Global::numLayers - currentRow) - 1;
 233         bool old = Global::layerHidden[layer];
 234         Global::layerHidden[layer] = Global::layerHidden[layer + 1];
 235         Global::layerHidden[layer + 1] = old;
 236         old = Global::layerLocked[layer];
 237         Global::layerLocked[layer] = Global::layerLocked[layer + 1];
 238         Global::layerLocked[layer + 1] = old;
 239         // We also have to tell the document to shuffle its layers too
 240         emit(LayersSwapped(layer, layer + 1));
 241 }
 242
 243
 244 void LayerWidget::MoveLayerDown(void)
 245 {
 246         // Get information out of the LayerItemWidget (& get it from the list!)
 247         int currentRow = list->currentRow();
 248         QListWidgetItem * qlwi = list->currentItem();
 249         LayerItemWidget * li = (LayerItemWidget *)list->itemWidget(qlwi);
 250         QString s = li->name->text();
 251         bool visible = li->invisible->isChecked();
 252         bool editible = li->locked->isChecked();
 253
 254         // We have to make a new LayerItemWidget because it destroys the old one!
 255         list->takeItem(currentRow);
 256         list->insertItem(currentRow + 1, qlwi);
 257         li = new LayerItemWidget(s, visible, editible, qlwi);
 258         list->setItemWidget(qlwi, li);
 259         list->setCurrentItem(qlwi);
 260
 261         // Set up SIGNAL/SLOTs for this LayerItemWidget
 262         connect(li, SIGNAL(HideToggled(QListWidgetItem *, bool)), this, SLOT(HandleHideToggle(QListWidgetItem *, bool)));
 263         connect(li, SIGNAL(LockToggled(QListWidgetItem *, bool)), this, SLOT(HandleLockToggle(QListWidgetItem *, bool)));
 264
 265         // Fix up the global state...
 266         // N.B.: Because we handle the button states correctly, we should never
 267         //       have a situation where the reference in the vector is bad.
 268         int layer = (Global::numLayers - currentRow) - 1;
 269         bool old = Global::layerHidden[layer];
 270         Global::layerHidden[layer] = Global::layerHidden[layer - 1];
 271         Global::layerHidden[layer - 1] = old;
 272         old = Global::layerLocked[layer];
 273         Global::layerLocked[layer] = Global::layerLocked[layer - 1];
 274         Global::layerLocked[layer - 1] = old;
 275         // We also have to tell the document to shuffle its layers too
 276         emit(LayersSwapped(layer, layer - 1));
 277 }
 278
 279
 280 //
 281 // Set button states in this widget to sane values
 282 //
 283 void LayerWidget::SetButtonStates(void)
 284 {
 285         int numItems = list->count();
 286         int currentRow = list->currentRow();
 287
 288         layerDown->setEnabled(currentRow == (numItems - 1) ? false : true);
 289         layerUp->setEnabled(currentRow == 0 ? false : true);
 290         removeLayer->setEnabled(numItems == 1 ? false : true);
 291 }
 292