atiran/porymap
3
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Merge branch 'master' into fix-window-size-issue

Browse source
This commit is contained in:
Tyler 2020-10-22 19:59:11 -04:00 committed by GitHub
commit de43c64118
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 281 additions and 119 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
CHANGELOG.md
View file

@ -15,6 +15,7 @@ The **"Breaking Changes"** listed below are changes that have been made in the d
- The New Map dialog now gives an option to specify the "Show Location Name" field.
- Some new shortcuts were added in [porymap/#290](https://github.com/huderlem/porymap/pull/290).
- All plain text boxes now have a clear button to delete the text.
- The window sizes and positions of the tileset editor, palette editor, and region map editor are now stored in `porymap.cfg`.
### Changed
- Holding `shift` now toggles "Smart Path" drawing; when the "Smart Paths" checkbox is checked, holding `shift` will temporarily disable it.

2
forms/paletteeditor.ui
View file

@ -14,7 +14,7 @@
<enum>Qt::ClickFocus</enum>
</property>
<property name="windowTitle">
<string>MainWindow</string>
<string>Palette Editor</string>
</property>
<widget class="QWidget" name="centralwidget">
<layout class="QVBoxLayout" name="verticalLayout">

20
include/config.h
View file

@ -50,7 +50,10 @@ public:
void setRecentMap(QString map);
void setMapSortOrder(MapSortOrder order);
void setPrettyCursors(bool enabled);
void setGeometry(QByteArray, QByteArray, QByteArray, QByteArray);
void setMainGeometry(QByteArray, QByteArray, QByteArray, QByteArray);
void setTilesetEditorGeometry(QByteArray, QByteArray);
void setPaletteEditorGeometry(QByteArray, QByteArray);
void setRegionMapEditorGeometry(QByteArray, QByteArray);
void setCollisionOpacity(int opacity);
void setMetatilesZoom(int zoom);
void setShowPlayerView(bool enabled);
@ -62,7 +65,10 @@ public:
QString getRecentMap();
MapSortOrder getMapSortOrder();
bool getPrettyCursors();
QMap<QString, QByteArray> getGeometry();
QMap<QString, QByteArray> getMainGeometry();
QMap<QString, QByteArray> getTilesetEditorGeometry();
QMap<QString, QByteArray> getPaletteEditorGeometry();
QMap<QString, QByteArray> getRegionMapEditorGeometry();
int getCollisionOpacity();
int getMetatilesZoom();
bool getShowPlayerView();
@ -83,11 +89,17 @@ private:
QByteArray bytesFromString(QString);
MapSortOrder mapSortOrder;
bool prettyCursors;
QByteArray windowGeometry;
QByteArray windowState;
QByteArray mainWindowGeometry;
QByteArray mainWindowState;
QByteArray mapSplitterState;
QByteArray eventsSlpitterState;
QByteArray mainSplitterState;
QByteArray tilesetEditorGeometry;
QByteArray tilesetEditorState;
QByteArray paletteEditorGeometry;
QByteArray paletteEditorState;
QByteArray regionMapEditorGeometry;
QByteArray regionMapEditorState;
int collisionOpacity;
int metatilesZoom;
bool showPlayerView;

2
include/ui/paletteeditor.h
View file

@ -45,7 +45,9 @@ private:
void refreshColor(int);
void setColor(int);
void commitEditHistory(int paletteid);
void restoreWindowState();
void setColorsFromHistory(PaletteHistoryItem*, int);
void closeEvent(QCloseEvent*);
signals:
void closed();

1
include/ui/regionmapeditor.h
View file

@ -97,6 +97,7 @@ private:
bool createCityMap(QString name);
bool tryInsertNewMapEntry(QString);
void restoreWindowState();
void closeEvent(QCloseEvent* event);
private slots:

20
include/ui/tileseteditor.h
View file

@ -37,8 +37,9 @@ class TilesetEditor : public QMainWindow
public:
explicit TilesetEditor(Project*, Map*, QWidget *parent = nullptr);
~TilesetEditor();
void setMap(Map*);
void setTilesets(QString, QString);
void update(Map *map, QString primaryTilsetLabel, QString secondaryTilesetLabel);
void updateMap(Map *map);
void updateTilesets(QString primaryTilsetLabel, QString secondaryTilesetLabel);
bool selectMetatile(uint16_t metatileId);
private slots:
@ -92,17 +93,25 @@ private slots:
void on_actionImport_Secondary_Metatiles_triggered();
private:
void init(Project*, Map*);
void closeEvent(QCloseEvent*);
void initMetatileSelector(Map*);
void initUi();
void setMetatileBehaviors();
void setMetatileLayersUi();
void setVersionSpecificUi();
void setMetatileLabelValidator();
void initMetatileSelector();
void initTileSelector();
void initSelectedTileItem();
void initMetatileLayersItem();
void restoreWindowState();
void initMetatileHistory();
void setTilesets(QString primaryTilesetLabel, QString secondaryTilesetLabel);
void reset();
void drawSelectedTiles();
void importTilesetTiles(Tileset*, bool);
void importTilesetMetatiles(Tileset*, bool);
void refresh();
void saveMetatileLabel();
void closeEvent(QCloseEvent*);
Ui::TilesetEditor *ui;
History<MetatileHistoryItem*> metatileHistory;
TilesetEditorMetatileSelector *metatileSelector = nullptr;
@ -110,6 +119,7 @@ private:
MetatileLayersItem *metatileLayersItem = nullptr;
PaletteEditor *paletteEditor = nullptr;
Project *project = nullptr;
Map *map = nullptr;
Metatile *metatile = nullptr;
int paletteId;
bool tileXFlip;

87
src/config.cpp
View file

@ -122,10 +122,10 @@ void PorymapConfig::parseConfigKeyValue(QString key, QString value) {
this->mapSortOrder = MapSortOrder::Group;
logWarn(QString("Invalid config value for map_sort_order: '%1'. Must be 'group', 'area', or 'layout'.").arg(value));
}
} else if (key == "window_geometry") {
this->windowGeometry = bytesFromString(value);
} else if (key == "window_state") {
this->windowState = bytesFromString(value);
} else if (key == "main_window_geometry") {
this->mainWindowGeometry = bytesFromString(value);
} else if (key == "main_window_state") {
this->mainWindowState = bytesFromString(value);
} else if (key == "map_splitter_state") {
this->mapSplitterState = bytesFromString(value);
} else if (key == "main_splitter_state") {
@ -137,6 +137,18 @@ void PorymapConfig::parseConfigKeyValue(QString key, QString value) {
logWarn(QString("Invalid config value for collision_opacity: '%1'. Must be an integer.").arg(value));
this->collisionOpacity = 50;
}
} else if (key == "tileset_editor_geometry") {
this->tilesetEditorGeometry = bytesFromString(value);
} else if (key == "tileset_editor_state") {
this->tilesetEditorState = bytesFromString(value);
} else if (key == "palette_editor_geometry") {
this->paletteEditorGeometry = bytesFromString(value);
} else if (key == "palette_editor_state") {
this->paletteEditorState = bytesFromString(value);
} else if (key == "region_map_editor_geometry") {
this->regionMapEditorGeometry = bytesFromString(value);
} else if (key == "region_map_editor_state") {
this->regionMapEditorState = bytesFromString(value);
} else if (key == "metatiles_zoom") {
bool ok;
this->metatilesZoom = qMax(10, qMin(100, value.toInt(&ok)));
@ -186,10 +198,16 @@ QMap<QString, QString> PorymapConfig::getKeyValueMap() {
map.insert("recent_map", this->recentMap);
map.insert("pretty_cursors", this->prettyCursors ? "1" : "0");
map.insert("map_sort_order", mapSortOrderMap.value(this->mapSortOrder));
map.insert("window_geometry", stringFromByteArray(this->windowGeometry));
map.insert("window_state", stringFromByteArray(this->windowState));
map.insert("main_window_geometry", stringFromByteArray(this->mainWindowGeometry));
map.insert("main_window_state", stringFromByteArray(this->mainWindowState));
map.insert("map_splitter_state", stringFromByteArray(this->mapSplitterState));
map.insert("main_splitter_state", stringFromByteArray(this->mainSplitterState));
map.insert("tileset_editor_geometry", stringFromByteArray(this->tilesetEditorGeometry));
map.insert("tileset_editor_state", stringFromByteArray(this->tilesetEditorState));
map.insert("palette_editor_geometry", stringFromByteArray(this->paletteEditorGeometry));
map.insert("palette_editor_state", stringFromByteArray(this->paletteEditorState));
map.insert("region_map_editor_geometry", stringFromByteArray(this->regionMapEditorGeometry));
map.insert("region_map_editor_state", stringFromByteArray(this->regionMapEditorState));
map.insert("collision_opacity", QString("%1").arg(this->collisionOpacity));
map.insert("metatiles_zoom", QString("%1").arg(this->metatilesZoom));
map.insert("show_player_view", this->showPlayerView ? "1" : "0");
@ -243,15 +261,33 @@ void PorymapConfig::setMonitorFiles(bool monitor) {
this->save();
}
void PorymapConfig::setGeometry(QByteArray windowGeometry_, QByteArray windowState_,
void PorymapConfig::setMainGeometry(QByteArray mainWindowGeometry_, QByteArray mainWindowState_,
QByteArray mapSplitterState_, QByteArray mainSplitterState_) {
this->windowGeometry = windowGeometry_;
this->windowState = windowState_;
this->mainWindowGeometry = mainWindowGeometry_;
this->mainWindowState = mainWindowState_;
this->mapSplitterState = mapSplitterState_;
this->mainSplitterState = mainSplitterState_;
this->save();
}
void PorymapConfig::setTilesetEditorGeometry(QByteArray tilesetEditorGeometry_, QByteArray tilesetEditorState_) {
this->tilesetEditorGeometry = tilesetEditorGeometry_;
this->tilesetEditorState = tilesetEditorState_;
this->save();
}
void PorymapConfig::setPaletteEditorGeometry(QByteArray paletteEditorGeometry_, QByteArray paletteEditorState_) {
this->paletteEditorGeometry = paletteEditorGeometry_;
this->paletteEditorState = paletteEditorState_;
this->save();
}
void PorymapConfig::setRegionMapEditorGeometry(QByteArray regionMapEditorGeometry_, QByteArray regionMapEditorState_) {
this->regionMapEditorGeometry = regionMapEditorGeometry_;
this->regionMapEditorState = regionMapEditorState_;
this->save();
}
void PorymapConfig::setCollisionOpacity(int opacity) {
this->collisionOpacity = opacity;
// don't auto-save here because this can be called very frequently.
@ -296,17 +332,44 @@ bool PorymapConfig::getPrettyCursors() {
return this->prettyCursors;
}
QMap<QString, QByteArray> PorymapConfig::getGeometry() {
QMap<QString, QByteArray> PorymapConfig::getMainGeometry() {
QMap<QString, QByteArray> geometry;
geometry.insert("window_geometry", this->windowGeometry);
geometry.insert("window_state", this->windowState);
geometry.insert("main_window_geometry", this->mainWindowGeometry);
geometry.insert("main_window_state", this->mainWindowState);
geometry.insert("map_splitter_state", this->mapSplitterState);
geometry.insert("main_splitter_state", this->mainSplitterState);
return geometry;
}
QMap<QString, QByteArray> PorymapConfig::getTilesetEditorGeometry() {
QMap<QString, QByteArray> geometry;
geometry.insert("tileset_editor_geometry", this->tilesetEditorGeometry);
geometry.insert("tileset_editor_state", this->tilesetEditorState);
return geometry;
}
QMap<QString, QByteArray> PorymapConfig::getPaletteEditorGeometry() {
QMap<QString, QByteArray> geometry;
geometry.insert("palette_editor_geometry", this->paletteEditorGeometry);
geometry.insert("palette_editor_state", this->paletteEditorState);
return geometry;
}
QMap<QString, QByteArray> PorymapConfig::getRegionMapEditorGeometry() {
QMap<QString, QByteArray> geometry;
geometry.insert("region_map_editor_geometry", this->regionMapEditorGeometry);
geometry.insert("region_map_editor_state", this->regionMapEditorState);
return geometry;
}
int PorymapConfig::getCollisionOpacity() {
return this->collisionOpacity;
}

19
src/mainwindow.cpp
View file

@ -364,10 +364,10 @@ void MainWindow::loadUserSettings() {
}
void MainWindow::restoreWindowState() {
logInfo("Restoring window geometry from previous session.");
QMap<QString, QByteArray> geometry = porymapConfig.getGeometry();
this->restoreGeometry(geometry.value("window_geometry"));
this->restoreState(geometry.value("window_state"));
logInfo("Restoring main window geometry from previous session.");
QMap<QString, QByteArray> geometry = porymapConfig.getMainGeometry();
this->restoreGeometry(geometry.value("main_window_geometry"));
this->restoreState(geometry.value("main_window_state"));
this->ui->splitter_map->restoreState(geometry.value("map_splitter_state"));
this->ui->splitter_main->restoreState(geometry.value("main_splitter_state"));
}
@ -1220,8 +1220,11 @@ void MainWindow::on_actionNew_Tileset_triggered() {
void MainWindow::updateTilesetEditor() {
if (this->tilesetEditor) {
this->tilesetEditor->setMap(this->editor->map);
this->tilesetEditor->setTilesets(editor->ui->comboBox_PrimaryTileset->currentText(), editor->ui->comboBox_SecondaryTileset->currentText());
this->tilesetEditor->update(
this->editor->map,
editor->ui->comboBox_PrimaryTileset->currentText(),
editor->ui->comboBox_SecondaryTileset->currentText()
);
}
}
@ -2532,7 +2535,6 @@ void MainWindow::on_actionTileset_Editor_triggered()
this->tilesetEditor = new TilesetEditor(this->editor->project, this->editor->map, this);
connect(this->tilesetEditor, SIGNAL(tilesetsSaved(QString, QString)), this, SLOT(onTilesetsSaved(QString, QString)));
connect(this->tilesetEditor, &QObject::destroyed, [=](QObject *) { this->tilesetEditor = nullptr; });
this->tilesetEditor->setAttribute(Qt::WA_DeleteOnClose);
}
if (!this->tilesetEditor->isVisible()) {
@ -2672,7 +2674,6 @@ void MainWindow::on_actionRegion_Map_Editor_triggered() {
return;
}
connect(this->regionMapEditor, &QObject::destroyed, [=](QObject *) { this->regionMapEditor = nullptr; });
this->regionMapEditor->setAttribute(Qt::WA_DeleteOnClose);
}
if (!this->regionMapEditor->isVisible()) {
@ -2711,7 +2712,7 @@ void MainWindow::closeEvent(QCloseEvent *event) {
}
}
porymapConfig.setGeometry(
porymapConfig.setMainGeometry(
this->saveGeometry(),
this->saveState(),
this->ui->splitter_map->saveState(),

2
src/mainwindow_scriptapi.cpp
View file

@ -247,7 +247,7 @@ void MainWindow::addImage(int x, int y, QString filepath) {
void MainWindow::refreshAfterPaletteChange(Tileset *tileset) {
if (this->tilesetEditor) {
this->tilesetEditor->setTilesets(this->editor->map->layout->tileset_primary_label, this->editor->map->layout->tileset_secondary_label);
this->tilesetEditor->updateTilesets(this->editor->map->layout->tileset_primary_label, this->editor->map->layout->tileset_secondary_label);
}
this->editor->metatile_selector_item->draw();
this->editor->selected_border_metatiles_item->draw();

18
src/ui/paletteeditor.cpp
View file

@ -1,9 +1,10 @@
#include "paletteeditor.h"
#include "ui_paletteeditor.h"
#include "paletteutil.h"
#include "config.h"
#include "log.h"
#include <QFileDialog>
#include <QMessageBox>
#include "log.h"
PaletteEditor::PaletteEditor(Project *project, Tileset *primaryTileset, Tileset *secondaryTileset, int paletteId, QWidget *parent) :
QMainWindow(parent),
@ -112,6 +113,7 @@ PaletteEditor::PaletteEditor(Project *project, Tileset *primaryTileset, Tileset
this->initColorSliders();
this->setPaletteId(paletteId);
this->commitEditHistory(this->ui->spinBox_PaletteId->value());
this->restoreWindowState();
}
PaletteEditor::~PaletteEditor()
@ -227,6 +229,13 @@ void PaletteEditor::commitEditHistory(int paletteId) {
this->palettesHistory[paletteId].push(commit);
}
void PaletteEditor::restoreWindowState() {
logInfo("Restoring palette editor geometry from previous session.");
QMap<QString, QByteArray> geometry = porymapConfig.getPaletteEditorGeometry();
this->restoreGeometry(geometry.value("palette_editor_geometry"));
this->restoreState(geometry.value("palette_editor_state"));
}
void PaletteEditor::on_actionUndo_triggered()
{
int paletteId = this->ui->spinBox_PaletteId->value();
@ -311,3 +320,10 @@ void PaletteEditor::on_actionImport_Palette_triggered()
this->commitEditHistory(paletteId);
emit this->changedPaletteColor();
}
void PaletteEditor::closeEvent(QCloseEvent*) {
porymapConfig.setPaletteEditorGeometry(
this->saveGeometry(),
this->saveState()
);
}

13
src/ui/regionmapeditor.cpp
View file

@ -24,6 +24,7 @@ RegionMapEditor::RegionMapEditor(QWidget *parent, Project *project_) :
this->project = project_;
this->region_map = new RegionMap;
this->ui->action_RegionMap_Resize->setVisible(false);
this->restoreWindowState();
}
RegionMapEditor::~RegionMapEditor()
@ -42,6 +43,13 @@ RegionMapEditor::~RegionMapEditor()
delete scene_region_map_tiles;
}
void RegionMapEditor::restoreWindowState() {
logInfo("Restoring region map editor geometry from previous session.");
QMap<QString, QByteArray> geometry = porymapConfig.getRegionMapEditorGeometry();
this->restoreGeometry(geometry.value("region_map_editor_geometry"));
this->restoreState(geometry.value("region_map_editor_state"));
}
void RegionMapEditor::on_action_RegionMap_Save_triggered() {
setCurrentSquareOptions();
if (project && region_map) {
@ -899,6 +907,11 @@ void RegionMapEditor::closeEvent(QCloseEvent *event)
} else {
event->accept();
}
porymapConfig.setRegionMapEditorGeometry(
this->saveGeometry(),
this->saveState()
);
}
void RegionMapEditor::on_verticalSlider_Zoom_Map_Image_valueChanged(int val) {

215
src/ui/tileseteditor.cpp
View file

@ -14,10 +14,14 @@
TilesetEditor::TilesetEditor(Project *project, Map *map, QWidget *parent) :
QMainWindow(parent),
ui(new Ui::TilesetEditor)
ui(new Ui::TilesetEditor),
project(project),
map(map),
hasUnsavedChanges(false)
{
this->init(project, map);
new QShortcut(QKeySequence("Ctrl+Shift+Z"), this, SLOT(on_actionRedo_triggered()));
this->setTilesets(this->map->layout->tileset_primary_label, this->map->layout->tileset_secondary_label);
this->initUi();
this->initMetatileHistory();
}
TilesetEditor::~TilesetEditor()
@ -37,27 +41,78 @@ TilesetEditor::~TilesetEditor()
delete metatileLayersScene;
}
void TilesetEditor::init(Project *project, Map *map) {
ui->setupUi(this);
this->project = project;
void TilesetEditor::update(Map *map, QString primaryTilesetLabel, QString secondaryTilesetLabel) {
this->updateMap(map);
this->updateTilesets(primaryTilesetLabel, secondaryTilesetLabel);
}
void TilesetEditor::updateMap(Map *map) {
this->map = map;
this->metatileSelector->map = map;
}
void TilesetEditor::updateTilesets(QString primaryTilesetLabel, QString secondaryTilesetLabel) {
if (this->hasUnsavedChanges) {
QMessageBox::StandardButton result = QMessageBox::question(
this,
"porymap",
"Tileset has been modified, save changes?",
QMessageBox::No | QMessageBox::Yes,
QMessageBox::Yes);
if (result == QMessageBox::Yes)
this->on_actionSave_Tileset_triggered();
}
this->hasUnsavedChanges = false;
this->tileXFlip = ui->checkBox_xFlip->isChecked();
this->tileYFlip = ui->checkBox_yFlip->isChecked();
this->paletteId = ui->spinBox_paletteSelector->value();
this->setTilesets(primaryTilesetLabel, secondaryTilesetLabel);
this->refresh();
}
Tileset *primaryTileset = project->getTileset(map->layout->tileset_primary_label);
Tileset *secondaryTileset = project->getTileset(map->layout->tileset_secondary_label);
bool TilesetEditor::selectMetatile(uint16_t metatileId) {
if (!Tileset::metatileIsValid(metatileId, this->primaryTileset, this->secondaryTileset)) return false;
this->metatileSelector->select(metatileId);
QPoint pos = this->metatileSelector->getMetatileIdCoordsOnWidget(metatileId);
this->ui->scrollArea_Metatiles->ensureVisible(pos.x(), pos.y());
return true;
}
void TilesetEditor::setTilesets(QString primaryTilesetLabel, QString secondaryTilesetLabel) {
Tileset *primaryTileset = project->getTileset(primaryTilesetLabel);
Tileset *secondaryTileset = project->getTileset(secondaryTilesetLabel);
if (this->primaryTileset) delete this->primaryTileset;
if (this->secondaryTileset) delete this->secondaryTileset;
this->primaryTileset = primaryTileset->copy();
this->secondaryTileset = secondaryTileset->copy();
}
QList<QString> sortedBehaviors;
void TilesetEditor::initUi() {
ui->setupUi(this);
new QShortcut(QKeySequence("Ctrl+Shift+Z"), this, SLOT(on_actionRedo_triggered()));
this->tileXFlip = ui->checkBox_xFlip->isChecked();
this->tileYFlip = ui->checkBox_yFlip->isChecked();
this->paletteId = ui->spinBox_paletteSelector->value();
this->ui->spinBox_paletteSelector->setMinimum(0);
this->ui->spinBox_paletteSelector->setMaximum(Project::getNumPalettesTotal() - 1);
this->setMetatileBehaviors();
this->setMetatileLayersUi();
this->setVersionSpecificUi();
this->setMetatileLabelValidator();
this->initMetatileSelector();
this->initMetatileLayersItem();
this->initTileSelector();
this->initSelectedTileItem();
this->metatileSelector->select(0);
this->restoreWindowState();
}
void TilesetEditor::setMetatileBehaviors() {
for (int num : project->metatileBehaviorMapInverse.keys()) {
this->ui->comboBox_metatileBehaviors->addItem(project->metatileBehaviorMapInverse[num], num);
}
}
void TilesetEditor::setMetatileLayersUi() {
if (!projectConfig.getTripleLayerMetatilesEnabled()) {
this->ui->comboBox_layerType->addItem("Normal - Middle/Top", 0);
this->ui->comboBox_layerType->addItem("Covered - Bottom/Middle", 1);
@ -67,10 +122,9 @@ void TilesetEditor::init(Project *project, Map *map) {
this->ui->label_layerType->setVisible(false);
this->ui->label_BottomTop->setText("Bottom/Middle/Top");
}
}
this->ui->spinBox_paletteSelector->setMinimum(0);
this->ui->spinBox_paletteSelector->setMaximum(Project::getNumPalettesTotal() - 1);
void TilesetEditor::setVersionSpecificUi() {
if (projectConfig.getBaseGameVersion() == BaseGameVersion::pokefirered) {
this->ui->comboBox_encounterType->setVisible(true);
this->ui->label_encounterType->setVisible(true);
@ -89,72 +143,18 @@ void TilesetEditor::init(Project *project, Map *map) {
this->ui->comboBox_terrainType->setVisible(false);
this->ui->label_terrainType->setVisible(false);
}
}
void TilesetEditor::setMetatileLabelValidator() {
//only allow characters valid for a symbol
QRegExp expression("[_A-Za-z0-9]*$");
QRegExpValidator *validator = new QRegExpValidator(expression);
this->ui->lineEdit_metatileLabel->setValidator(validator);
this->initMetatileSelector(map);
this->initMetatileLayersItem();
this->initTileSelector();
this->initSelectedTileItem();
this->metatileSelector->select(0);
MetatileHistoryItem *commit = new MetatileHistoryItem(0, nullptr, this->metatile->copy());
metatileHistory.push(commit);
}
bool TilesetEditor::selectMetatile(uint16_t metatileId) {
if (!Tileset::metatileIsValid(metatileId, this->primaryTileset, this->secondaryTileset)) return false;
this->metatileSelector->select(metatileId);
QPoint pos = this->metatileSelector->getMetatileIdCoordsOnWidget(metatileId);
this->ui->scrollArea_Metatiles->ensureVisible(pos.x(), pos.y());
return true;
}
void TilesetEditor::setMap(Map *map) {
this->metatileSelector->map = map;
}
void TilesetEditor::setTilesets(QString primaryTilesetLabel, QString secondaryTilesetLabel) {
if (this->hasUnsavedChanges) {
QMessageBox::StandardButton result = QMessageBox::question(
this,
"porymap",
"Tileset has been modified, save changes?",
QMessageBox::No | QMessageBox::Yes,
QMessageBox::Yes);
if (result == QMessageBox::Yes)
this->on_actionSave_Tileset_triggered();
}
this->hasUnsavedChanges = false;
delete this->primaryTileset;
delete this->secondaryTileset;
Tileset *primaryTileset = project->getTileset(primaryTilesetLabel);
Tileset *secondaryTileset = project->getTileset(secondaryTilesetLabel);
this->primaryTileset = primaryTileset->copy();
this->secondaryTileset = secondaryTileset->copy();
this->refresh();
}
void TilesetEditor::refresh() {
this->metatileLayersItem->setTilesets(this->primaryTileset, this->secondaryTileset);
this->tileSelector->setTilesets(this->primaryTileset, this->secondaryTileset);
this->metatileSelector->setTilesets(this->primaryTileset, this->secondaryTileset);
this->metatileSelector->select(this->metatileSelector->getSelectedMetatile());
this->drawSelectedTiles();
this->ui->graphicsView_Tiles->setSceneRect(0, 0, this->tileSelector->pixmap().width() + 2, this->tileSelector->pixmap().height() + 2);
this->ui->graphicsView_Tiles->setFixedSize(this->tileSelector->pixmap().width() + 2, this->tileSelector->pixmap().height() + 2);
this->ui->graphicsView_Metatiles->setSceneRect(0, 0, this->metatileSelector->pixmap().width() + 2, this->metatileSelector->pixmap().height() + 2);
this->ui->graphicsView_Metatiles->setFixedSize(this->metatileSelector->pixmap().width() + 2, this->metatileSelector->pixmap().height() + 2);
this->ui->graphicsView_selectedTile->setFixedSize(this->selectedTilePixmapItem->pixmap().width() + 2, this->selectedTilePixmapItem->pixmap().height() + 2);
}
void TilesetEditor::initMetatileSelector(Map *map)
void TilesetEditor::initMetatileSelector()
{
this->metatileSelector = new TilesetEditorMetatileSelector(this->primaryTileset, this->secondaryTileset, map);
this->metatileSelector = new TilesetEditorMetatileSelector(this->primaryTileset, this->secondaryTileset, this->map);
connect(this->metatileSelector, SIGNAL(hoveredMetatileChanged(uint16_t)),
this, SLOT(onHoveredMetatileChanged(uint16_t)));
connect(this->metatileSelector, SIGNAL(hoveredMetatileCleared()),
@ -170,6 +170,19 @@ void TilesetEditor::initMetatileSelector(Map *map)
this->ui->graphicsView_Metatiles->setFixedSize(this->metatileSelector->pixmap().width() + 2, this->metatileSelector->pixmap().height() + 2);
}
void TilesetEditor::initMetatileLayersItem() {
Metatile *metatile = Tileset::getMetatile(this->metatileSelector->getSelectedMetatile(), this->primaryTileset, this->secondaryTileset);
this->metatileLayersItem = new MetatileLayersItem(metatile, this->primaryTileset, this->secondaryTileset);
connect(this->metatileLayersItem, SIGNAL(tileChanged(int, int)),
this, SLOT(onMetatileLayerTileChanged(int, int)));
connect(this->metatileLayersItem, SIGNAL(selectedTilesChanged(QPoint, int, int)),
this, SLOT(onMetatileLayerSelectionChanged(QPoint, int, int)));
this->metatileLayersScene = new QGraphicsScene;
this->metatileLayersScene->addItem(this->metatileLayersItem);
this->ui->graphicsView_metatileLayers->setScene(this->metatileLayersScene);
}
void TilesetEditor::initTileSelector()
{
this->tileSelector = new TilesetEditorTileSelector(this->primaryTileset, this->secondaryTileset, projectConfig.getTripleLayerMetatilesEnabled());
@ -196,6 +209,40 @@ void TilesetEditor::initSelectedTileItem() {
this->ui->graphicsView_selectedTile->setFixedSize(this->selectedTilePixmapItem->pixmap().width() + 2, this->selectedTilePixmapItem->pixmap().height() + 2);
}
void TilesetEditor::restoreWindowState() {
logInfo("Restoring tileset editor geometry from previous session.");
QMap<QString, QByteArray> geometry = porymapConfig.getTilesetEditorGeometry();
this->restoreGeometry(geometry.value("tileset_editor_geometry"));
this->restoreState(geometry.value("tileset_editor_state"));
}
void TilesetEditor::initMetatileHistory() {
MetatileHistoryItem *commit = new MetatileHistoryItem(0, nullptr, this->metatile->copy());
metatileHistory.push(commit);
}
void TilesetEditor::reset() {
this->hasUnsavedChanges = false;
this->setTilesets(this->primaryTileset->name, this->secondaryTileset->name);
if (this->paletteEditor)
this->paletteEditor->setTilesets(this->primaryTileset, this->secondaryTileset);
this->refresh();
}
void TilesetEditor::refresh() {
this->metatileLayersItem->setTilesets(this->primaryTileset, this->secondaryTileset);
this->tileSelector->setTilesets(this->primaryTileset, this->secondaryTileset);
this->metatileSelector->setTilesets(this->primaryTileset, this->secondaryTileset);
this->metatileSelector->select(this->metatileSelector->getSelectedMetatile());
this->drawSelectedTiles();
this->ui->graphicsView_Tiles->setSceneRect(0, 0, this->tileSelector->pixmap().width() + 2, this->tileSelector->pixmap().height() + 2);
this->ui->graphicsView_Tiles->setFixedSize(this->tileSelector->pixmap().width() + 2, this->tileSelector->pixmap().height() + 2);
this->ui->graphicsView_Metatiles->setSceneRect(0, 0, this->metatileSelector->pixmap().width() + 2, this->metatileSelector->pixmap().height() + 2);
this->ui->graphicsView_Metatiles->setFixedSize(this->metatileSelector->pixmap().width() + 2, this->metatileSelector->pixmap().height() + 2);
this->ui->graphicsView_selectedTile->setFixedSize(this->selectedTilePixmapItem->pixmap().width() + 2, this->selectedTilePixmapItem->pixmap().height() + 2);
}
void TilesetEditor::drawSelectedTiles() {
if (!this->selectedTileScene) {
return;
@ -222,19 +269,6 @@ void TilesetEditor::drawSelectedTiles() {
this->ui->graphicsView_selectedTile->setFixedSize(this->selectedTilePixmapItem->pixmap().width() + 2, this->selectedTilePixmapItem->pixmap().height() + 2);
}
void TilesetEditor::initMetatileLayersItem() {
Metatile *metatile = Tileset::getMetatile(this->metatileSelector->getSelectedMetatile(), this->primaryTileset, this->secondaryTileset);
this->metatileLayersItem = new MetatileLayersItem(metatile, this->primaryTileset, this->secondaryTileset);
connect(this->metatileLayersItem, SIGNAL(tileChanged(int, int)),
this, SLOT(onMetatileLayerTileChanged(int, int)));
connect(this->metatileLayersItem, SIGNAL(selectedTilesChanged(QPoint, int, int)),
this, SLOT(onMetatileLayerSelectionChanged(QPoint, int, int)));
this->metatileLayersScene = new QGraphicsScene;
this->metatileLayersScene->addItem(this->metatileLayersItem);
this->ui->graphicsView_metatileLayers->setScene(this->metatileLayersScene);
}
void TilesetEditor::onHoveredMetatileChanged(uint16_t metatileId) {
Metatile *metatile = Tileset::getMetatile(metatileId, this->primaryTileset, this->secondaryTileset);
QString message;
@ -599,6 +633,7 @@ void TilesetEditor::closeEvent(QCloseEvent *event)
this->on_actionSave_Tileset_triggered();
event->accept();
} else if (result == QMessageBox::No) {
this->reset();
event->accept();
} else if (result == QMessageBox::Cancel) {
event->ignore();
@ -606,6 +641,14 @@ void TilesetEditor::closeEvent(QCloseEvent *event)
} else {
event->accept();
}
if (event->isAccepted()) {
if (this->paletteEditor) this->paletteEditor->close();
porymapConfig.setTilesetEditorGeometry(
this->saveGeometry(),
this->saveState()
);
}
}
void TilesetEditor::on_actionChange_Metatiles_Count_triggered()