Leahnaya/porymap
1
0
Fork 0
mirror of https://github.com/huderlem/porymap.git synced 2026-08-27 19:16:31 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Convert selected_events from DraggablePixmapItem to Event

Browse Source
This commit is contained in:
GriffinR
2025-02-16 18:03:24 -05:00
parent ac8db41299
commit 88f5a90b2f
8 changed files with 86 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/core/map.h
View File

@@ -85,6 +85,7 @@ public:
void removeEvent(Event *);
void addEvent(Event *);
int getIndexOfEvent(Event *) const;
bool hasEvent(Event *) const;
void deleteConnections();
QList<MapConnection*> getConnections() const;

7
include/editor.h
View File

@@ -111,14 +111,13 @@ public:
DraggablePixmapItem *addEventPixmapItem(Event *event);
void removeEventPixmapItem(Event *event);
bool canAddEvents(const QList<Event*> &events);
void selectMapEvent(DraggablePixmapItem *item, bool toggle = false);
void selectMapEvent(Event *event, bool toggle = false);
Event *addNewEvent(Event::Type type);
void updateSelectedEvents();
void updateEvents();
void duplicateSelectedEvents();
void redrawAllEvents();
void redrawEvents(const QList<Event*> &events);
void redrawEventPixmapItem(DraggablePixmapItem *item);
QList<DraggablePixmapItem *> getEventPixmapItems();
qreal getEventOpacity(const Event *event) const;
void updateCursorRectPos(int x, int y);
@@ -153,7 +152,7 @@ public:
CurrentSelectedMetatilesPixmapItem *current_metatile_selection_item = nullptr;
QPointer<MovementPermissionsSelector> movement_permissions_selector_item = nullptr;
QList<DraggablePixmapItem *> *selected_events = nullptr;
QList<Event*> selectedEvents;
QPointer<ConnectionPixmapItem> selected_connection_item = nullptr;
QPointer<MapConnection> connection_to_select = nullptr;

2
include/mainwindow.h
View File

@@ -332,7 +332,7 @@ private:
MapHeaderForm *mapHeaderForm = nullptr;
QMap<Event::Group, DraggablePixmapItem*> lastSelectedEvent;
QMap<Event::Group, Event*> lastSelectedEvent;
bool isProgrammaticEventTabChange;

21
src/core/editcommands.cpp
View File

@@ -328,10 +328,7 @@ void EventCreate::redo() {
map->addEvent(event);
editor->addEventPixmapItem(event);
// select this event
editor->selected_events->clear();
editor->selectMapEvent(event->getPixmapItem());
editor->selectMapEvent(event);
}
void EventCreate::undo() {
@@ -374,9 +371,9 @@ void EventDelete::redo() {
editor->removeEventPixmapItem(event);
}
editor->selected_events->clear();
editor->selectedEvents.clear();
if (nextSelectedEvent)
editor->selected_events->append(nextSelectedEvent->getPixmapItem());
editor->selectedEvents.append(nextSelectedEvent);
editor->shouldReselectEvents();
}
@@ -386,11 +383,7 @@ void EventDelete::undo() {
editor->addEventPixmapItem(event);
}
// select these events
editor->selected_events->clear();
for (Event *event : selectedEvents) {
editor->selected_events->append(event->getPixmapItem());
}
editor->selectedEvents = selectedEvents;
editor->shouldReselectEvents();
QUndoCommand::undo();
@@ -427,11 +420,7 @@ void EventDuplicate::redo() {
editor->addEventPixmapItem(event);
}
// select these events
editor->selected_events->clear();
for (Event *event : selectedEvents) {
editor->selected_events->append(event->getPixmapItem());
}
editor->selectedEvents = selectedEvents;
editor->shouldReselectEvents();
}

4
src/core/map.cpp
View File

@@ -229,6 +229,10 @@ int Map::getIndexOfEvent(Event *event) const {
return m_events.value(event->getEventGroup()).indexOf(event);
}
bool Map::hasEvent(Event *event) const {
return getIndexOfEvent(event) >= 0;
}
void Map::deleteConnections() {
qDeleteAll(m_ownedConnections);
m_ownedConnections.clear();

91
src/editor.cpp
View File

@@ -28,7 +28,6 @@ QList<QList<const QImage*>> Editor::collisionIcons;
Editor::Editor(Ui::MainWindow* ui)
{
this->ui = ui;
this->selected_events = new QList<DraggablePixmapItem*>;
this->settings = new Settings();
this->playerViewRect = new MovableRect(&this->settings->playerViewRectEnabled, 30 * 8, 20 * 8, qRgb(255, 255, 255));
this->cursorMapTileRect = new CursorTileRect(&this->settings->cursorTileRectEnabled, qRgb(255, 255, 255));
@@ -40,7 +39,7 @@ Editor::Editor(Ui::MainWindow* ui)
/// the index is changed.
connect(&editGroup, &QUndoGroup::indexChanged, [this](int) {
if (selectNewEvents) {
updateSelectedEvents();
updateEvents();
selectNewEvents = false;
}
});
@@ -58,7 +57,6 @@ Editor::Editor(Ui::MainWindow* ui)
Editor::~Editor()
{
delete this->selected_events;
delete this->settings;
delete this->playerViewRect;
delete this->cursorMapTileRect;
@@ -1167,7 +1165,7 @@ bool Editor::setMap(QString map_name) {
editGroup.addStack(map->editHistory());
editGroup.setActiveStack(map->editHistory());
selected_events->clear();
this->selectedEvents.clear();
if (!displayMap()) {
return false;
}
@@ -1176,7 +1174,7 @@ bool Editor::setMap(QString map_name) {
connect(map, &Map::openScriptRequested, this, &Editor::openScript);
connect(map, &Map::connectionAdded, this, &Editor::displayConnection);
connect(map, &Map::connectionRemoved, this, &Editor::removeConnectionPixmap);
updateSelectedEvents();
updateEvents();
return true;
}
@@ -1331,8 +1329,8 @@ void Editor::mouseEvent_map(QGraphicsSceneMouseEvent *event, LayoutPixmapItem *i
// Left-clicking while in paint mode will add a new event of the
// type of the first currently selected events.
Event::Type eventType = Event::Type::Object;
if (this->selected_events->size() > 0)
eventType = this->selected_events->first()->event->getEventType();
if (!this->selectedEvents.isEmpty())
eventType = this->selectedEvents.first()->getEventType();
Event* event = addNewEvent(eventType);
if (event && event->getPixmapItem())
@@ -1352,15 +1350,9 @@ void Editor::mouseEvent_map(QGraphicsSceneMouseEvent *event, LayoutPixmapItem *i
if (pos.x() != selection_origin.x() || pos.y() != selection_origin.y()) {
int xDelta = pos.x() - selection_origin.x();
int yDelta = pos.y() - selection_origin.y();
QList<Event *> selectedEvents;
for (DraggablePixmapItem *pixmapItem : getEventPixmapItems()) {
selectedEvents.append(pixmapItem->event);
}
selection_origin = QPoint(pos.x(), pos.y());
map->commit(new EventShift(selectedEvents, xDelta, yDelta, this->eventShiftActionId));
this->map->commit(new EventShift(this->map->getEvents(), xDelta, yDelta, this->eventShiftActionId));
}
}
}
@@ -1661,7 +1653,7 @@ void Editor::clearMapEvents() {
delete events_group;
events_group = nullptr;
}
selected_events->clear();
this->selectedEvents.clear();
}
void Editor::displayMapEvents() {
@@ -1690,7 +1682,7 @@ void Editor::removeEventPixmapItem(Event *event) {
if (!item) return;
this->events_group->removeFromGroup(item);
this->selected_events->removeOne(item);
this->selectedEvents.removeOne(event);
event->setPixmapItem(nullptr);
delete item;
@@ -1955,14 +1947,6 @@ void Editor::redrawEvents(const QList<Event*> &events) {
}
}
QList<DraggablePixmapItem *> Editor::getEventPixmapItems() {
QList<DraggablePixmapItem *> list;
for (QGraphicsItem *child : events_group->childItems()) {
list.append(static_cast<DraggablePixmapItem *>(child));
}
return list;
}
qreal Editor::getEventOpacity(const Event *event) const {
// There are 4 possible opacities for an event's sprite:
// - Off the Events tab, and the event overlay is off (0.0)
@@ -1982,7 +1966,7 @@ void Editor::redrawEventPixmapItem(DraggablePixmapItem *item) {
item->setShapeMode(porymapConfig.eventSelectionShapeMode);
if (this->editMode == EditMode::Events) {
if (selected_events && selected_events->contains(item)) {
if (this->selectedEvents.contains(item->event)) {
// Draw the selection rectangle
QImage image = item->pixmap().toImage();
QPainter painter(&image);
@@ -2027,44 +2011,40 @@ void Editor::updateWarpEventWarning(Event *event) {
void Editor::updateWarpEventWarnings() {
if (porymapConfig.warpBehaviorWarningDisabled)
return;
if (selected_events) {
for (auto selection : *selected_events)
updateWarpEventWarning(selection->event);
}
for (const auto &event : this->selectedEvents)
updateWarpEventWarning(event);
}
void Editor::shouldReselectEvents() {
selectNewEvents = true;
}
void Editor::updateSelectedEvents() {
for (DraggablePixmapItem *item : getEventPixmapItems()) {
redrawEventPixmapItem(item);
}
// TODO: This is frequently used to do more work than necessary.
void Editor::updateEvents() {
redrawAllEvents();
emit eventsChanged();
}
void Editor::selectMapEvent(DraggablePixmapItem *item, bool toggle) {
if (!selected_events || !item)
void Editor::selectMapEvent(Event *event, bool toggle) {
if (!event)
return;
if (!toggle) {
// Selecting just this event
selected_events->clear();
selected_events->append(item);
} else if (!selected_events->contains(item)) {
this->selectedEvents.clear();
this->selectedEvents.append(event);
} else if (!this->selectedEvents.contains(event)) {
// Adding event to group selection
selected_events->append(item);
} else if (selected_events->length() > 1) {
this->selectedEvents.append(event);
} else if (this->selectedEvents.length() > 1) {
// Removing event from group selection
selected_events->removeOne(item);
this->selectedEvents.removeOne(event);
} else {
// Attempting to toggle the only currently-selected event.
// Unselecting an event this way would be unexpected, so we ignore it.
return;
}
updateSelectedEvents();
updateEvents();
}
void Editor::selectedEventIndexChanged(int index, Event::Group eventGroup) {
@@ -2072,10 +2052,10 @@ void Editor::selectedEventIndexChanged(int index, Event::Group eventGroup) {
index = index - event_offs;
Event *event = this->map->getEvent(eventGroup, index);
if (event && event->getPixmapItem()) {
this->selectMapEvent(event->getPixmapItem());
if (event) {
selectMapEvent(event);
} else {
updateSelectedEvents();
updateEvents();
}
}
@@ -2095,12 +2075,12 @@ bool Editor::canAddEvents(const QList<Event*> &events) {
}
void Editor::duplicateSelectedEvents() {
if (!selected_events || !selected_events->length() || !project || !map || !current_view || this->getEditingLayout())
if (this->selectedEvents.isEmpty() || !project || !map || !current_view || this->getEditingLayout())
return;
QList<Event *> duplicatedEvents;
for (int i = 0; i < selected_events->length(); i++) {
duplicatedEvents.append(selected_events->at(i)->event->duplicate());
for (const auto &event : this->selectedEvents) {
duplicatedEvents.append(event->duplicate());
}
if (!canAddEvents(duplicatedEvents)) {
WarningMessage::show(QStringLiteral("Unable to duplicate, the maximum number of events would be exceeded."), ui->graphicsView_Map);
@@ -2142,13 +2122,12 @@ Event *Editor::addNewEvent(Event::Type type) {
}
void Editor::deleteSelectedEvents() {
if (!this->selected_events || this->selected_events->length() == 0 || !this->map || this->editMode != EditMode::Events)
if (this->selectedEvents.isEmpty() || !this->map || this->editMode != EditMode::Events)
return;
QList<Event*> eventsToDelete;
bool skipWarning = porymapConfig.eventDeleteWarningDisabled;
for (DraggablePixmapItem *item : *this->selected_events) {
Event* event = item->event;
for (auto event : this->selectedEvents) {
const QString idName = event->getIdName();
if (skipWarning || idName.isEmpty()) {
eventsToDelete.append(event);
@@ -2166,7 +2145,7 @@ void Editor::deleteSelectedEvents() {
msgBox.setCheckBox(new QCheckBox(QStringLiteral("Don't warn me again")));
QAbstractButton* deleteAllButton = nullptr;
if (this->selected_events->length() > 1) {
if (this->selectedEvents.length() > 1) {
deleteAllButton = msgBox.addButton(QStringLiteral("Delete All"), QMessageBox::DestructiveRole);
msgBox.addButton(QStringLiteral("Skip"), QMessageBox::NoRole);
}
@@ -2191,7 +2170,7 @@ void Editor::deleteSelectedEvents() {
}
}
// TODO: Are we just calling this to invalidate connections?
event->setPixmapItem(item);
event->setPixmapItem(event->getPixmapItem());
}
if (eventsToDelete.isEmpty())
return;
@@ -2308,9 +2287,9 @@ void Editor::eventsView_onMousePress(QMouseEvent *event) {
}
bool multiSelect = event->modifiers() & Qt::ControlModifier;
if (!selectingEvent && !multiSelect && selected_events->length() > 1) {
if (!selectingEvent && !multiSelect && this->selectedEvents.length() > 1) {
// User is clearing group selection by clicking on the background
this->selectMapEvent(selected_events->first());
this->selectMapEvent(this->selectedEvents.first());
}
selectingEvent = false;
}

72
src/mainwindow.cpp
View File

@@ -1027,18 +1027,13 @@ void MainWindow::openWarpMap(QString map_name, int event_id, Event::Group event_
// Select the target event.
int index = event_id - Event::getIndexOffset(event_group);
Event* event = editor->map->getEvent(event_group, index);
Event* event = this->editor->map->getEvent(event_group, index);
if (event) {
auto item = event->getPixmapItem();
if (item) {
editor->selected_events->clear();
editor->selected_events->append(item);
editor->updateSelectedEvents();
return;
}
this->editor->selectMapEvent(event);
} else {
// Can still warp to this map, but can't select the specified event
logWarn(QString("%1 %2 doesn't exist on map '%3'").arg(Event::groupToString(event_group)).arg(event_id).arg(map_name));
}
// Can still warp to this map, but can't select the specified event
logWarn(QString("%1 %2 doesn't exist on map '%3'").arg(Event::groupToString(event_group)).arg(event_id).arg(map_name));
}
void MainWindow::displayMapProperties() {
@@ -1628,15 +1623,8 @@ void MainWindow::copy() {
OrderedJson::object copyObject;
copyObject["object"] = "events";
QList<DraggablePixmapItem *> events;
if (editor->selected_events && editor->selected_events->length()) {
events = *editor->selected_events;
}
OrderedJson::array eventsArray;
for (auto item : events) {
Event *event = item->event;
for (const auto &event : this->editor->selectedEvents) {
OrderedJson::object eventContainer;
eventContainer["event_type"] = Event::typeToString(event->getEventType());
OrderedJson::object eventJson = event->buildEventJson(editor->project);
@@ -1997,31 +1985,32 @@ void MainWindow::displayEventTabs() {
}
void MainWindow::updateEvents() {
QList<DraggablePixmapItem *> items = editor->getEventPixmapItems();
for (auto i = this->lastSelectedEvent.cbegin(), end = this->lastSelectedEvent.cend(); i != end; i++) {
if (i.value() && !items.contains(i.value()))
this->lastSelectedEvent.insert(i.key(), nullptr);
if (this->editor->map) {
for (auto i = this->lastSelectedEvent.begin(); i != this->lastSelectedEvent.end(); i++) {
if (i.value() && !this->editor->map->hasEvent(i.value()))
this->lastSelectedEvent.insert(i.key(), nullptr);
}
}
displayEventTabs();
updateSelectedEvents();
}
void MainWindow::updateSelectedEvents() {
QList<DraggablePixmapItem *> events;
QList<Event*> events;
if (editor->selected_events && editor->selected_events->length()) {
events = *editor->selected_events;
if (!this->editor->selectedEvents.isEmpty()) {
events = this->editor->selectedEvents;
}
else {
QList<Event *> all_events;
if (editor->map) {
all_events = editor->map->getEvents();
QList<Event *> allEvents;
if (this->editor->map) {
allEvents = this->editor->map->getEvents();
}
if (all_events.length()) {
DraggablePixmapItem *selectedEvent = all_events.first()->getPixmapItem();
if (!allEvents.isEmpty()) {
Event *selectedEvent = allEvents.first();
if (selectedEvent) {
editor->selected_events->append(selectedEvent);
editor->redrawEventPixmapItem(selectedEvent);
this->editor->selectedEvents.append(selectedEvent);
this->editor->redrawEventPixmapItem(selectedEvent->getPixmapItem());
events.append(selectedEvent);
}
}
@@ -2034,12 +2023,13 @@ void MainWindow::updateSelectedEvents() {
if (events.length() == 1) {
// single selected event case
Event *current = events[0]->event;
Event *current = events.constFirst();
Event::Group eventGroup = current->getEventGroup();
int event_offs = Event::getIndexOffset(eventGroup);
if (eventGroup != Event::Group::None)
this->lastSelectedEvent.insert(eventGroup, current->getPixmapItem());
if (eventGroup != Event::Group::None) {
this->lastSelectedEvent.insert(eventGroup, current);
}
switch (eventGroup) {
case Event::Group::Object: {
@@ -2110,8 +2100,7 @@ void MainWindow::updateSelectedEvents() {
this->isProgrammaticEventTabChange = false;
QList<QFrame *> frames;
for (DraggablePixmapItem *item : events) {
Event *event = item->event;
for (auto event : events) {
EventFrame *eventFrame = event->createEventFrame();
eventFrame->populate(this->editor->project);
eventFrame->initialize();
@@ -2166,7 +2155,7 @@ Event::Group MainWindow::getEventGroupFromTabWidget(QWidget *tab) {
void MainWindow::eventTabChanged(int index) {
if (editor->map) {
Event::Group group = getEventGroupFromTabWidget(ui->tabWidget_EventType->widget(index));
DraggablePixmapItem *selectedItem = this->lastSelectedEvent.value(group, nullptr);
Event *selectedEvent = this->lastSelectedEvent.value(group, nullptr);
switch (group) {
case Event::Group::Object:
@@ -2189,11 +2178,8 @@ void MainWindow::eventTabChanged(int index) {
}
if (!isProgrammaticEventTabChange) {
if (!selectedItem) {
Event *event = editor->map->getEvent(group, 0);
if (event) selectedItem = event->getPixmapItem();
}
if (selectedItem) editor->selectMapEvent(selectedItem);
if (!selectedEvent) selectedEvent = this->editor->map->getEvent(group, 0);
this->editor->selectMapEvent(selectedEvent);
}
}

18
src/ui/draggablepixmapitem.cpp
View File

@@ -8,11 +8,11 @@ static unsigned currentActionId = 0;
void DraggablePixmapItem::updatePosition() {
int x = event->getPixelX();
int y = event->getPixelY();
int x = this->event->getPixelX();
int y = this->event->getPixelY();
setX(x);
setY(y);
if (editor->selected_events && editor->selected_events->contains(this)) {
if (this->editor->selectedEvents.contains(this->event)) {
setZValue(event->getY() + 1);
} else {
setZValue(event->getY());
@@ -40,10 +40,10 @@ void DraggablePixmapItem::mousePressEvent(QGraphicsSceneMouseEvent *mouse) {
this->lastPos = Metatile::coordFromPixmapCoord(mouse->scenePos());
bool selectionToggle = mouse->modifiers() & Qt::ControlModifier;
if (selectionToggle || !editor->selected_events->contains(this)) {
if (selectionToggle || !this->editor->selectedEvents.contains(this->event)) {
// User is either toggling this selection on/off as part of a group selection,
// or they're newly selecting just this item.
this->editor->selectMapEvent(this, selectionToggle);
this->editor->selectMapEvent(this->event, selectionToggle);
} else {
// This item is already selected and the user isn't toggling the selection, so there are 4 possibilities:
// 1. This is the only selected event, and the selection is pointless.
@@ -84,10 +84,8 @@ void DraggablePixmapItem::mouseMoveEvent(QGraphicsSceneMouseEvent *mouse) {
emit this->editor->map_item->hoveredMapMetatileChanged(pos);
QList <Event *> selectedEvents;
if (editor->selected_events->contains(this)) {
for (DraggablePixmapItem *item : *editor->selected_events) {
selectedEvents.append(item->event);
}
if (this->editor->selectedEvents.contains(this->event)) {
selectedEvents = this->editor->selectedEvents;
} else {
selectedEvents.append(this->event);
}
@@ -103,7 +101,7 @@ void DraggablePixmapItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouse) {
if (this->releaseSelectionQueued) {
this->releaseSelectionQueued = false;
if (Metatile::coordFromPixmapCoord(mouse->scenePos()) == this->lastPos)
this->editor->selectMapEvent(this);
this->editor->selectMapEvent(this->event);
}
}