Skip to content

Commit

Permalink
Cleanup atlas not in dynamic view checks
Browse files Browse the repository at this point in the history 
Signed-off-by: Tomas Slusny <[email protected]>
  • Loading branch information
@deathbeam
deathbeam committed Feb 15, 2025
1 parent 4646cee commit ad5a64f
Show file tree
Hide file tree
Showing 2 changed files with 52 additions and 66 deletions.
5 changes: 2 additions & 3 deletions src/tiled/tilesetmodel.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -113,9 +113,8 @@ Qt::ItemFlags TilesetModel::flags(const QModelIndex &index) const
if (!index.isValid())
return defaultFlags;

if (isFixedAtlas())
if (!tileAt(index))
return defaultFlags & ~Qt::ItemIsSelectable;
if (isFixedAtlas() && !tileAt(index))
return defaultFlags & ~Qt::ItemIsSelectable;

defaultFlags |= Qt::ItemIsDropEnabled;
defaultFlags |= Qt::ItemIsDragEnabled;
Expand Down
113 changes: 50 additions & 63 deletions src/tiled/tilesetview.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -114,9 +114,10 @@ void TileDelegate::paint(QPainter *painter,
const QModelIndex &index) const
{
const TilesetModel *model = static_cast<const TilesetModel*>(index.model());
const Tileset *tileset = model->tileset();
if (!model)
return;

if (tileset->isAtlas() && !mTilesetView->dynamicWrapping())
if (model->isFixedAtlas())
return;

Tile *tile = model->tileAt(index);
Expand Down Expand Up @@ -211,10 +212,9 @@ QSize TileDelegate::sizeHint(const QStyleOptionViewItem & /* option */,
const qreal scale = mTilesetView->scale();
Tileset *tileset = m->tileset();

if (tileset->isAtlas() && !mTilesetView->dynamicWrapping()) {
if (m->isFixedAtlas())
return QSize(tileset->imageWidth() * scale + extra,
tileset->imageHeight() * scale + extra);
}

if (const Tile *tile = m->tileAt(index)) {
if (mTilesetView->dynamicWrapping() && !tileset->isAtlas())
Expand Down Expand Up @@ -538,9 +538,10 @@ void TilesetView::setRelocateTiles(bool enabled)

mRelocateTiles = enabled;

if (TilesetModel *m = tilesetModel())
if (m->tileset()->isAtlas())
enabled = false;
if (TilesetModel *m = tilesetModel(); m && m->tileset()->isAtlas()) {
selectionModel()->clear();
enabled = false;
}

if (enabled)
setDragDropMode(QTableView::InternalMove);
Expand Down Expand Up @@ -582,10 +583,7 @@ void TilesetView::setWangId(WangId wangId)
mWangBehavior = AssignWholeId;

if (mEditWangSet) {
const TilesetModel *model = tilesetModel();
if (!model)
return;
if (model->tileset()->isAtlas()) {
if (TilesetModel *m = tilesetModel(); m && m->isFixedAtlas()) {
viewport()->update();
} else if (mHoveredIndex.isValid()) {
update(mHoveredIndex);
Expand Down Expand Up @@ -666,9 +664,14 @@ void TilesetView::mouseMoveEvent(QMouseEvent *event)
return;
}

const TilesetModel *model = tilesetModel();
if (!model)
return;

if (mDraggedIndex.isValid()) {
mSnapToGrid = !(event->modifiers() & Qt::ShiftModifier);
if (Tile *tile = tilesetModel()->tileAt(mDraggedIndex)) {

if (Tile *tile = model->tileAt(mDraggedIndex)) {
QRect newRect = tile->imageRect();
QPoint pos = viewToTile(event->pos());

Expand All @@ -692,10 +695,10 @@ void TilesetView::mouseMoveEvent(QMouseEvent *event)
}

if (mSnapToGrid) {
const int margin = tilesetModel()->tileset()->margin();
const int spacing = tilesetModel()->tileset()->tileSpacing();
const int tileWidth = tilesetModel()->tileset()->tileWidth();
const int tileHeight = tilesetModel()->tileset()->tileHeight();
const int margin = model->tileset()->margin();
const int spacing = model->tileset()->tileSpacing();
const int tileWidth = model->tileset()->tileWidth();
const int tileHeight = model->tileset()->tileHeight();

if (mResizingEdge == 0) {
pos.setX((qMax(pos.x() - margin, 0) / (tileWidth + spacing)) * (tileWidth + spacing) + margin);
Expand Down Expand Up @@ -726,6 +729,7 @@ void TilesetView::mouseMoveEvent(QMouseEvent *event)

mRubberBand.setGeometry(tileToView(newRect));
}

event->accept();
return;
}
Expand All @@ -734,10 +738,6 @@ void TilesetView::mouseMoveEvent(QMouseEvent *event)
if (!mWangSet)
return;

const TilesetModel *model = tilesetModel();
if (!model)
return;

const QPoint pos = event->pos();
const QModelIndex hoveredIndex = indexAt(pos);
const QModelIndex previousHoveredIndex = mHoveredIndex;
Expand Down Expand Up @@ -824,23 +824,22 @@ void TilesetView::mouseMoveEvent(QMouseEvent *event)

void TilesetView::mouseReleaseEvent(QMouseEvent *event)
{
const TilesetModel *model = tilesetModel();
if (!model)
return;

if (mDraggedIndex.isValid() && event->button() == Qt::LeftButton) {
if (Tile* tile = tilesetModel()->tileAt(mDraggedIndex)) {
if (Tile* tile = model->tileAt(mDraggedIndex))
mTilesetDocument->undoStack()->push(new ChangeTileImageRect(mTilesetDocument, { tile }, { viewToTile(mRubberBand.geometry()) }));
}

mDraggedIndex = QModelIndex();
mRubberBand.hide();
event->accept();
return;
}

if (mAtlasSelecting && (event->button() == Qt::LeftButton || event->button() == Qt::RightButton)) {
QRect tileRect;
if (mRubberBand.geometry().isEmpty()) {
tileRect = QRect(mSelectionOffset, QSize(1, 1));
} else {
tileRect = viewToTile(mRubberBand.geometry());
}
QRect tileRect = mRubberBand.geometry().isEmpty() ? QRect(mSelectionOffset, QSize(1, 1)) : viewToTile(mRubberBand.geometry());

if (event->button() == Qt::RightButton) {
QList<Tile*> tiles;
Expand Down Expand Up @@ -875,14 +874,14 @@ void TilesetView::paintEvent(QPaintEvent *event)
QTableView::paintEvent(event);

TilesetModel *model = tilesetModel();
if (!model || !model->tileset()->isAtlas() || dynamicWrapping())
if (!model || !model->isFixedAtlas())
return;

QPainter painter(viewport());
const Tileset *tileset = model->tileset();

// Draw tileset background image when in relocate mode
if (mRelocateTiles) {
const Tileset *tileset = model->tileset();
if (!tileset->imageSource().isEmpty()) {
const QRect sourceRect(0, 0, tileset->imageWidth(), tileset->imageHeight());
const QRect viewRect = tileToView(sourceRect);
Expand All @@ -896,7 +895,7 @@ void TilesetView::paintEvent(QPaintEvent *event)
TileDelegate *delegate = static_cast<TileDelegate*>(itemDelegate());
QItemSelectionModel *s = selectionModel();

for (Tile *tile : model->tileset()->tiles()) {
for (Tile *tile : tileset->tiles()) {
const QRect rect = tileToView(tile->imageRect());
const QModelIndex index = model->tileIndex(tile);
const bool selected = s->isSelected(index) || index == s->currentIndex();
Expand All @@ -915,62 +914,52 @@ void TilesetView::paintEvent(QPaintEvent *event)

QModelIndex TilesetView::indexAt(const QPoint &pos) const
{
if (!model())
return QModelIndex();

if (tilesetModel() && tilesetModel()->tileset()->isAtlas() && !dynamicWrapping()) {
if (TilesetModel *m = tilesetModel(); m && m->isFixedAtlas()) {
const QPoint tilesetPos = viewToTile(pos);

// Find tile that contains this position
for (Tile *tile : tilesetModel()->tileset()->tiles()) {
for (Tile *tile : m->tileset()->tiles())
if (tile->imageRect().contains(tilesetPos))
return tilesetModel()->tileIndex(tile);
}

// Return invalid index if no tile found
return QModelIndex();
}

// Use default behavior for non-atlas mode
return QTableView::indexAt(pos);
}

void TilesetView::scrollTo(const QModelIndex &index, ScrollHint hint)
{
if (!tilesetModel() || !tilesetModel()->tileset()->isAtlas() || dynamicWrapping()) {
QTableView::scrollTo(index, hint);
if (TilesetModel *m = tilesetModel(); m && m->isFixedAtlas()) {
return;
}

QTableView::scrollTo(index, hint);
}

void TilesetView::setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags flags)
{
if (!tilesetModel() || !tilesetModel()->tileset()->isAtlas() || dynamicWrapping()) {
const TilesetModel *model = tilesetModel();

if (!model || !model->isFixedAtlas()) {
QTableView::setSelection(rect, flags);
return;
}

// Convert view coordinates to tileset coordinates
// Select tiles based on position in the rect
const QRect tilesetRect = viewToTile(rect);

// Select all tiles that intersect with the rect
QItemSelection selection;
const TilesetModel *model = tilesetModel();

for (Tile *tile : model->tileset()->tiles()) {
if (tile->imageRect().intersects(tilesetRect)) {
const QModelIndex index = model->tileIndex(tile);
selection.select(index, index);
}
}

selectionModel()->select(selection, flags);
}

void TilesetView::selectionChanged(const QItemSelection &selected, const QItemSelection &deselected)
{
QTableView::selectionChanged(selected, deselected);
if (tilesetModel() && tilesetModel()->tileset()->isAtlas())

if (TilesetModel *m = tilesetModel(); m && m->isFixedAtlas())
viewport()->update();
}

Expand All @@ -979,11 +968,9 @@ QRect TilesetView::visualRect(const QModelIndex &index) const
if (!index.isValid())
return QRect();

const TilesetModel *m = tilesetModel();
if (m && m->tileset()->isAtlas() && !dynamicWrapping()) {
if (Tile *tile = m->tileAt(index)) {
if (TilesetModel *m = tilesetModel(); m && m->isFixedAtlas()) {
if (Tile *tile = m->tileAt(index))
return tileToView(tile->imageRect());
}
return QRect();
}

Expand All @@ -995,8 +982,7 @@ void TilesetView::leaveEvent(QEvent *event)
if (mHoveredIndex.isValid()) {
const QModelIndex previousHoveredIndex = mHoveredIndex;
mHoveredIndex = QModelIndex();
const TilesetModel *model = tilesetModel();
if (model && model->tileset()->isAtlas()) {
if (TilesetModel *m = tilesetModel(); m && m->isFixedAtlas()) {
viewport()->update();
} else {
update(previousHoveredIndex);
Expand Down Expand Up @@ -1225,10 +1211,11 @@ void TilesetView::adjustScale()

void TilesetView::refreshColumnCount()
{
if (!tilesetModel())
const TilesetModel *model = tilesetModel();
if (!model)
return;

if (tilesetModel()->tileset()->isAtlas())
if (model->tileset()->isAtlas())
viewport()->update();

if (!dynamicWrapping()) {
Expand All @@ -1239,12 +1226,12 @@ void TilesetView::refreshColumnCount()
const QSize maxSize = maximumViewportSize();
const int gridSpace = mDrawGrid ? 1 : 0;
int tileWidth;
if (tilesetModel()->tileset()->isAtlas()) {
if (model->tileset()->isAtlas()) {
tileWidth = 0;
for (Tile *tile : tilesetModel()->tileset()->tiles())
for (Tile *tile : model->tileset()->tiles())
tileWidth = std::max(tileWidth, tile->imageRect().width());
} else {
tileWidth = tilesetModel()->tileset()->tileWidth();
tileWidth = model->tileset()->tileWidth();
}
const int scaledTileSize = std::max<int>(tileWidth * scale(), 1) + gridSpace;
const int columnCount = std::max(maxSize.width() / scaledTileSize, 1);
Expand Down

0 comments on commit ad5a64f

Please sign in to comment.