void TilesetDock::deleteTilesetView(int index)
{
TilesetDocument *tilesetDocument = mTilesetDocuments.at(index);
tilesetDocument->disconnect(this);
Tileset *tileset = tilesetDocument->tileset().data();
TilesetView *view = tilesetViewAt(index);
QString path = QLatin1String("TilesetDock/TilesetScale/") + tileset->name();
QSettings *settings = Preferences::instance()->settings();
if (view->scale() != 1.0)
settings->setValue(path, view->scale());
else
settings->remove(path);
mTilesets.remove(index);
mTilesetDocuments.removeAt(index);
delete view; // view needs to go before the tab
mTabBar->removeTab(index);
// Make sure we don't reference this tileset anymore
if (mCurrentTiles && mCurrentTiles->referencesTileset(tileset)) {
TileLayer *cleaned = mCurrentTiles->clone();
cleaned->removeReferencesToTileset(tileset);
setCurrentTiles(cleaned);
}
if (mCurrentTile && mCurrentTile->tileset() == tileset)
setCurrentTile(nullptr);
}
void TilesetDock::updateActions()
{
bool external = false;
TilesetView *view = nullptr;
Tileset *tileset = nullptr;
const int index = mTabBar->currentIndex();
if (index > -1) {
view = tilesetViewAt(index);
tileset = mTilesets.at(index).data();
if (view) {
if (!view->model()) // Lazily set up the model
setupTilesetModel(view, tileset);
mViewStack->setCurrentIndex(index);
external = tileset->isExternal();
}
}
const bool tilesetIsDisplayed = view != nullptr;
const auto map = mMapDocument ? mMapDocument->map() : nullptr;
mEmbedTileset->setEnabled(tilesetIsDisplayed && external);
mExportTileset->setEnabled(tilesetIsDisplayed && !external);
mEditTileset->setEnabled(tilesetIsDisplayed);
mDeleteTileset->setEnabled(tilesetIsDisplayed && map && contains(map->tilesets(), tileset));
}
void TilesetDock::createTilesetView(int index, TilesetDocument *tilesetDocument)
{
auto tileset = tilesetDocument->tileset();
mTilesets.insert(index, tileset);
mTilesetDocuments.insert(index, tilesetDocument);
TilesetView *view = new TilesetView;
view->setZoomable(mZoomable);
// Insert view before the tab to make sure it is there when the tab index
// changes (happens when first tab is inserted).
mViewStack->insertWidget(index, view);
mTabBar->insertTab(index, tileset->name());
connect(tilesetDocument, &TilesetDocument::tilesetNameChanged,
this, &TilesetDock::tilesetNameChanged);
connect(tilesetDocument, &TilesetDocument::fileNameChanged,
this, &TilesetDock::updateActions);
connect(tilesetDocument, &TilesetDocument::tilesetChanged,
this, &TilesetDock::tilesetChanged);
connect(tilesetDocument, &TilesetDocument::tileImageSourceChanged,
this, &TilesetDock::tileImageSourceChanged);
connect(tilesetDocument, &TilesetDocument::tileAnimationChanged,
this, &TilesetDock::tileAnimationChanged);
}
/**
* Synchronizes the selection with the given stamp. Ignored when the stamp is
* changing because of a selection change in the TilesetDock.
*/
void TilesetDock::selectTilesInStamp(const TileStamp &stamp)
{
if (mEmittingStampCaptured)
return;
QSet<Tile*> processed;
QMap<QItemSelectionModel*, QItemSelection> selections;
for (const TileStampVariation &variation : stamp.variations()) {
const TileLayer &tileLayer = *variation.tileLayer();
for (const Cell &cell : tileLayer) {
if (Tile *tile = cell.tile) {
if (processed.contains(tile))
continue;
processed.insert(tile); // avoid spending time on duplicates
Tileset *tileset = tile->tileset();
int tilesetIndex = mTilesets.indexOf(tileset->sharedPointer());
if (tilesetIndex != -1) {
TilesetView *view = tilesetViewAt(tilesetIndex);
if (!view->model()) // Lazily set up the model
setupTilesetModel(view, tileset);
const TilesetModel *model = view->tilesetModel();
const QModelIndex modelIndex = model->tileIndex(tile);
QItemSelectionModel *selectionModel = view->selectionModel();
selections[selectionModel].select(modelIndex, modelIndex);
}
}
}
}
if (!selections.isEmpty()) {
mSynchronizingSelection = true;
// Mark captured tiles as selected
for (auto i = selections.constBegin(); i != selections.constEnd(); ++i) {
QItemSelectionModel *selectionModel = i.key();
const QItemSelection &selection = i.value();
selectionModel->select(selection, QItemSelectionModel::SelectCurrent);
}
// Show/edit properties of all captured tiles
mMapDocument->setSelectedTiles(processed.toList());
// Update the current tile (useful for animation and collision editors)
auto first = selections.begin();
QItemSelectionModel *selectionModel = first.key();
const QItemSelection &selection = first.value();
const QModelIndex currentIndex = selection.first().topLeft();
if (selectionModel->currentIndex() != currentIndex)
selectionModel->setCurrentIndex(currentIndex, QItemSelectionModel::NoUpdate);
else
currentChanged(currentIndex);
mSynchronizingSelection = false;
}
}
void TilesetEditor::currentWangSetChanged(WangSet *wangSet)
{
TilesetView *view = currentTilesetView();
if (!view)
return;
view->setWangSet(wangSet);
}
void TilesetEditor::currentWangIdChanged(WangId wangId)
{
TilesetView *view = currentTilesetView();
if (!view)
return;
view->setWangId(wangId);
}
void TilesetDock::tileImageSourceChanged(Tile *tile)
{
int tilesetIndex = mTilesets.indexOf(tile->tileset()->sharedPointer());
if (tilesetIndex != -1) {
TilesetView *view = tilesetViewAt(tilesetIndex);
if (TilesetModel *model = view->tilesetModel())
model->tileChanged(tile);
}
}
void TilesetEditor::wangColorChanged(int color, bool edge)
{
TilesetView *view = currentTilesetView();
if (!view)
return;
if (edge)
view->setWangEdgeColor(color);
else
view->setWangCornerColor(color);
}
void BrushState::OnTilesetViewRender() {
TilesetView* tsv = GetExecutor()->GetTilesetView();
Tileset* ts = GetExecutor()->GetTileset();
int tileWidth = ts->Width() + (tsv->IsPadded() ? 1 : 0);
int tileHeight = ts->Height() + (tsv->IsPadded() ? 1 : 0);
Rect selected = tsv->GetBrushSelection();
int ywin = tsv->GetYWin();
tsv->DrawSelectRect(selected.left * tileWidth, selected.top * tileHeight - ywin, tileWidth * (selected.Width() + 1), tileHeight * (selected.Height() + 1), RGBA(127, 255, 255));
}
TileSet* TilesetDock::getSelectedTileset() {
TilesetView *currentView;
TilesetScene *currentScene;
currentView = (TilesetView*) tabWidget->currentWidget();
if(currentView == NULL) return NULL;
currentScene = (TilesetScene*) currentView->scene();
return currentScene->tileSet;
}
void TilesetDock::insertTilesetView(int index, Tileset *tileset)
{
TilesetView *view = new TilesetView(mMapDocument);
view->setModel(new TilesetModel(tileset, view));
connect(view->selectionModel(),
SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
SLOT(updateCurrentTiles()));
mTabBar->insertTab(index, tileset->name());
mViewStack->insertWidget(index, view);
}
void TilesetDock::removeTiles()
{
TilesetView *view = currentTilesetView();
if (!view)
return;
if (!view->selectionModel()->hasSelection())
return;
const QModelIndexList indexes = view->selectionModel()->selectedIndexes();
const TilesetModel *model = view->tilesetModel();
QList<Tile*> tiles;
for (const QModelIndex &index : indexes)
if (Tile *tile = model->tileAt(index))
tiles.append(tile);
auto matchesAnyTile = [&tiles] (const Cell &cell) {
if (Tile *tile = cell.tile)
return tiles.contains(tile);
return false;
};
const bool inUse = hasTileReferences(mMapDocument, matchesAnyTile);
// If the tileset is in use, warn the user and confirm removal
if (inUse) {
QMessageBox warning(QMessageBox::Warning,
tr("Remove Tiles"),
tr("One or more of the tiles to be removed are "
"still in use by the map!"),
QMessageBox::Yes | QMessageBox::No,
this);
warning.setDefaultButton(QMessageBox::Yes);
warning.setInformativeText(tr("Remove all references to these tiles?"));
if (warning.exec() != QMessageBox::Yes)
return;
}
QUndoStack *undoStack = mMapDocument->undoStack();
undoStack->beginMacro(tr("Remove Tiles"));
if (inUse)
removeTileReferences(mMapDocument, matchesAnyTile);
Tileset *tileset = view->tilesetModel()->tileset();
undoStack->push(new RemoveTiles(mMapDocument, tileset, tiles));
undoStack->endMacro();
// Clear the current tiles, will be referencing the removed tiles
setCurrentTiles(nullptr);
setCurrentTile(nullptr);
}
void TilesetDock::tilesetAdded(int index, Tileset *tileset)
{
TilesetView *view = new TilesetView;
view->setMapDocument(mMapDocument);
view->setZoomable(mZoomable);
mTilesets.insert(index, tileset->sharedPointer());
mTabBar->insertTab(index, tileset->name());
mViewStack->insertWidget(index, view);
updateActions();
}
void TilesetEditor::currentTerrainChanged(const Terrain *terrain)
{
TilesetView *view = currentTilesetView();
if (!view)
return;
if (terrain) {
view->setTerrain(terrain);
view->setEraseTerrain(false);
} else {
view->setEraseTerrain(true);
}
}
void TilesetDock::tilesetChanged(Tileset *tileset)
{
// Update the affected tileset model, if it exists
const int index = indexOf(mTilesets, tileset);
if (index < 0)
return;
TilesetView *view = tilesetViewAt(index);
if (TilesetModel *model = view->tilesetModel()) {
view->updateBackgroundColor();
model->tilesetChanged();
}
}
void TilesetEditor::removeTiles()
{
TilesetView *view = currentTilesetView();
if (!view)
return;
if (!view->selectionModel()->hasSelection())
return;
const QModelIndexList indexes = view->selectionModel()->selectedIndexes();
const TilesetModel *model = view->tilesetModel();
QList<Tile*> tiles;
for (const QModelIndex &index : indexes)
if (Tile *tile = model->tileAt(index))
tiles.append(tile);
auto matchesAnyTile = [&tiles] (const Cell &cell) {
if (Tile *tile = cell.tile())
return tiles.contains(tile);
return false;
};
QList<MapDocument *> mapsUsingTiles;
for (MapDocument *mapDocument : mCurrentTilesetDocument->mapDocuments())
if (hasTileReferences(mapDocument, matchesAnyTile))
mapsUsingTiles.append(mapDocument);
// If the tileset is in use, warn the user and confirm removal
if (!mapsUsingTiles.isEmpty()) {
QMessageBox warning(QMessageBox::Warning,
tr("Remove Tiles"),
tr("Tiles to be removed are in use by open maps!"),
QMessageBox::Yes | QMessageBox::No,
mMainWindow->window());
warning.setDefaultButton(QMessageBox::Yes);
warning.setInformativeText(tr("Remove all references to these tiles?"));
if (warning.exec() != QMessageBox::Yes)
return;
}
for (MapDocument *mapDocument : mapsUsingTiles)
removeTileReferences(mapDocument, matchesAnyTile);
mCurrentTilesetDocument->undoStack()->push(new RemoveTiles(mCurrentTilesetDocument, tiles));
// todo: make sure any current brushes are no longer referring to removed tiles
setCurrentTile(nullptr);
}
void TilesetDock::insertTilesetView(int index, Tileset *tileset)
{
TilesetView *view = new TilesetView(mMapDocument);
view->setModel(new TilesetModel(tileset, view));
connect(view->selectionModel(),
SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
SLOT(updateCurrentTiles()));
mViewStack->insertWidget(index, view);
QVariant userdata = QVariant::fromValue(view);
mDropDown->addItem(tileset->name(), userdata);
mDropDown->model()->sort(0);
mDropDown->setCurrentIndex(mDropDown->findData(userdata));
}
void TilesetDock::insertTilesetView(int index, Tileset *tileset)
{
TilesetView *view = new TilesetView(mMapDocument);
view->setModel(new TilesetModel(tileset, view));
connect(view->selectionModel(),
SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
SLOT(updateCurrentTiles()));
connect(view, SIGNAL(deleteRequested(TilesetView*)),
SLOT(deleteRequested(TilesetView*)));
mViewStack->insertWidget(index, view);
mDropDown->insertItem(index, QIcon(), tileset->name());
mDropDown->setCurrentIndex(index);
}
void TilesetDock::updateActions()
{
bool external = false;
TilesetView *view = 0;
const int index = mTabBar->currentIndex();
if (index > -1) {
view = tilesetViewAt(index);
if (view) {
mViewStack->setCurrentWidget(view);
external = view->tilesetModel()->tileset()->isExternal();
}
}
mRenameTileset->setEnabled(view && !external);
mImportTileset->setEnabled(view && external);
mExportTileset->setEnabled(view && !external);
mPropertiesTileset->setEnabled(view && !external);
mDeleteTileset->setEnabled(view);
}
void TilesetDock::updateCurrentTiles()
{
TilesetView *view = currentTilesetView();
if (!view)
return;
const QItemSelectionModel *s = view->selectionModel();
if (!s)
return;
const QModelIndexList indexes = s->selection().indexes();
if (indexes.isEmpty())
return;
const QModelIndex &first = indexes.first();
int minX = first.column();
int maxX = first.column();
int minY = first.row();
int maxY = first.row();
for (const QModelIndex &index : indexes) {
if (minX > index.column()) minX = index.column();
if (maxX < index.column()) maxX = index.column();
if (minY > index.row()) minY = index.row();
if (maxY < index.row()) maxY = index.row();
}
// Create a tile layer from the current selection
TileLayer *tileLayer = new TileLayer(QString(), 0, 0,
maxX - minX + 1,
maxY - minY + 1);
const TilesetModel *model = view->tilesetModel();
for (const QModelIndex &index : indexes) {
tileLayer->setCell(index.column() - minX,
index.row() - minY,
Cell(model->tileAt(index)));
}
setCurrentTiles(tileLayer);
}
void TilesetEditor::selectionChanged()
{
TilesetView *view = currentTilesetView();
if (!view)
return;
updateAddRemoveActions();
const QItemSelectionModel *s = view->selectionModel();
const QModelIndexList indexes = s->selection().indexes();
if (indexes.isEmpty())
return;
const TilesetModel *model = view->tilesetModel();
QList<Tile*> selectedTiles;
for (const QModelIndex &index : indexes)
if (Tile *tile = model->tileAt(index))
selectedTiles.append(tile);
mCurrentTilesetDocument->setSelectedTiles(selectedTiles);
}
void TilesetEditor::removeDocument(Document *document)
{
TilesetDocument *tilesetDocument = qobject_cast<TilesetDocument*>(document);
Q_ASSERT(tilesetDocument);
Q_ASSERT(mViewForTileset.contains(tilesetDocument));
tilesetDocument->disconnect(this);
TilesetView *view = mViewForTileset.take(tilesetDocument);
QString path = QLatin1String("TilesetEditor/TilesetScale/") +
tilesetDocument->tileset()->name();
QSettings *settings = Preferences::instance()->settings();
if (view->scale() != 1.0)
settings->setValue(path, view->scale());
else
settings->remove(path);
// remove first, to keep it valid while the current widget changes
mWidgetStack->removeWidget(view);
delete view;
}
void TilesetDock::createTilesetView(int index, TilesetDocument *tilesetDocument)
{
auto tileset = tilesetDocument->tileset();
mTilesets.insert(index, tileset);
mTilesetDocuments.insert(index, tilesetDocument);
TilesetView *view = new TilesetView;
// Insert view before the tab to make sure it is there when the tab index
// changes (happens when first tab is inserted).
mViewStack->insertWidget(index, view);
mTabBar->insertTab(index, tileset->name());
mTabBar->setTabToolTip(index, tileset->fileName());
QString path = QLatin1String("TilesetDock/TilesetScale/") + tileset->name();
qreal scale = Preferences::instance()->settings()->value(path, 1).toReal();
view->zoomable()->setScale(scale);
connect(tilesetDocument, &TilesetDocument::tilesetNameChanged,
this, &TilesetDock::tilesetNameChanged);
connect(tilesetDocument, &TilesetDocument::fileNameChanged,
this, &TilesetDock::tilesetFileNameChanged);
connect(tilesetDocument, &TilesetDocument::tilesetChanged,
this, &TilesetDock::tilesetChanged);
connect(tilesetDocument, &TilesetDocument::tileImageSourceChanged,
this, &TilesetDock::tileImageSourceChanged);
connect(tilesetDocument, &TilesetDocument::tileAnimationChanged,
this, &TilesetDock::tileAnimationChanged);
connect(view, &TilesetView::clicked,
this, &TilesetDock::updateCurrentTiles);
connect(view, &TilesetView::swapTilesRequested,
this, &TilesetDock::swapTiles);
connect(view, &TilesetView::changeSelectedMapObjectsTileRequested,
this, &TilesetDock::changeSelectedMapObjectsTile);
}
void TilesetEditor::setCurrentDocument(Document *document)
{
TilesetDocument *tilesetDocument = qobject_cast<TilesetDocument*>(document);
Q_ASSERT(tilesetDocument || !document);
if (mCurrentTilesetDocument == tilesetDocument)
return;
TilesetView *tilesetView = nullptr;
if (document) {
tilesetView = mViewForTileset.value(tilesetDocument);
Q_ASSERT(tilesetView);
mWidgetStack->setCurrentWidget(tilesetView);
tilesetView->setEditTerrain(mTerrainDock->isVisible());
tilesetView->setEditWangSet(mWangDock->isVisible());
tilesetView->zoomable()->setComboBox(mZoomComboBox);
}
mPropertiesDock->setDocument(document);
mUndoDock->setStack(document ? document->undoStack() : nullptr);
mTileAnimationEditor->setTilesetDocument(tilesetDocument);
mTileCollisionDock->setTilesetDocument(tilesetDocument);
mTerrainDock->setDocument(document);
mWangDock->setDocument(document);
mCurrentTilesetDocument = tilesetDocument;
if (tilesetDocument) {
currentChanged(tilesetView->currentIndex());
selectionChanged();
}
updateAddRemoveActions();
}
void TilesetDock::updateActions()
{
bool external = false;
bool isCollection = false;
bool hasSelection = false;
TilesetView *view = nullptr;
const int index = mTabBar->currentIndex();
if (index > -1) {
view = tilesetViewAt(index);
if (view) {
Tileset *tileset = mTilesets.at(index).data();
if (!view->model()) // Lazily set up the model
setupTilesetModel(view, tileset);
mViewStack->setCurrentIndex(index);
external = tileset->isExternal();
isCollection = tileset->isCollection();
hasSelection = view->selectionModel()->hasSelection();
}
}
const bool tilesetIsDisplayed = view != nullptr;
const bool mapIsDisplayed = mMapDocument != nullptr;
mNewTileset->setEnabled(mapIsDisplayed);
mImportTileset->setEnabled(tilesetIsDisplayed && external);
mExportTileset->setEnabled(tilesetIsDisplayed && !external);
mPropertiesTileset->setEnabled(tilesetIsDisplayed);
mDeleteTileset->setEnabled(tilesetIsDisplayed);
mEditTerrain->setEnabled(tilesetIsDisplayed && !external);
mAddTiles->setEnabled(tilesetIsDisplayed && isCollection && !external);
mRemoveTiles->setEnabled(tilesetIsDisplayed && isCollection
&& hasSelection && !external);
}
void TilesetEditor::addDocument(Document *document)
{
TilesetDocument *tilesetDocument = qobject_cast<TilesetDocument*>(document);
Q_ASSERT(tilesetDocument);
TilesetView *view = new TilesetView(mWidgetStack);
view->setTilesetDocument(tilesetDocument);
Tileset *tileset = tilesetDocument->tileset().data();
QString path = QLatin1String("TilesetEditor/TilesetScale/") + tileset->name();
qreal scale = Preferences::instance()->settings()->value(path, 1).toReal();
view->zoomable()->setScale(scale);
view->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
TilesetModel *tilesetModel = new TilesetModel(tileset, view);
view->setModel(tilesetModel);
connect(tilesetDocument, &TilesetDocument::tileTerrainChanged,
tilesetModel, &TilesetModel::tilesChanged);
connect(tilesetDocument, &TilesetDocument::tileWangSetChanged,
tilesetModel, &TilesetModel::tilesChanged);
connect(tilesetDocument, &TilesetDocument::tileImageSourceChanged,
tilesetModel, &TilesetModel::tileChanged);
connect(tilesetDocument, &TilesetDocument::tileAnimationChanged,
tilesetModel, &TilesetModel::tileChanged);
connect(tilesetDocument, &TilesetDocument::tilesetChanged,
this, &TilesetEditor::tilesetChanged);
connect(view, &TilesetView::createNewTerrain, this, &TilesetEditor::addTerrainType);
connect(view, &TilesetView::terrainImageSelected, this, &TilesetEditor::setTerrainImage);
connect(view, &TilesetView::wangSetImageSelected, this, &TilesetEditor::setWangSetImage);
connect(view, &TilesetView::wangColorImageSelected, this, &TilesetEditor::setWangColorImage);
connect(view, &TilesetView::wangIdUsedChanged, mWangDock, &WangDock::onWangIdUsedChanged);
connect(view, &TilesetView::currentWangIdChanged, mWangDock, &WangDock::onCurrentWangIdChanged);
QItemSelectionModel *s = view->selectionModel();
connect(s, &QItemSelectionModel::selectionChanged, this, &TilesetEditor::selectionChanged);
connect(s, &QItemSelectionModel::currentChanged, this, &TilesetEditor::currentChanged);
connect(view, &TilesetView::pressed, this, &TilesetEditor::indexPressed);
mViewForTileset.insert(tilesetDocument, view);
mWidgetStack->addWidget(view);
}
void TilesetDock::setMapDocument(MapDocument *mapDocument)
{
if (mMapDocument == mapDocument)
return;
// Hide while we update the tab bar, to avoid repeated layouting
widget()->hide();
setCurrentTiles(0);
if (mMapDocument) {
// Remember the last visible tileset for this map
const QString tilesetName = mTabBar->tabText(mTabBar->currentIndex());
mCurrentTilesets.insert(mMapDocument, tilesetName);
}
// Clear previous content
while (mTabBar->count())
mTabBar->removeTab(0);
while (mViewStack->count())
delete mViewStack->widget(0);
mTilesets.clear();
// Clear all connections to the previous document
if (mMapDocument)
mMapDocument->disconnect(this);
mMapDocument = mapDocument;
if (mMapDocument) {
mTilesets = mMapDocument->map()->tilesets();
foreach (Tileset *tileset, mTilesets) {
TilesetView *view = new TilesetView;
view->setMapDocument(mMapDocument);
view->setZoomable(mZoomable);
mTabBar->addTab(tileset->name());
mViewStack->addWidget(view);
}
connect(mMapDocument, SIGNAL(tilesetAdded(int,Tileset*)),
SLOT(tilesetAdded(int,Tileset*)));
connect(mMapDocument, SIGNAL(tilesetRemoved(Tileset*)),
SLOT(tilesetRemoved(Tileset*)));
connect(mMapDocument, SIGNAL(tilesetMoved(int,int)),
SLOT(tilesetMoved(int,int)));
connect(mMapDocument, SIGNAL(tilesetNameChanged(Tileset*)),
SLOT(tilesetNameChanged(Tileset*)));
connect(mMapDocument, SIGNAL(tilesetFileNameChanged(Tileset*)),
SLOT(updateActions()));
QString cacheName = mCurrentTilesets.take(mMapDocument);
for (int i = 0; i < mTabBar->count(); ++i) {
if (mTabBar->tabText(i) == cacheName) {
mTabBar->setCurrentIndex(i);
break;
}
}
}
void TilesetDock::setMapDocument(MapDocument *mapDocument)
{
if (mMapDocument == mapDocument)
return;
// Hide while we update the tab bar, to avoid repeated layouting
// But, this causes problems on OS X (issue #1055)
#ifndef Q_OS_OSX
widget()->hide();
#endif
setCurrentTiles(nullptr);
setCurrentTile(nullptr);
if (mMapDocument) {
// Remember the last visible tileset for this map
const QString tilesetName = mTabBar->tabText(mTabBar->currentIndex());
mCurrentTilesets.insert(mMapDocument, tilesetName);
}
// Clear previous content
while (mTabBar->count())
mTabBar->removeTab(0);
while (mViewStack->count())
delete mViewStack->widget(0);
mTilesets.clear();
// Clear all connections to the previous document
if (mMapDocument)
mMapDocument->disconnect(this);
mMapDocument = mapDocument;
if (mMapDocument) {
mTilesets = mMapDocument->map()->tilesets();
for (const SharedTileset &tileset : mTilesets) {
TilesetView *view = new TilesetView;
view->setMapDocument(mMapDocument);
view->setZoomable(mZoomable);
mTabBar->addTab(tileset->name());
mViewStack->addWidget(view);
}
connect(mMapDocument, &MapDocument::tilesetAdded,
this, &TilesetDock::tilesetAdded);
connect(mMapDocument, &MapDocument::tilesetRemoved,
this, &TilesetDock::tilesetRemoved);
connect(mMapDocument, &MapDocument::tilesetMoved,
this, &TilesetDock::tilesetMoved);
connect(mMapDocument, &MapDocument::tilesetReplaced,
this, &TilesetDock::tilesetReplaced);
connect(mMapDocument, &MapDocument::tilesetNameChanged,
this, &TilesetDock::tilesetNameChanged);
connect(mMapDocument, &MapDocument::tilesetFileNameChanged,
this, &TilesetDock::updateActions);
connect(mMapDocument, &MapDocument::tilesetChanged,
this, &TilesetDock::tilesetChanged);
connect(mMapDocument, &MapDocument::tileImageSourceChanged,
this, &TilesetDock::tileImageSourceChanged);
connect(mMapDocument, &MapDocument::tileAnimationChanged,
this, &TilesetDock::tileAnimationChanged);
QString cacheName = mCurrentTilesets.take(mMapDocument);
for (int i = 0; i < mTabBar->count(); ++i) {
if (mTabBar->tabText(i) == cacheName) {
mTabBar->setCurrentIndex(i);
break;
}
}
if (Object *object = mMapDocument->currentObject())
if (object->typeId() == Object::TileType)
setCurrentTile(static_cast<Tile*>(object));
}
updateActions();
#ifndef Q_OS_OSX
widget()->show();
#endif
}
void TilesetEditor::indexPressed(const QModelIndex &index)
{
TilesetView *view = currentTilesetView();
if (Tile *tile = view->tilesetModel()->tileAt(index))
mCurrentTilesetDocument->setCurrentObject(tile);
}
