lots of changes

blockdata.cpp

 #include "blockdata.h"
+#include <QDebug>
 
 Blockdata::Blockdata(QObject *parent) : QObject(parent)
 {
     blockdata->copyFrom(this);
     return blockdata;
 }
+
+bool Blockdata::equals(Blockdata *other) {
+    if (!other) {
+        return false;
+    }
+    if (blocks->length() != other->blocks->length()) {
+        return false;
+    }
+    for (int i = 0; i < blocks->length(); i++) {
+        if (blocks->value(i) != other->blocks->value(i)) {
+            return false;
+        }
+    }
+    return true;
+}

blockdata.h

     explicit Blockdata(QObject *parent = 0);
 
 public:
-    QList<Block> *blocks;
+    QList<Block> *blocks = NULL;
     void addBlock(uint16_t);
     void addBlock(Block);
     QByteArray serialize();
     void copyFrom(Blockdata*);
     Blockdata* copy();
+    bool equals(Blockdata *);
 
 signals:
 

editor.cpp

 #include "editor.h"
+#include <QPainter>
+#include <QMouseEvent>
 
 Editor::Editor()
 {
-
+    selected_events = new QList<DraggablePixmapItem*>;
 }
 
 void Editor::saveProject() {
 
 void Editor::setEditingMap() {
     current_view = map_item;
-    map_item->draw();
-    map_item->setVisible(true);
-    map_item->setEnabled(true);
-    collision_item->setVisible(false);
-    objects_group->setVisible(false);
+    if (map_item) {
+        map_item->draw();
+        map_item->setVisible(true);
+        map_item->setEnabled(true);
+    }
+    if (collision_item) {
+        collision_item->setVisible(false);
+    }
+    if (objects_group) {
+        objects_group->setVisible(false);
+    }
 }
 
 void Editor::setEditingCollision() {
     current_view = collision_item;
-    collision_item->draw();
-    collision_item->setVisible(true);
-    map_item->setVisible(false);
-    objects_group->setVisible(false);
+    if (collision_item) {
+        collision_item->draw();
+        collision_item->setVisible(true);
+    }
+    if (map_item) {
+        map_item->setVisible(false);
+    }
+    if (objects_group) {
+        objects_group->setVisible(false);
+    }
 }
 
 void Editor::setEditingObjects() {
-    objects_group->setVisible(true);
-    map_item->setVisible(true);
-    map_item->setEnabled(false);
-    collision_item->setVisible(false);
+    current_view = map_item;
+    if (objects_group) {
+        objects_group->setVisible(true);
+    }
+    if (map_item) {
+        map_item->setVisible(true);
+        map_item->setEnabled(false);
+    }
+    if (collision_item) {
+        collision_item->setVisible(false);
+    }
 }
 
 void Editor::setMap(QString map_name) {
     if (map_name.isNull()) {
         return;
     }
-    map = project->getMap(map_name);
-    displayMap();
+    if (project) {
+        map = project->loadMap(map_name);
+        displayMap();
+        selected_events->clear();
+        updateSelectedObjects();
+    }
+}
+
+void Editor::mouseEvent_map(QGraphicsSceneMouseEvent *event, MapPixmapItem *item) {
+    if (map_edit_mode == "paint") {
+        item->paint(event);
+    } else if (map_edit_mode == "fill") {
+        item->floodFill(event);
+    } else if (map_edit_mode == "pick") {
+        item->pick(event);
+    } else if (map_edit_mode == "select") {
+        item->select(event);
+    }
+}
+void Editor::mouseEvent_collision(QGraphicsSceneMouseEvent *event, CollisionPixmapItem *item) {
+    if (map_edit_mode == "paint") {
+        item->paint(event);
+    } else if (map_edit_mode == "fill") {
+        item->floodFill(event);
+    } else if (map_edit_mode == "pick") {
+        item->pick(event);
+    } else if (map_edit_mode == "select") {
+        item->select(event);
+    }
 }
 
 void Editor::displayMap() {
     scene = new QGraphicsScene;
 
     map_item = new MapPixmapItem(map);
+    connect(map_item, SIGNAL(mouseEvent(QGraphicsSceneMouseEvent*,MapPixmapItem*)),
+            this, SLOT(mouseEvent_map(QGraphicsSceneMouseEvent*,MapPixmapItem*)));
+
     map_item->draw();
     scene->addItem(map_item);
 
     collision_item = new CollisionPixmapItem(map);
+    connect(collision_item, SIGNAL(mouseEvent(QGraphicsSceneMouseEvent*,CollisionPixmapItem*)),
+            this, SLOT(mouseEvent_collision(QGraphicsSceneMouseEvent*,CollisionPixmapItem*)));
+
     collision_item->draw();
     scene->addItem(collision_item);
 
-    objects_group = new QGraphicsItemGroup;
+    objects_group = new EventGroup;
     scene->addItem(objects_group);
 
-    map_item->setVisible(false);
-    collision_item->setVisible(false);
-    objects_group->setVisible(false);
+    if (map_item) {
+        map_item->setVisible(false);
+    }
+    if (collision_item) {
+        collision_item->setVisible(false);
+    }
+    if (objects_group) {
+        objects_group->setVisible(false);
+    }
 
     int tw = 16;
     int th = 16;
         objects_group->removeFromGroup(child);
     }
 
-    project->loadObjectPixmaps(map->object_events);
-    for (int i = 0; i < map->object_events.length(); i++) {
-        ObjectEvent *object_event = map->object_events.value(i);
-        DraggablePixmapItem *object = new DraggablePixmapItem(object_event);
-        objects_group->addToGroup(object);
+    QList<Event *> events = map->getAllEvents();
+    project->loadObjectPixmaps(events);
+    for (Event *event : events) {
+        addMapObject(event);
     }
-    objects_group->setFiltersChildEvents(false);
+    //objects_group->setFiltersChildEvents(false);
+    objects_group->setHandlesChildEvents(false);
+
+    emit objectsChanged();
+}
+
+DraggablePixmapItem *Editor::addMapObject(Event *event) {
+    DraggablePixmapItem *object = new DraggablePixmapItem(event);
+    object->editor = this;
+    objects_group->addToGroup(object);
+    return object;
 }
 
 void Editor::displayMapConnections() {
         Map *connected_map = project->getMap(connection->map_name);
         QPixmap pixmap = connected_map->renderConnection(*connection);
         int offset = connection->offset.toInt(nullptr, 0);
-        int x, y;
+        int x = 0, y = 0;
         if (connection->direction == "up") {
             x = offset * 16;
             y = -pixmap.height();
             y = offset * 16;
         }
         QGraphicsPixmapItem *item = new QGraphicsPixmapItem(pixmap);
+        item->setZValue(-1);
         item->setX(x);
         item->setY(y);
         scene->addItem(item);
         QGraphicsPixmapItem *item = new QGraphicsPixmapItem(pixmap);
         item->setX(x * 16);
         item->setY(y * 16);
-        item->setZValue(-1);
+        item->setZValue(-2);
         scene->addItem(item);
     }
 }
 
+void MetatilesPixmapItem::paintTileChanged(Map *map) {
+    draw();
+}
 
 void MetatilesPixmapItem::draw() {
     setPixmap(map->renderMetatiles());
 
 void MetatilesPixmapItem::pick(uint tile) {
     map->paint_tile = tile;
-    draw();
+    emit map->paintTileChanged(map);
 }
 
 void MetatilesPixmapItem::mousePressEvent(QGraphicsSceneMouseEvent *event) {
         pick(y * width + x);
     }
 }
+void MetatilesPixmapItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event) {
+    mousePressEvent(event);
+}
 void MetatilesPixmapItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) {
     mousePressEvent(event);
 }
         Block *block = map->getBlock(x, y);
         if (block) {
             block->tile = map->paint_tile;
-            map->setBlock(x, y, *block);
+            map->_setBlock(x, y, *block);
+        }
+        if (event->type() == QEvent::GraphicsSceneMouseRelease) {
+            map->commit();
         }
         draw();
     }
     }
 }
 
+void MapPixmapItem::pick(QGraphicsSceneMouseEvent *event) {
+    QPointF pos = event->pos();
+    int x = (int)(pos.x()) / 16;
+    int y = (int)(pos.y()) / 16;
+    Block *block = map->getBlock(x, y);
+    if (block) {
+        map->paint_tile = block->tile;
+        emit map->paintTileChanged(map);
+    }
+}
+
+#define SWAP(a, b) do { if (a != b) { a ^= b; b ^= a; a ^= b; } } while (0)
+
+void MapPixmapItem::select(QGraphicsSceneMouseEvent *event) {
+    QPointF pos = event->pos();
+    int x = (int)(pos.x()) / 16;
+    int y = (int)(pos.y()) / 16;
+    if (event->type() == QEvent::GraphicsSceneMousePress) {
+        selection_origin = QPoint(x, y);
+        selection.clear();
+    } else if (event->type() == QEvent::GraphicsSceneMouseMove) {
+        if (event->buttons() & Qt::LeftButton) {
+            selection.clear();
+            selection.append(QPoint(x, y));
+        }
+    } else if (event->type() == QEvent::GraphicsSceneMouseRelease) {
+        if (!selection.isEmpty()) {
+            QPoint pos = selection.last();
+            int x1 = selection_origin.x();
+            int y1 = selection_origin.y();
+            int x2 = pos.x();
+            int y2 = pos.y();
+            if (x1 > x2) SWAP(x1, x2);
+            if (y1 > y2) SWAP(y1, y2);
+            selection.clear();
+            for (int y = y1; y <= y2; y++) {
+                for (int x = x1; x <= x2; x++) {
+                    selection.append(QPoint(x, y));
+                }
+            }
+            qDebug() << QString("selected (%1, %2) -> (%3, %4)").arg(x1).arg(y1).arg(x2).arg(y2);
+        }
+    }
+}
+
 void MapPixmapItem::draw() {
-    setPixmap(map->render());
+    if (map) {
+        setPixmap(map->render());
+    }
 }
 
 void MapPixmapItem::undo() {
-    map->undo();
-    draw();
+    if (map) {
+        map->undo();
+        draw();
+    }
 }
 
 void MapPixmapItem::redo() {
-    map->redo();
-    draw();
+    if (map) {
+        map->redo();
+        draw();
+    }
 }
 
 void MapPixmapItem::mousePressEvent(QGraphicsSceneMouseEvent *event) {
-    active = true;
-    if (event->button() == Qt::RightButton) {
-        right_click = true;
-        floodFill(event);
-    } else {
-        right_click = false;
-        paint(event);
-    }
+    emit mouseEvent(event, this);
 }
 void MapPixmapItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event) {
-    if (active) {
-        if (right_click) {
-            floodFill(event);
-        } else {
-            paint(event);
-        }
-    }
+    emit mouseEvent(event, this);
 }
 void MapPixmapItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) {
-    active = false;
+    emit mouseEvent(event, this);
+}
+
+void CollisionPixmapItem::mousePressEvent(QGraphicsSceneMouseEvent *event) {
+    emit mouseEvent(event, this);
+}
+void CollisionPixmapItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event) {
+    emit mouseEvent(event, this);
+}
+void CollisionPixmapItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) {
+    emit mouseEvent(event, this);
 }
 
 void CollisionPixmapItem::draw() {
-    setPixmap(map->renderCollision());
+    if (map) {
+        setPixmap(map->renderCollision());
+    }
 }
 
 void CollisionPixmapItem::paint(QGraphicsSceneMouseEvent *event) {
             if (map->paint_elevation >= 0) {
                 block->elevation = map->paint_elevation;
             }
-            map->setBlock(x, y, *block);
+            map->_setBlock(x, y, *block);
+        }
+        if (event->type() == QEvent::GraphicsSceneMouseRelease) {
+            map->commit();
         }
         draw();
     }
     }
 }
 
+void CollisionPixmapItem::pick(QGraphicsSceneMouseEvent *event) {
+    QPointF pos = event->pos();
+    int x = (int)(pos.x()) / 16;
+    int y = (int)(pos.y()) / 16;
+    Block *block = map->getBlock(x, y);
+    if (block) {
+        map->paint_collision = block->collision;
+        map->paint_elevation = block->elevation;
+        emit map->paintCollisionChanged(map);
+    }
+}
+
 void DraggablePixmapItem::mousePressEvent(QGraphicsSceneMouseEvent *mouse) {
     active = true;
-    last_x = mouse->pos().x() / 16;
-    last_y = mouse->pos().y() / 16;
-    qDebug() << event->x_ + ", " + event->y_;
+    clicking = true;
+    last_x = (mouse->pos().x() + this->pos().x()) / 16;
+    last_y = (mouse->pos().y() + this->pos().y()) / 16;
+    //qDebug() << QString("(%1, %2)").arg(event->get("x")).arg(event->get("y"));
+}
+
+void DraggablePixmapItem::move(int x, int y) {
+    event->setX(event->x() + x);
+    event->setY(event->y() + y);
+    updatePosition();
+    emitPositionChanged();
 }
 
 void DraggablePixmapItem::mouseMoveEvent(QGraphicsSceneMouseEvent *mouse) {
     if (active) {
-        int x = mouse->pos().x() / 16;
-        int y = mouse->pos().y() / 16;
+        int x = (mouse->pos().x() + this->pos().x()) / 16;
+        int y = (mouse->pos().y() + this->pos().y()) / 16;
         if (x != last_x || y != last_y) {
-            event->setX(event->x() + x - last_x);
-            event->setY(event->y() + y - last_y);
-            update();
+            clicking = false;
+            if (editor->selected_events->contains(this)) {
+                for (DraggablePixmapItem *item : *editor->selected_events) {
+                    item->move(x - last_x, y - last_y);
+                }
+            } else {
+                move(x - last_x, y - last_y);
+            }
+            last_x = x;
+            last_y = y;
+            //qDebug() << QString("(%1, %2)").arg(event->get("x")).arg(event->get("x"));
         }
     }
 }
 
 void DraggablePixmapItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouse) {
+    if (clicking) {
+        this->editor->selectMapObject(this, mouse->modifiers() & Qt::ControlModifier);
+        this->editor->updateSelectedObjects();
+    }
     active = false;
 }
+
+QList<DraggablePixmapItem *> *Editor::getObjects() {
+    QList<DraggablePixmapItem *> *list = new QList<DraggablePixmapItem *>;
+    for (Event *event : map->getAllEvents()) {
+        for (QGraphicsItem *child : objects_group->childItems()) {
+            DraggablePixmapItem *item = (DraggablePixmapItem *)child;
+            if (item->event == event) {
+                list->append(item);
+                break;
+            }
+        }
+    }
+    return list;
+}
+
+void Editor::redrawObject(DraggablePixmapItem *item) {
+    if (item) {
+        item->setPixmap(item->event->pixmap);
+        if (selected_events && selected_events->contains(item)) {
+            QImage image = item->pixmap().toImage();
+            QPainter painter(&image);
+            painter.setPen(QColor(250, 100, 25));
+            painter.drawRect(0, 0, image.width() - 1, image.height() - 1);
+            painter.end();
+            item->setPixmap(QPixmap::fromImage(image));
+        }
+    }
+}
+
+void Editor::updateSelectedObjects() {
+    for (DraggablePixmapItem *item : *(getObjects())) {
+        redrawObject(item);
+    }
+    emit selectedObjectsChanged();
+}
+
+void Editor::selectMapObject(DraggablePixmapItem *object) {
+    selectMapObject(object, false);
+}
+
+void Editor::selectMapObject(DraggablePixmapItem *object, bool toggle) {
+    if (selected_events && object) {
+        if (selected_events->contains(object)) {
+            if (toggle) {
+                selected_events->removeOne(object);
+            }
+        } else {
+            if (!toggle) {
+                selected_events->clear();
+            }
+            selected_events->append(object);
+        }
+        updateSelectedObjects();
+    }
+}
+
+DraggablePixmapItem* Editor::addNewEvent() {
+    return addNewEvent("object");
+}
+
+DraggablePixmapItem* Editor::addNewEvent(QString event_type) {
+    if (project && map) {
+        Event *event = new Event;
+        event->put("map_name", map->name);
+        event->put("event_type", event_type);
+        map->addEvent(event);
+        project->loadObjectPixmaps(map->getAllEvents());
+        DraggablePixmapItem *object = addMapObject(event);
+
+        return object;
+    }
+    return NULL;
+}
+
+void Editor::deleteEvent(Event *event) {
+    Map *map = project->getMap(event->get("map_name"));
+    if (map) {
+        map->removeEvent(event);
+    }
+    //selected_events->removeAll(event);
+    //updateSelectedObjects();
+}
+
+
+// dunno how to detect bubbling. QMouseEvent::isAccepted seems to always be true
+// check if selected_events changed instead. this has the side effect of deselecting
+// when you click on a selected event, since selected_events doesn't change.
+
+QList<DraggablePixmapItem *> selected_events_test;
+bool clicking = false;
+
+void Editor::objectsView_onMousePress(QMouseEvent *event) {
+    clicking = true;
+    selected_events_test = *selected_events;
+}
+
+void Editor::objectsView_onMouseMove(QMouseEvent *event) {
+    clicking = false;
+}
+
+void Editor::objectsView_onMouseRelease(QMouseEvent *event) {
+    if (clicking) {
+        if (selected_events_test.length()) {
+            if (selected_events_test.length() == selected_events->length()) {
+                bool deselect = true;
+                for (int i = 0; i < selected_events_test.length(); i++) {
+                    if (selected_events_test.at(i) != selected_events->at(i)) {
+                        deselect = false;
+                        break;
+                    }
+                }
+                if (deselect) {
+                    selected_events->clear();
+                    updateSelectedObjects();
+                }
+            }
+        }
+        clicking = false;
+    }
+}

editor.h

 #include <QGraphicsScene>
 #include <QGraphicsItemGroup>
 #include <QGraphicsSceneMouseEvent>
+#include <QGraphicsItemAnimation>
+#include <QComboBox>
 
 #include "project.h"
 
+class DraggablePixmapItem;
+class MapPixmapItem;
+class CollisionPixmapItem;
+class MetatilesPixmapItem;
+class CollisionMetatilesPixmapItem;
+class ElevationMetatilesPixmapItem;
 
-class DraggablePixmapItem : public QGraphicsPixmapItem {
+class Editor : public QObject
+{
+    Q_OBJECT
+public:
+    Editor();
+public:
+    QObject *parent = NULL;
+    Project *project = NULL;
+    Map *map = NULL;
+    void saveProject();
+    void save();
+    void undo();
+    void redo();
+    void setMap(QString map_name);
+    void displayMap();
+    void displayMetatiles();
+    void displayCollisionMetatiles();
+    void displayElevationMetatiles();
+    void displayMapObjects();
+    void displayMapConnections();
+    void displayMapBorder();
+
+    void setEditingMap();
+    void setEditingCollision();
+    void setEditingObjects();
+
+    DraggablePixmapItem *addMapObject(Event *event);
+    void selectMapObject(DraggablePixmapItem *object);
+    void selectMapObject(DraggablePixmapItem *object, bool toggle);
+    DraggablePixmapItem *addNewEvent();
+    DraggablePixmapItem *addNewEvent(QString event_type);
+    void deleteEvent(Event *);
+    void updateSelectedObjects();
+    void redrawObject(DraggablePixmapItem *item);
+    QList<DraggablePixmapItem *> *getObjects();
+
+    QGraphicsScene *scene = NULL;
+    QGraphicsPixmapItem *current_view = NULL;
+    MapPixmapItem *map_item = NULL;
+    CollisionPixmapItem *collision_item = NULL;
+    QGraphicsItemGroup *objects_group = NULL;
+
+    QGraphicsScene *scene_metatiles = NULL;
+    QGraphicsScene *scene_collision_metatiles = NULL;
+    QGraphicsScene *scene_elevation_metatiles = NULL;
+    MetatilesPixmapItem *metatiles_item = NULL;
+    CollisionMetatilesPixmapItem *collision_metatiles_item = NULL;
+    ElevationMetatilesPixmapItem *elevation_metatiles_item = NULL;
+
+    QList<DraggablePixmapItem*> *events = NULL;
+    QList<DraggablePixmapItem*> *selected_events = NULL;
+
+    QString map_edit_mode;
+
+    void objectsView_onMousePress(QMouseEvent *event);
+    void objectsView_onMouseMove(QMouseEvent *event);
+    void objectsView_onMouseRelease(QMouseEvent *event);
+
+private slots:
+    void mouseEvent_map(QGraphicsSceneMouseEvent *event, MapPixmapItem *item);
+    void mouseEvent_collision(QGraphicsSceneMouseEvent *event, CollisionPixmapItem *item);
+
+signals:
+    void objectsChanged();
+    void selectedObjectsChanged();
+};
+
+
+
+class DraggablePixmapItem : public QObject, public QGraphicsPixmapItem {
+    Q_OBJECT
 public:
     DraggablePixmapItem(QPixmap pixmap): QGraphicsPixmapItem(pixmap) {
     }
-    Event *event;
+    Editor *editor = NULL;
+    Event *event = NULL;
+    QGraphicsItemAnimation *pos_anim = NULL;
     DraggablePixmapItem(Event *event_) : QGraphicsPixmapItem(event_->pixmap) {
         event = event_;
-        update();
+        updatePosition();
     }
     bool active;
     bool right_click;
+    bool clicking;
     int last_x;
     int last_y;
-    void update() {
+    void updatePosition() {
         int x = event->x() * 16;
         int y = event->y() * 16;
         x -= pixmap().width() / 32 * 16;
         setY(y);
         setZValue(event->y());
     }
+    void move(int x, int y);
+    void emitPositionChanged() {
+        emit xChanged(event->x());
+        emit yChanged(event->y());
+        emit elevationChanged(event->elevation());
+    }
+    void updatePixmap() {
+        QList<Event*> objects;
+        objects.append(event);
+        event->pixmap = QPixmap();
+        editor->project->loadObjectPixmaps(objects);
+        editor->redrawObject(this);
+        emit spriteChanged(event->pixmap);
+    }
+    void bind(QComboBox *combo, QString key) {
+        connect(combo, static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::activated),
+                this, [this, key](QString value){
+            this->event->put(key, value);
+        });
+        connect(this, &DraggablePixmapItem::onPropertyChanged,
+                this, [combo, key](QString key2, QString value){
+            if (key2 == key) {
+                combo->addItem(value);
+                combo->setCurrentText(value);
+            }
+        });
+    }
+
+signals:
+    void positionChanged(Event *event);
+    void xChanged(int);
+    void yChanged(int);
+    void elevationChanged(int);
+    void spriteChanged(QPixmap pixmap);
+    void onPropertyChanged(QString key, QString value);
+
+public slots:
+    void set_x(const QString &text) {
+        event->put("x", text);
+        updatePosition();
+    }
+    void set_y(const QString &text) {
+        event->put("y", text);
+        updatePosition();
+    }
+    void set_elevation(const QString &text) {
+        event->put("elevation", text);
+        updatePosition();
+    }
+    void set_sprite(const QString &text) {
+        event->put("sprite", text);
+        updatePixmap();
+    }
+    void set_script(const QString &text) {
+        event->put("script_label", text);
+    }
 
 protected:
     void mousePressEvent(QGraphicsSceneMouseEvent*);
     void mouseReleaseEvent(QGraphicsSceneMouseEvent*);
 };
 
-class MapPixmapItem : public QGraphicsPixmapItem {
+class EventGroup : public QGraphicsItemGroup {
+};
+
+class MapPixmapItem : public QObject, public QGraphicsPixmapItem {
+    Q_OBJECT
 public:
     MapPixmapItem(QPixmap pixmap): QGraphicsPixmapItem(pixmap) {
     }
-    Map *map;
+    Map *map = NULL;
     MapPixmapItem(Map *map_) {
         map = map_;
     }
     bool active;
     bool right_click;
+    QPoint selection_origin;
+    QList<QPoint> selection;
     virtual void paint(QGraphicsSceneMouseEvent*);
     virtual void floodFill(QGraphicsSceneMouseEvent*);
+    virtual void pick(QGraphicsSceneMouseEvent*);
+    virtual void select(QGraphicsSceneMouseEvent*);
     virtual void undo();
     virtual void redo();
     virtual void draw();
 
+signals:
+    void mouseEvent(QGraphicsSceneMouseEvent *, MapPixmapItem *);
+
 protected:
     void mousePressEvent(QGraphicsSceneMouseEvent*);
     void mouseMoveEvent(QGraphicsSceneMouseEvent*);
 };
 
 class CollisionPixmapItem : public MapPixmapItem {
+    Q_OBJECT
 public:
     CollisionPixmapItem(QPixmap pixmap): MapPixmapItem(pixmap) {
     }
     CollisionPixmapItem(Map *map_): MapPixmapItem(map_) {
     }
-
-public:
     virtual void paint(QGraphicsSceneMouseEvent*);
     virtual void floodFill(QGraphicsSceneMouseEvent*);
+    virtual void pick(QGraphicsSceneMouseEvent*);
     virtual void draw();
+
+signals:
+    void mouseEvent(QGraphicsSceneMouseEvent *, CollisionPixmapItem *);
+
+protected:
+    void mousePressEvent(QGraphicsSceneMouseEvent*);
+    void mouseMoveEvent(QGraphicsSceneMouseEvent*);
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent*);
 };
 
-class MetatilesPixmapItem : public QGraphicsPixmapItem {
+class MetatilesPixmapItem : public QObject, public QGraphicsPixmapItem {
+    Q_OBJECT
 public:
     MetatilesPixmapItem(QPixmap pixmap): QGraphicsPixmapItem(pixmap) {
     }
     MetatilesPixmapItem(Map *map_) {
         map = map_;
+        connect(map, SIGNAL(paintTileChanged(Map*)), this, SLOT(paintTileChanged(Map *)));
     }
-    Map* map;
+    Map* map = NULL;
     virtual void pick(uint);
     virtual void draw();
+private slots:
+    void paintTileChanged(Map *map);
 protected:
     void mousePressEvent(QGraphicsSceneMouseEvent*);
+    void mouseMoveEvent(QGraphicsSceneMouseEvent*);
     void mouseReleaseEvent(QGraphicsSceneMouseEvent*);
 };
 
 class CollisionMetatilesPixmapItem : public MetatilesPixmapItem {
+    Q_OBJECT
 public:
     CollisionMetatilesPixmapItem(Map *map_): MetatilesPixmapItem(map_) {
+        connect(map, SIGNAL(paintCollisionChanged(Map*)), this, SLOT(paintCollisionChanged(Map *)));
     }
     virtual void pick(uint collision) {
         map->paint_collision = collision;
     virtual void draw() {
         setPixmap(map->renderCollisionMetatiles());
     }
+private slots:
+    void paintCollisionChanged(Map *map) {
+        draw();
+    }
 };
 
 class ElevationMetatilesPixmapItem : public MetatilesPixmapItem {
+    Q_OBJECT
 public:
     ElevationMetatilesPixmapItem(Map *map_): MetatilesPixmapItem(map_) {
+        connect(map, SIGNAL(paintCollisionChanged(Map*)), this, SLOT(paintCollisionChanged(Map *)));
     }
     virtual void pick(uint elevation) {
         map->paint_elevation = elevation;
     virtual void draw() {
         setPixmap(map->renderElevationMetatiles());
     }
+private slots:
+    void paintCollisionChanged(Map *map) {
+        draw();
+    }
 };
 
 
-class Editor
-{
-public:
-    Editor();
-public:
-    Project *project;
-    Map *map;
-    void saveProject();
-    void save();
-    void undo();
-    void redo();
-    void setMap(QString map_name);
-    void displayMap();
-    void displayMetatiles();
-    void displayCollisionMetatiles();
-    void displayElevationMetatiles();
-    void displayMapObjects();
-    void displayMapConnections();
-    void displayMapBorder();
-
-    void setEditingMap();
-    void setEditingCollision();
-    void setEditingObjects();
-
-    QGraphicsScene *scene;
-    QGraphicsPixmapItem *current_view;
-    MapPixmapItem *map_item;
-    CollisionPixmapItem *collision_item;
-    QGraphicsItemGroup *objects_group;
-
-    QGraphicsScene *scene_metatiles;
-    QGraphicsScene *scene_collision_metatiles;
-    QGraphicsScene *scene_elevation_metatiles;
-    MetatilesPixmapItem *metatiles_item;
-    CollisionMetatilesPixmapItem *collision_metatiles_item;
-    ElevationMetatilesPixmapItem *elevation_metatiles_item;
-};
-
 #endif // EDITOR_H

event.cpp

 
 Event::Event()
 {
-
-}
-
-ObjectEvent::ObjectEvent()
-{
-
-}
-
-Warp::Warp()
-{
-
-}
-
-CoordEvent::CoordEvent()
-{
-
-}
-
-BGEvent::BGEvent()
-{
-
-}
-
-Sign::Sign()
-{
-
-}
-
-Sign::Sign(const BGEvent &bg)
-{
-    x_ = bg.x_;
-    y_ = bg.y_;
-    elevation_ = bg.elevation_;
-    type = bg.type;
-}
-
-HiddenItem::HiddenItem()
-{
-
-}
-
-HiddenItem::HiddenItem(const BGEvent &bg)
-{
-    x_ = bg.x_;
-    y_ = bg.y_;
-    elevation_ = bg.elevation_;
-    type = bg.type;
 }

event.h

 
 #include <QString>
 #include <QPixmap>
+#include <QMap>
 
 class Event
 {
 
 public:
     int x() {
-        return x_.toInt(nullptr, 0);
+        return getInt("x");
     }
     int y() {
-        return y_.toInt(nullptr, 0);
+        return getInt("y");
     }
     int elevation() {
-        return elevation_.toInt(nullptr, 0);
+        return getInt("elevation");
     }
     void setX(int x) {
-        x_ = QString("%1").arg(x);
+        put("x", x);
     }
     void setY(int y) {
-        y_ = QString("%1").arg(y);
+        put("y", y);
     }
-
-    QString x_;
-    QString y_;
-    QString elevation_;
-    QPixmap pixmap;
-};
-
-class ObjectEvent : public Event {
-public:
-    ObjectEvent();
-
-public:
-    QString sprite;
-    QString replacement; // ????
-    QString behavior;
-    QString radius_x;
-    QString radius_y;
-    QString property;
-    QString sight_radius;
-    QString script_label;
-    QString event_flag;
-};
-
-class Warp : public Event {
-public:
-    Warp();
-
-public:
-    QString destination_warp;
-    QString destination_map;
-};
-
-class CoordEvent : public Event {
-public:
-    CoordEvent();
-
-public:
-    QString unknown1;
-    QString unknown2;
-    QString unknown3;
-    QString unknown4;
-    QString script_label;
-};
-
-class BGEvent : public Event {
-public:
-    BGEvent();
-public:
-    bool is_item() {
-        return type.toInt(nullptr, 0) >= 5;
+    QString get(QString key) {
+        return values.value(key);
+    }
+    int getInt(QString key) {
+        return values.value(key).toInt(nullptr, 0);
+    }
+    void put(QString key, int value) {
+        put(key, QString("%1").arg(value));
+    }
+    void put(QString key, QString value) {
+        values.insert(key, value);
     }
-    QString type;
-};
 
-class Sign : public BGEvent {
-public:
-    Sign();
-    Sign(const BGEvent&);
-public:
-    QString script_label;
-};
+    bool is_hidden_item() {
+        return getInt("type") >= 5;
+    }
 
-class HiddenItem : public BGEvent {
-public:
-    HiddenItem();
-    HiddenItem(const BGEvent&);
-public:
-    QString item;
-    QString unknown5;
-    QString unknown6;
+    QMap<QString, QString> values;
+    QPixmap pixmap;
 };
 
 #endif // EVENT_H

graphicsview.cpp

+#include "graphicsview.h"
+
+void GraphicsView::mousePressEvent(QMouseEvent *event) {
+    QGraphicsView::mousePressEvent(event);
+    if (editor) {
+        editor->objectsView_onMousePress(event);
+    }
+}
+
+void GraphicsView::mouseMoveEvent(QMouseEvent *event) {
+    QGraphicsView::mouseMoveEvent(event);
+    if (editor) {
+        editor->objectsView_onMouseMove(event);
+    }
+}
+
+void GraphicsView::mouseReleaseEvent(QMouseEvent *event) {
+    QGraphicsView::mouseReleaseEvent(event);
+    if (editor) {
+        editor->objectsView_onMouseRelease(event);
+    }
+}

graphicsview.h

+#ifndef GRAPHICSVIEW_H
+#define GRAPHICSVIEW_H
+
+#include <QGraphicsView>
+#include <QMouseEvent>
+
+#include "editor.h"
+
+/*
+class GraphicsView_Object : public QObject
+{
+    Q_OBJECT
+
+signals:
+    void onMousePress(QMouseEvent *event);
+    void onMouseMove(QMouseEvent *event);
+    void onMouseRelease(QMouseEvent *event);
+};
+*/
+
+class GraphicsView : public QGraphicsView
+{
+public:
+    GraphicsView() : QGraphicsView() {}
+    GraphicsView(QWidget *parent) : QGraphicsView(parent) {}
+
+public:
+//    GraphicsView_Object object;
+    Editor *editor = NULL;
+protected:
+    void mousePressEvent(QMouseEvent *event);
+    void mouseMoveEvent(QMouseEvent *event);
+    void mouseReleaseEvent(QMouseEvent *event);
+};
+
+//Q_DECLARE_METATYPE(GraphicsView)
+
+#endif // GRAPHICSVIEW_H

mainwindow.cpp

 #include "mainwindow.h"
 #include "ui_mainwindow.h"
 #include "project.h"
+#include "editor.h"
+#include "objectpropertiesframe.h"
+#include "ui_objectpropertiesframe.h"
 
 #include <QDebug>
 #include <QFileDialog>
 #include <QStandardItemModel>
 #include <QShortcut>
 #include <QSettings>
+#include <QSpinBox>
+#include <QTextEdit>
+#include <QSpacerItem>
+#include <QFont>
+#include <QScrollBar>
 
 MainWindow::MainWindow(QWidget *parent) :
     QMainWindow(parent),
     QCoreApplication::setOrganizationName("pret");
     QCoreApplication::setApplicationName("pretmap");
 
+    ui->setupUi(this);
+    new QShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Z), this, SLOT(redo()));
+
     editor = new Editor;
+    connect(editor, SIGNAL(objectsChanged()), this, SLOT(updateSelectedObjects()));
+    connect(editor, SIGNAL(selectedObjectsChanged()), this, SLOT(updateSelectedObjects()));
 
-    new QShortcut(QKeySequence(Qt::CTRL + Qt::SHIFT + Qt::Key_Z), this, SLOT(redo()));
-    ui->setupUi(this);
+    on_toolButton_Paint_clicked();
 
     QSettings settings;
     QString key = "recent_projects";
     if (settings.contains(key)) {
         QString default_dir = settings.value(key).toStringList().last();
-        openProject(default_dir);
+        if (!default_dir.isNull()) {
+            qDebug() << QString("default_dir: '%1'").arg(default_dir);
+            openProject(default_dir);
+        }
     }
 }
 
 }
 
 void MainWindow::openProject(QString dir) {
-    bool already_open = (editor->project != NULL) && (editor->project->root == dir);
+    if (dir.isNull()) {
+        return;
+    }
+    bool already_open = (
+        (editor != NULL && editor != nullptr)
+        && (editor->project != NULL && editor->project != nullptr)
+        && (editor->project->root == dir)
+    );
     if (!already_open) {
         editor->project = new Project;
         editor->project->root = dir;
+        setWindowTitle(editor->project->getProjectTitle() + " - pretmap");
         populateMapList();
         setMap(getDefaultMap());
     } else {
+        setWindowTitle(editor->project->getProjectTitle() + " - pretmap");
         populateMapList();
     }
 }
 
 QString MainWindow::getDefaultMap() {
-    QSettings settings;
-    QString key = "project:" + editor->project->root;
-    if (settings.contains(key)) {
-        QMap<QString, QVariant> qmap = settings.value(key).toMap();
-        if (qmap.contains("recent_map")) {
-            QString map_name = qmap.value("recent_map").toString();
-            return map_name;
-        }
-    }
-    // Failing that, just get the first map in the list.
-    for (int i = 0; i < editor->project->groupedMapNames->length(); i++) {
-        QStringList *list = editor->project->groupedMapNames->value(i);
-        if (list->length()) {
-            return list->value(0);
+    if (editor && editor->project) {
+        QList<QStringList*> *names = editor->project->groupedMapNames;
+        if (names) {
+            QSettings settings;
+            QString key = "project:" + editor->project->root;
+            if (settings.contains(key)) {
+                QMap<QString, QVariant> qmap = settings.value(key).toMap();
+                if (qmap.contains("recent_map")) {
+                    QString map_name = qmap.value("recent_map").toString();
+                    for (int i = 0; i < names->length(); i++) {
+                        if (names->value(i)->contains(map_name)) {
+                            return map_name;
+                        }
+                    }
+                }
+            }
+            // Failing that, just get the first map in the list.
+            for (int i = 0; i < names->length(); i++) {
+                QStringList *list = names->value(i);
+                if (list->length()) {
+                    return list->value(0);
+                }
+            }
         }
     }
-    return NULL;
+    return QString();
 }
 
 QString MainWindow::getExistingDirectory(QString dir) {
 }
 
 void MainWindow::setMap(QString map_name) {
+    qDebug() << QString("setMap(%1)").arg(map_name);
     if (map_name.isNull()) {
         return;
     }
     ui->graphicsView_Objects_Map->setScene(editor->scene);
     ui->graphicsView_Objects_Map->setSceneRect(editor->scene->sceneRect());
     ui->graphicsView_Objects_Map->setFixedSize(editor->scene->width() + 2, editor->scene->height() + 2);
+    ui->graphicsView_Objects_Map->editor = editor;
 
     ui->graphicsView_Metatiles->setScene(editor->scene_metatiles);
     //ui->graphicsView_Metatiles->setSceneRect(editor->scene_metatiles->sceneRect());
 
     displayMapProperties();
 
+    setWindowTitle(map_name + " - " + editor->project->getProjectTitle() + " - pretmap");
+
+    connect(editor->map, SIGNAL(mapChanged(Map*)), this, SLOT(onMapChanged(Map *)));
+
     setRecentMap(map_name);
     updateMapList();
 }
 }
 
 void MainWindow::displayMapProperties() {
+    ui->comboBox_Song->clear();
+    ui->comboBox_Location->clear();
+    ui->comboBox_Visibility->clear();
+    ui->comboBox_Weather->clear();
+    ui->comboBox_Type->clear();
+    ui->comboBox_BattleScene->clear();
+    ui->checkBox_ShowLocation->setChecked(false);
+    if (!editor || !editor->map || !editor->project) {
+        ui->frame_3->setEnabled(false);
+        return;
+    }
+    ui->frame_3->setEnabled(true);
     Map *map = editor->map;
     Project *project = editor->project;
 
     QStringList songs = project->getSongNames();
-    ui->comboBox_Song->clear();
     ui->comboBox_Song->addItems(songs);
     QString song = map->song;
     if (!songs.contains(song)) {
     }
     ui->comboBox_Song->setCurrentText(song);
 
-    ui->comboBox_Location->clear();
     ui->comboBox_Location->addItems(project->getLocations());
     ui->comboBox_Location->setCurrentText(map->location);
 
-    ui->comboBox_Visibility->clear();
     ui->comboBox_Visibility->addItems(project->getVisibilities());
     ui->comboBox_Visibility->setCurrentText(map->visibility);
 
-    ui->comboBox_Weather->clear();
     ui->comboBox_Weather->addItems(project->getWeathers());
     ui->comboBox_Weather->setCurrentText(map->weather);
 
-    ui->comboBox_Type->clear();
     ui->comboBox_Type->addItems(project->getMapTypes());
     ui->comboBox_Type->setCurrentText(map->type);
 
-    ui->comboBox_BattleScene->clear();
     ui->comboBox_BattleScene->addItems(project->getBattleScenes());
     ui->comboBox_BattleScene->setCurrentText(map->battle_scene);
 
 
 void MainWindow::on_comboBox_Song_activated(const QString &song)
 {
-    editor->map->song = song;
+    if (editor && editor->map) {
+        editor->map->song = song;
+    }
 }
 
 void MainWindow::on_comboBox_Location_activated(const QString &location)
 {
-    editor->map->location = location;
+    if (editor && editor->map) {
+        editor->map->location = location;
+    }
 }
 
 void MainWindow::on_comboBox_Visibility_activated(const QString &visibility)
 {
-    editor->map->visibility = visibility;
+    if (editor && editor->map) {
+        editor->map->visibility = visibility;
+    }
 }
 
 void MainWindow::on_comboBox_Weather_activated(const QString &weather)
 {
-    editor->map->weather = weather;
+    if (editor && editor->map) {
+        editor->map->weather = weather;
+    }
 }
 
 void MainWindow::on_comboBox_Type_activated(const QString &type)
 {
-    editor->map->type = type;
+    if (editor && editor->map) {
+        editor->map->type = type;
+    }
 }
 
 void MainWindow::on_comboBox_BattleScene_activated(const QString &battle_scene)
 {
-    editor->map->battle_scene = battle_scene;
+    if (editor && editor->map) {
+        editor->map->battle_scene = battle_scene;
+    }
 }
 
 void MainWindow::on_checkBox_ShowLocation_clicked(bool checked)
 {
-    if (checked) {
-        editor->map->show_location = "TRUE";
-    } else {
-        editor->map->show_location = "FALSE";
+    if (editor && editor->map) {
+        if (checked) {
+            editor->map->show_location = "TRUE";
+        } else {
+            editor->map->show_location = "FALSE";
+        }
     }
 }
 
     if (!data.isNull()) {
         setMap(data.toString());
     }
-    updateMapList();
+    //updateMapList();
 }
 
 void MainWindow::markAllEdited(QAbstractItemModel *model) {
             if (editor->project->map_cache->contains(map_name)) {
                 // Just mark anything that's been opened for now.
                 // TODO if (project->getMap()->saved)
-                ui->mapList->setExpanded(index, true);
+                //ui->mapList->setExpanded(index, true);
+                ui->mapList->setExpanded(index, editor->project->map_cache->value(map_name)->hasUnsavedChanges());
             }
         }
     }
 
 void MainWindow::on_action_Save_triggered() {
     editor->save();
+    updateMapList();
 }
 
 void MainWindow::on_tabWidget_2_currentChanged(int index)
 {
     redo();
 }
+
+void MainWindow::on_toolButton_newObject_clicked()
+{
+    if (editor) {
+        DraggablePixmapItem *object = editor->addNewEvent();
+        if (object) {
+            //if (editor->selected_events->length()) {
+                editor->selectMapObject(object, true);
+            //}
+        }
+        updateSelectedObjects();
+    }
+}
+
+// Should probably just pass layout and let the editor work it out
+void MainWindow::updateSelectedObjects() {
+
+    QList<DraggablePixmapItem *> *all_events = editor->getObjects();
+    QList<DraggablePixmapItem *> *events = all_events;
+
+    if (editor->selected_events && editor->selected_events->length()) {
+        events = editor->selected_events;
+    }
+
+    QMap<QString, int> map_obj_gfx_constants = editor->project->getMapObjGfxConstants();
+
+    QList<ObjectPropertiesFrame *> frames;
+
+    for (DraggablePixmapItem *item : *events) {
+        ObjectPropertiesFrame *frame = new ObjectPropertiesFrame;
+//        frame->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
+
+        QSpinBox *x = frame->ui->spinBox_x;
+        QSpinBox *y = frame->ui->spinBox_y;
+        QSpinBox *z = frame->ui->spinBox_z;
+
+        x->setValue(item->event->x());
+        connect(x, SIGNAL(valueChanged(QString)), item, SLOT(set_x(QString)));
+        connect(item, SIGNAL(xChanged(int)), x, SLOT(setValue(int)));
+
+        y->setValue(item->event->y());
+        connect(y, SIGNAL(valueChanged(QString)), item, SLOT(set_y(QString)));
+        connect(item, SIGNAL(yChanged(int)), y, SLOT(setValue(int)));
+
+        z->setValue(item->event->elevation());
+        connect(z, SIGNAL(valueChanged(QString)), item, SLOT(set_elevation(QString)));
+        connect(item, SIGNAL(elevationChanged(int)), z, SLOT(setValue(int)));
+
+        QFont font;
+        font.setCapitalization(QFont::Capitalize);
+        frame->ui->label_name->setFont(font);
+        QString event_type = item->event->get("event_type");
+        QString map_name = item->event->get("map_name");
+        frame->ui->label_name->setText(
+            QString("%1 %2 %3")
+                .arg(map_name)
+                .arg(event_type)
+                .arg(editor->project->getMap(map_name)->events.value(event_type).indexOf(item->event) + 1)
+        );
+
+        frame->ui->label_spritePixmap->setPixmap(item->event->pixmap);
+        connect(item, SIGNAL(spriteChanged(QPixmap)), frame->ui->label_spritePixmap, SLOT(setPixmap(QPixmap)));
+
+        frame->ui->sprite->setVisible(false);
+
+        QMap<QString, QString> field_labels;
+        field_labels["script_label"] = "Script";
+        field_labels["event_flag"] = "Event Flag";
+        field_labels["replacement"] = "Replacement";
+        field_labels["property"] = "Property";
+        field_labels["sight_radius"] = "Sight Radius";
+        field_labels["destination_warp"] = "Destination Warp";
+        field_labels["destination_map"] = "Destination Map";
+        field_labels["coord_unknown1"] = "Unknown 1";
+        field_labels["coord_unknown2"] = "Unknown 2";
+        field_labels["type"] = "Type";
+        field_labels["item"] = "Item";
+        field_labels["item_unknown5"] = "Unknown 5";
+        field_labels["item_unknown6"] = "Unknown 6";
+
+        QStringList fields;
+
+        if (event_type == "object") {
+
+            frame->ui->sprite->setVisible(true);
+            frame->ui->comboBox_sprite->addItems(map_obj_gfx_constants.keys());
+            frame->ui->comboBox_sprite->setCurrentText(item->event->get("sprite"));
+            connect(frame->ui->comboBox_sprite, SIGNAL(activated(QString)), item, SLOT(set_sprite(QString)));
+
+            /*
+            frame->ui->script->setVisible(true);
+            frame->ui->comboBox_script->addItem(item->event->get("script_label"));
+            frame->ui->comboBox_script->setCurrentText(item->event->get("script_label"));
+            //item->bind(frame->ui->comboBox_script, "script_label");
+            connect(frame->ui->comboBox_script, SIGNAL(activated(QString)), item, SLOT(set_script(QString)));
+            //connect(frame->ui->comboBox_script, static_cast<void (QComboBox::*)(const QString&)>(&QComboBox::activated), item, [item](QString script_label){ item->event->put("script_label", script_label); });
+            //connect(item, SIGNAL(scriptChanged(QString)), frame->ui->comboBox_script, SLOT(setValue(QString)));
+            */
+
+            fields << "script_label";
+            fields << "event_flag";
+            fields << "replacement";
+            fields << "property";
+            fields << "sight_radius";
+        }
+        else if (event_type == "warp") {
+            fields << "destination_warp";
+            fields << "destination_map";
+        }
+        else if (event_type == "trap") {
+            fields << "script_label";
+            fields << "coord_unknown1";
+            fields << "coord_unknown2";
+        }
+        else if (event_type == "sign") {
+            fields << "type";
+            fields << "script_label";
+        }
+        else if (event_type == "hidden item") {
+            fields << "type";
+            fields << "item";
+            fields << "item_unknown5";
+            fields << "item_unknown6";
+        }
+
+        for (QString key : fields) {
+            QWidget *widget = new QWidget(frame);
+            QFormLayout *fl = new QFormLayout(widget);
+            fl->setContentsMargins(9, 0, 9, 0);
+            QComboBox *combo = new QComboBox(widget);
+            combo->setEditable(true);
+
+            QString value = item->event->get(key);
+            if (key == "destination_map") {
+                if (!editor->project->mapNames->contains(value)) {
+                    combo->addItem(value);
+                }
+                combo->addItems(*editor->project->mapNames);
+            } else {
+                combo->addItem(value);
+            }
+            combo->setCurrentText(value);
+
+            fl->addRow(new QLabel(field_labels[key], widget), combo);
+            widget->setLayout(fl);
+            frame->layout()->addWidget(widget);
+
+            item->bind(combo, key);
+        }
+
+        frames.append(frame);
+
+    }
+
+    //int scroll = ui->scrollArea_4->verticalScrollBar()->value();
+
+    QWidget *target = ui->scrollAreaWidgetContents;
+
+    if (target->children().length()) {
+        qDeleteAll(target->children());
+    }
+
+    QVBoxLayout *layout = new QVBoxLayout(target);
+    target->setLayout(layout);
+    ui->scrollArea_4->setWidgetResizable(true);
+    ui->scrollArea_4->setWidget(target);
+
+    for (ObjectPropertiesFrame *frame : frames) {
+        layout->addWidget(frame);
+    }
+
+    layout->addStretch(1);
+
+    // doesn't work
+    //QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
+    //ui->scrollArea_4->ensureVisible(0, scroll);
+}
+
+void MainWindow::on_toolButton_deleteObject_clicked()
+{
+    if (editor && editor->selected_events) {
+        if (editor->selected_events->length()) {
+            for (DraggablePixmapItem *item : *editor->selected_events) {
+                editor->deleteEvent(item->event);
+                if (editor->scene->items().contains(item)) {
+                    editor->scene->removeItem(item);
+                }
+                editor->selected_events->removeOne(item);
+            }
+            updateSelectedObjects();
+        }
+    }
+}
+
+void MainWindow::on_toolButton_Paint_clicked()
+{
+    editor->map_edit_mode = "paint";
+    checkToolButtons();
+}
+
+void MainWindow::on_toolButton_Select_clicked()
+{
+    editor->map_edit_mode = "select";
+    checkToolButtons();
+}
+
+void MainWindow::on_toolButton_Fill_clicked()
+{
+    editor->map_edit_mode = "fill";
+    checkToolButtons();
+}
+
+void MainWindow::on_toolButton_Dropper_clicked()
+{
+    editor->map_edit_mode = "pick";
+    checkToolButtons();
+}
+
+void MainWindow::checkToolButtons() {
+    ui->toolButton_Paint->setChecked(editor->map_edit_mode == "paint");
+    ui->toolButton_Select->setChecked(editor->map_edit_mode == "select");
+    ui->toolButton_Fill->setChecked(editor->map_edit_mode == "fill");
+    ui->toolButton_Dropper->setChecked(editor->map_edit_mode == "pick");
+}
+
+void MainWindow::onMapChanged(Map *map) {
+    updateMapList();
+}

mainwindow.h

     void undo();
     void redo();
 
+    void onMapChanged(Map *map);
+
     void on_action_Save_triggered();
     void on_tabWidget_2_currentChanged(int index);
     void on_action_Exit_triggered();
 
     void on_actionRedo_triggered();
 
+    void on_toolButton_newObject_clicked();
+
+    void on_toolButton_deleteObject_clicked();
+
+    void updateSelectedObjects();
+
+    void on_toolButton_Paint_clicked();
+
+    void on_toolButton_Select_clicked();
+
+    void on_toolButton_Fill_clicked();
+
+    void on_toolButton_Dropper_clicked();
+
 private:
     Ui::MainWindow *ui;
-    Editor *editor;
+    Editor *editor = NULL;
     void setMap(QString);
     void populateMapList();
     QString getExistingDirectory(QString);
     void updateMapList();
 
     void displayMapProperties();
+    void checkToolButtons();
 };
 
 #endif // MAINWINDOW_H

map.cpp

 #include <QTime>
 #include <QDebug>
 #include <QPainter>
+#include <QImage>
 
 Map::Map(QObject *parent) : QObject(parent)
 {
+    blockdata = new Blockdata;
     cached_blockdata = new Blockdata;
     cached_collision = new Blockdata;
     cached_border = new Blockdata;
     return height.toInt(nullptr, 0);
 }
 
-Tileset* Map::getBlockTileset(uint metatile_index) {
-    uint primary_size = 0x200;//tileset_primary->metatiles->length();
+Tileset* Map::getBlockTileset(int metatile_index) {
+    int primary_size = 0x200;//tileset_primary->metatiles->length();
     if (metatile_index < primary_size) {
         return tileset_primary;
     } else {
     }
 }
 
-QImage Map::getMetatileTile(uint tile) {
-    uint primary_size = 0x200;//tileset_primary->metatiles->length();
-    if (tile < primary_size) {
-        return tileset_primary->tiles->value(tile);
-    } else {
-        return tileset_secondary->tiles->value(tile - primary_size);
+QList<QList<QRgb>> Map::getBlockPalettes(int metatile_index) {
+    QList<QList<QRgb>> palettes;
+    for (int i = 0; i < 6; i++) {
+        palettes.append(tileset_primary->palettes->at(i));
+    }
+    for (int i = 6; i < tileset_secondary->palettes->length(); i++) {
+        palettes.append(tileset_secondary->palettes->at(i));
     }
+    return palettes;
 }
 
-Metatile* Map::getMetatile(uint index) {
-    uint primary_size = 0x200;//tileset_primary->metatiles->length();
+int Map::getBlockIndex(int index) {
+    int primary_size = 0x200;
     if (index < primary_size) {
-        return tileset_primary->metatiles->value(index);
+        return index;
     } else {
-        //qDebug() << QString("secondary tileset: %1").arg(index - primary_size, 0, 16);
-        return tileset_secondary->metatiles->value(index - primary_size);
+        return index - primary_size;
+    }
+}
+
+QImage Map::getMetatileTile(int tile) {
+    Tileset *tileset = getBlockTileset(tile);
+    int local_index = getBlockIndex(tile);
+    if (!tileset || !tileset->tiles) {
+        return QImage();
+    }
+    return tileset->tiles->value(local_index, QImage());
+}
+
+Metatile* Map::getMetatile(int index) {
+    Tileset *tileset = getBlockTileset(index);
+    int local_index = getBlockIndex(index);
+    if (!tileset || !tileset->metatiles) {
+        return NULL;
     }
+    Metatile *metatile = tileset->metatiles->value(local_index, NULL);
+    return metatile;
 }
 
 QImage Map::getCollisionMetatileImage(Block block) {
     return metatile_image;
 }
 
-QImage Map::getMetatileImage(uint tile) {
+QImage Map::getMetatileImage(int tile) {
 
     QImage metatile_image(16, 16, QImage::Format_RGBA8888);
 
     Metatile* metatile = getMetatile(tile);
-    if (metatile == NULL) {
+    if (!metatile || !metatile->tiles) {
         metatile_image.fill(0xffffffff);
         return metatile_image;
     }
 
     Tileset* blockTileset = getBlockTileset(tile);
+    if (!blockTileset) {
+        metatile_image.fill(0xffffffff);
+        return metatile_image;
+    }
+    QList<QList<QRgb>> palettes = getBlockPalettes(tile);
 
+    QPainter metatile_painter(&metatile_image);
     for (int layer = 0; layer < 2; layer++)
     for (int y = 0; y < 2; y++)
     for (int x = 0; x < 2; x++) {
-        //qDebug() << QString("x=%1 y=%2 layer=%3").arg(x).arg(y).arg(layer);
-        Tile tile = metatile->tiles->value((y * 2) + x + (layer * 4));
-        QImage tile_image = getMetatileTile(tile.tile);
-        QList<QRgb> palette = blockTileset->palettes->value(tile.palette);
-        for (int j = 0; j < palette.length(); j++) {
-            tile_image.setColor(j, palette.value(j));
-        }
+        Tile tile_ = metatile->tiles->value((y * 2) + x + (layer * 4));
+        QImage tile_image = getMetatileTile(tile_.tile);
+        //if (tile_image.isNull()) {
+        //    continue;
+        //}
+        //if (blockTileset->palettes) {
+            QList<QRgb> palette = palettes.value(tile_.palette);
+            for (int j = 0; j < palette.length(); j++) {
+                tile_image.setColor(j, palette.value(j));
+            }
+        //}
         //QVector<QRgb> vector = palette.toVector();
         //tile_image.setColorTable(vector);
         if (layer > 0) {
             color.setAlpha(0);
             tile_image.setColor(15, color.rgba());
         }
-        QPainter metatile_painter(&metatile_image);
         QPoint origin = QPoint(x*8, y*8);
-        metatile_painter.drawImage(origin, tile_image.mirrored(tile.xflip == 1, tile.yflip == 1));
-        metatile_painter.end();
+        metatile_painter.drawImage(origin, tile_image.mirrored(tile_.xflip == 1, tile_.yflip == 1));
     }
+    metatile_painter.end();
 
     return metatile_image;
 }
 
 bool Map::blockChanged(int i, Blockdata *cache) {
+    if (cache == NULL || cache == nullptr) {
+        return true;
+    }
+    if (blockdata == NULL || blockdata == nullptr) {
+        return true;
+    }
+    if (cache->blocks == NULL || cache->blocks == nullptr) {
+        return true;
+    }
+    if (blockdata->blocks == NULL || blockdata->blocks == nullptr) {
+        return true;
+    }
     if (cache->blocks->length() <= i) {
         return true;
     }
+    if (blockdata->blocks->length() <= i) {
+        return true;
+    }
     return blockdata->blocks->value(i) != cache->blocks->value(i);
 }
 
 void Map::cacheBorder() {
+    if (cached_border) delete cached_border;
     cached_border = new Blockdata;
-    for (int i = 0; i < border->blocks->length(); i++) {
-        Block block = border->blocks->value(i);
-        cached_border->blocks->append(block);
+    if (border && border->blocks) {
+        for (int i = 0; i < border->blocks->length(); i++) {
+            Block block = border->blocks->value(i);
+            cached_border->blocks->append(block);
+        }
     }
 }
 
 void Map::cacheBlockdata() {
+    if (cached_blockdata) delete cached_blockdata;
     cached_blockdata = new Blockdata;
-    for (int i = 0; i < blockdata->blocks->length(); i++) {
-        Block block = blockdata->blocks->value(i);
-        cached_blockdata->blocks->append(block);
+    if (blockdata && blockdata->blocks) {
+        for (int i = 0; i < blockdata->blocks->length(); i++) {
+            Block block = blockdata->blocks->value(i);
+            cached_blockdata->blocks->append(block);
+        }
     }
 }
 
 void Map::cacheCollision() {
+    if (cached_collision) delete cached_collision;
     cached_collision = new Blockdata;
-    for (int i = 0; i < blockdata->blocks->length(); i++) {
-        Block block = blockdata->blocks->value(i);
-        cached_collision->blocks->append(block);
+    if (blockdata && blockdata->blocks) {
+        for (int i = 0; i < blockdata->blocks->length(); i++) {
+            Block block = blockdata->blocks->value(i);
+            cached_collision->blocks->append(block);
+        }
     }
 }
 
         collision_image = QImage(width_ * 16, height_ * 16, QImage::Format_RGBA8888);
         changed_any = true;
     }
+    if (!(blockdata && blockdata->blocks && width_ && height_)) {
+        collision_pixmap = collision_pixmap.fromImage(collision_image);
+        return collision_pixmap;
+    }
     QPainter painter(&collision_image);
     for (int i = 0; i < blockdata->blocks->length(); i++) {
-        if (!blockChanged(i, cached_collision)) {
+        if (cached_collision && !blockChanged(i, cached_collision)) {
             continue;
         }
         changed_any = true;
         QImage metatile_image = getMetatileImage(block.tile);
         QImage collision_metatile_image = getCollisionMetatileImage(block);
         QImage elevation_metatile_image = getElevationMetatileImage(block);
-        int map_y = i / width_;
-        int map_x = i % width_;
+        int map_y = width_ ? i / width_ : 0;
+        int map_x = width_ ? i % width_ : 0;
         QPoint metatile_origin = QPoint(map_x * 16, map_y * 16);
         painter.setOpacity(1);
         painter.drawImage(metatile_origin, metatile_image);
         image = QImage(width_ * 16, height_ * 16, QImage::Format_RGBA8888);
         changed_any = true;
     }
+    if (!(blockdata && blockdata->blocks && width_ && height_)) {
+        pixmap = pixmap.fromImage(image);
+        return pixmap;
+    }
+
     QPainter painter(&image);
     for (int i = 0; i < blockdata->blocks->length(); i++) {
         if (!blockChanged(i, cached_blockdata)) {
         changed_any = true;
         Block block = blockdata->blocks->value(i);
         QImage metatile_image = getMetatileImage(block.tile);
-        int map_y = i / width_;
-        int map_x = i % width_;
+        int map_y = width_ ? i / width_ : 0;
+        int map_x = width_ ? i % width_ : 0;
         QPoint metatile_origin = QPoint(map_x * 16, map_y * 16);
         painter.drawImage(metatile_origin, metatile_image);
     }
         border_image = QImage(width_ * 16, height_ * 16, QImage::Format_RGBA8888);
         changed_any = true;
     }
+    if (!(border && border->blocks)) {
+        border_pixmap = border_pixmap.fromImage(border_image);
+        return border_pixmap;
+    }
     QPainter painter(&border_image);
     for (int i = 0; i < border->blocks->length(); i++) {
         if (!blockChanged(i, cached_border)) {
 }
 
 QPixmap Map::renderMetatiles() {
+    if (!tileset_primary || !tileset_primary->metatiles || !tileset_secondary || !tileset_secondary->metatiles) {
+        return QPixmap();
+    }
     int primary_length = tileset_primary->metatiles->length();
     int length_ = primary_length + tileset_secondary->metatiles->length();
     int width_ = 8;
     QImage image(width_ * 16, height_ * 16, QImage::Format_RGBA8888);
     QPainter painter(&image);
     for (int i = 0; i < length_; i++) {
-        uint tile = i;
+        int tile = i;
         if (i >= primary_length) {
             tile += 0x200 - primary_length;
         }
 }
 
 Block* Map::getBlock(int x, int y) {
-    if (x >= 0 && x < getWidth())
-    if (y >= 0 && y < getHeight()) {
-        int i = y * getWidth() + x;
-        return new Block(blockdata->blocks->value(i));
+    if (blockdata && blockdata->blocks) {
+        if (x >= 0 && x < getWidth())
+        if (y >= 0 && y < getHeight()) {
+            int i = y * getWidth() + x;
+            return new Block(blockdata->blocks->value(i));
+        }
     }
     return NULL;
 }
 
 void Map::_setBlock(int x, int y, Block block) {
     int i = y * getWidth() + x;
-    blockdata->blocks->replace(i, block);
+    if (blockdata && blockdata->blocks) {
+        blockdata->blocks->replace(i, block);
+    }
 }
 
 void Map::_floodFill(int x, int y, uint tile) {
 
 
 void Map::undo() {
-    Blockdata *commit = history.pop();
-    if (commit != NULL) {
-        blockdata->copyFrom(commit);
+    if (blockdata) {
+        Blockdata *commit = history.pop();
+        if (commit != NULL) {
+            blockdata->copyFrom(commit);
+            emit mapChanged(this);
+        }
     }
 }
 
 void Map::redo() {
-    Blockdata *commit = history.next();
-    if (commit != NULL) {
-        blockdata->copyFrom(commit);
+    if (blockdata) {
+        Blockdata *commit = history.next();
+        if (commit != NULL) {
+            blockdata->copyFrom(commit);
+            emit mapChanged(this);
+        }
     }
 }
 
 void Map::commit() {
-    Blockdata* commit = blockdata->copy();
-    history.push(commit);
+    if (blockdata) {
+        if (!blockdata->equals(history.history.at(history.head))) {
+            Blockdata* commit = blockdata->copy();
+            history.push(commit);
+            emit mapChanged(this);
+        }
+    }
 }
 
 void Map::setBlock(int x, int y, Block block) {
         commit();
     }
 }
+
+QList<Event *> Map::getAllEvents() {
+    QList<Event*> all;
+    for (QList<Event*> list : events.values()) {
+        all += list;
+    }
+    return all;
+}
+
+QList<Event *> Map::getEventsByType(QString type)
+{
+    return events.value(type);
+}
+
+void Map::removeEvent(Event *event) {
+    for (QString key : events.keys()) {
+        events[key].removeAll(event);
+    }
+}
+
+void Map::addEvent(Event *event) {
+    events[event->get("event_type")].append(event);
+}
+
+bool Map::hasUnsavedChanges() {
+    return !history.isSaved();
+}

map.h

 class History {
 public:
     QList<T> history;
-    int head;
+    int head = -1;
+    int saved = -1;
 
     History() {
-        head = -1;
+
     }
     T pop() {
         if (head > 0) {
         while (head + 1 < history.length()) {
             history.removeLast();
         }
+        if (saved > head) {
+            saved = -1;
+        }
         history.append(commit);
         head++;
     }
+    void save() {
+        saved = head;
+    }
+    bool isSaved() {
+        return saved == head;
+    }
 };
 
 class Connection {
     QString tileset_primary_label;
     QString tileset_secondary_label;
 
-    Tileset *tileset_primary;
-    Tileset *tileset_secondary;
+    Tileset *tileset_primary = NULL;
+    Tileset *tileset_secondary = NULL;
 
-    Blockdata* blockdata;
+    Blockdata* blockdata = NULL;
 
 public:
     int getWidth();
     int getHeight();
-    Tileset* getBlockTileset(uint);
-    Metatile* getMetatile(uint);
-    QImage getMetatileImage(uint);
-    QImage getMetatileTile(uint);
+    Tileset* getBlockTileset(int);
+    int getBlockIndex(int index);
+    Metatile* getMetatile(int);
+    QImage getMetatileImage(int);
+    QImage getMetatileTile(int);
     QPixmap render();
     QPixmap renderMetatiles();
 
     void drawSelection(int i, int w, QPainter *painter);
 
     bool blockChanged(int, Blockdata*);
-    Blockdata* cached_blockdata;
+    Blockdata* cached_blockdata = NULL;
     void cacheBlockdata();
-    Blockdata* cached_collision;
+    Blockdata* cached_collision = NULL;
     void cacheCollision();
     QImage image;
     QPixmap pixmap;
     QString coord_events_label;
     QString bg_events_label;
 
-    QList<ObjectEvent*> object_events;
-    QList<Warp*> warps;
-    QList<CoordEvent*> coord_events;
-    QList<Sign*> signs;
-    QList<HiddenItem*> hidden_items;
+    QList<Event*> getAllEvents();
+    QList<Event*> getEventsByType(QString type);
+    void removeEvent(Event *event);
+    void addEvent(Event *event);
+    QMap<QString, QList<Event*>> events;
 
     QList<Connection*> connections;
     QPixmap renderConnection(Connection);
 
     QImage border_image;
     QPixmap border_pixmap;
-    Blockdata *border;
-    Blockdata *cached_border;
+    Blockdata *border = NULL;
+    Blockdata *cached_border = NULL;
     QPixmap renderBorder();
     void cacheBorder();
 
+    bool hasUnsavedChanges();
+
+    QList<QList<QRgb> > getBlockPalettes(int metatile_index);
+
 signals:
+    void paintTileChanged(Map *map);
+    void paintCollisionChanged(Map *map);
+    void mapChanged(Map *map);
 
 public slots:
 };

metatile.h

 public:
     Metatile();
 public:
-    QList<Tile> *tiles;
+    QList<Tile> *tiles = NULL;
     int attr;
 };
 

objectpropertiesframe.cpp

+#include "objectpropertiesframe.h"
+#include "ui_objectpropertiesframe.h"
+
+ObjectPropertiesFrame::ObjectPropertiesFrame(QWidget *parent) :
+    QFrame(parent),
+    ui(new Ui::ObjectPropertiesFrame)
+{
+    ui->setupUi(this);
+}
+
+ObjectPropertiesFrame::~ObjectPropertiesFrame()
+{
+    delete ui;
+}

objectpropertiesframe.h

+#ifndef OBJECTPROPERTIESFRAME_H
+#define OBJECTPROPERTIESFRAME_H
+
+#include <QFrame>
+
+namespace Ui {
+class ObjectPropertiesFrame;
+}
+
+class ObjectPropertiesFrame : public QFrame
+{
+    Q_OBJECT
+
+public:
+    explicit ObjectPropertiesFrame(QWidget *parent = 0);
+    ~ObjectPropertiesFrame();
+
+public:
+    Ui::ObjectPropertiesFrame *ui;
+};
+
+#endif // OBJECTPROPERTIESFRAME_H

objectpropertiesframe.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ObjectPropertiesFrame</class>
+ <widget class="QFrame" name="ObjectPropertiesFrame">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>284</width>
+    <height>146</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>284</width>
+    <height>90</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Frame</string>
+  </property>
+  <property name="layoutDirection">
+   <enum>Qt::LeftToRight</enum>
+  </property>
+  <property name="frameShape">
+   <enum>QFrame::Box</enum>
+  </property>
+  <property name="frameShadow">
+   <enum>QFrame::Raised</enum>
+  </property>
+  <property name="lineWidth">
+   <number>1</number>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_2">
+   <item>
+    <widget class="QWidget" name="widget" native="true">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <layout class="QHBoxLayout" name="horizontalLayout_2">
+      <item>
+       <widget class="QLabel" name="label_spritePixmap">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>64</width>
+          <height>64</height>
+         </size>
+        </property>
+        <property name="frameShape">
+         <enum>QFrame::Box</enum>
+        </property>
+        <property name="frameShadow">
+         <enum>QFrame::Sunken</enum>
+        </property>
+        <property name="text">
+         <string/>
+        </property>
+        <property name="scaledContents">
+         <bool>false</bool>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignCenter</set>
+        </property>
+        <property name="indent">
+         <number>-1</number>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <layout class="QVBoxLayout" name="verticalLayout">
+        <item>
+         <widget class="QLabel" name="label_name">
+          <property name="text">
+           <string>Object 1</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <layout class="QHBoxLayout" name="horizontalLayout">
+          <item>
+           <layout class="QHBoxLayout" name="x">
+            <item>
+             <widget class="QLabel" name="label_x">
+              <property name="text">
+               <string>X</string>
+              </property>
+              <property name="alignment">
+               <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QSpinBox" name="spinBox_x">
+              <property name="minimum">
+               <number>-32768</number>
+              </property>
+              <property name="maximum">
+               <number>32767</number>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+          <item>
+           <layout class="QHBoxLayout" name="y">
+            <item>
+             <widget class="QLabel" name="label_y">
+              <property name="text">
+               <string>Y</string>
+              </property>
+              <property name="alignment">
+               <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QSpinBox" name="spinBox_y">
+              <property name="minimum">
+               <number>-32768</number>
+              </property>
+              <property name="maximum">
+               <number>32767</number>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+          <item>
+           <layout class="QHBoxLayout" name="z">
+            <item>
+             <widget class="QLabel" name="label">
+              <property name="text">
+               <string>Z</string>
+              </property>
+              <property name="alignment">
+               <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QSpinBox" name="spinBox_z">
+              <property name="maximum">
+               <number>15</number>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+          <item>
+           <spacer name="horizontalSpacer">
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>40</width>
+              <height>20</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+         </layout>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QWidget" name="sprite" native="true">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <layout class="QFormLayout" name="formLayout_sprite">
+      <property name="leftMargin">
+       <number>9</number>
+      </property>
+      <property name="topMargin">
+       <number>0</number>
+      </property>
+      <property name="bottomMargin">
+       <number>0</number>
+      </property>
+      <item row="0" column="0">
+       <widget class="QLabel" name="label_sprite">
+        <property name="text">
+         <string>Sprite</string>
+        </property>
+        <property name="buddy">
+         <cstring>comboBox_sprite</cstring>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="1">
+       <widget class="QComboBox" name="comboBox_sprite">
+        <property name="enabled">
+         <bool>true</bool>
+        </property>
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="editable">
+         <bool>true</bool>
+        </property>
+        <property name="currentText">
+         <string/>
+        </property>
+        <property name="maxVisibleItems">
+         <number>25</number>
+        </property>
+        <property name="sizeAdjustPolicy">
+         <enum>QComboBox::AdjustToContentsOnFirstShow</enum>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <tabstops>
+  <tabstop>spinBox_x</tabstop>
+  <tabstop>spinBox_y</tabstop>
+  <tabstop>spinBox_z</tabstop>
+  <tabstop>comboBox_sprite</tabstop>
+ </tabstops>
+ <resources/>
+ <connections/>
+</ui>

pretmap.pro

     metatile.cpp \
     tile.cpp \
     event.cpp \
-    editor.cpp
+    editor.cpp \
+    objectpropertiesframe.cpp \
+    graphicsview.cpp
 
 HEADERS  += mainwindow.h \
     project.h \
     metatile.h \
     tile.h \
     event.h \
-    editor.h
+    editor.h \
+    objectpropertiesframe.h \
+    graphicsview.h
 
-FORMS    += mainwindow.ui
+FORMS    += mainwindow.ui \
+    objectpropertiesframe.ui
 
 RESOURCES += \
     resources/images.qrc

project.cpp

 {
     groupNames = new QStringList;
     groupedMapNames = new QList<QStringList*>;
+    mapNames = new QStringList;
     map_cache = new QMap<QString, Map*>;
     tileset_cache = new QMap<QString, Tileset*>;
 }
 
 QString Project::getProjectTitle() {
-    return root.section('/', -1);
+    if (!root.isNull()) {
+        return root.section('/', -1);
+    } else {
+        return QString();
+    }
 }
 
 Map* Project::loadMap(QString map_name) {
     readMapEvents(map);
     loadMapConnections(map);
     map->commit();
+    map->history.save();
 
     map_cache->insert(map_name, map);
     return map;
 void Project::loadMapConnections(Map *map) {
     map->connections.clear();
     if (!map->connections_label.isNull()) {
-        QString path = root + QString("/data/maps/%1/connections.s").arg(map->name);
+        QString path = root + QString("/data/maps/%1/connections.inc").arg(map->name);
         QString text = readTextFile(path);
-        if (text != NULL) {
+        if (!text.isNull()) {
             QList<QStringList> *commands = parse(text);
             QStringList *list = getLabelValues(commands, map->connections_label);
 
     QString label = map->name;
     Asm *parser = new Asm;
 
-    QString header_text = readTextFile(root + "/data/maps/" + label + "/header.s");
+    QString header_text = readTextFile(root + "/data/maps/" + label + "/header.inc");
+    if (header_text.isNull()) {
+        return;
+    }
     QStringList *header = getLabelValues(parser->parse(header_text), label);
     map->attributes_label = header->value(0);
     map->events_label = header->value(1);
 
 void Project::saveMapHeader(Map *map) {
     QString label = map->name;
-    QString header_path = root + "/data/maps/" + label + "/header.s";
+    QString header_path = root + "/data/maps/" + label + "/header.inc";
     QString text = "";
     text += QString("%1::\n").arg(label);
     text += QString("\t.4byte %1\n").arg(map->attributes_label);
 void Project::readMapAttributes(Map* map) {
     Asm *parser = new Asm;
 
-    QString assets_text = readTextFile(root + "/data/maps/_assets.s");
+    QString assets_text = readTextFile(root + "/data/maps/_assets.inc");
+    if (assets_text.isNull()) {
+        return;
+    }
     QStringList *attributes = getLabelValues(parser->parse(assets_text), map->attributes_label);
     map->width = attributes->value(0);
     map->height = attributes->value(1);
 Tileset* Project::loadTileset(QString label) {
     Asm *parser = new Asm;
 
-    QString headers_text = readTextFile(root + "/data/tilesets/headers.s");
+    QString headers_text = readTextFile(root + "/data/tilesets/headers.inc");
     QStringList *values = getLabelValues(parser->parse(headers_text), label);
     Tileset *tileset = new Tileset;
     tileset->name = label;
 }
 
 QString Project::getBlockdataPath(Map* map) {
-    QString text = readTextFile(root + "/data/maps/_assets.s");
+    QString text = readTextFile(root + "/data/maps/_assets.inc");
     QStringList *values = getLabelValues(parse(text), map->blockdata_label);
     QString path;
     if (!values->isEmpty()) {
 }
 
 QString Project::getMapBorderPath(Map *map) {
-    QString text = readTextFile(root + "/data/maps/_assets.s");
+    QString text = readTextFile(root + "/data/maps/_assets.inc");
     QStringList *values = getLabelValues(parse(text), map->border_label);
     QString path;
     if (!values->isEmpty()) {
 void Project::saveBlockdata(Map* map) {
     QString path = getBlockdataPath(map);
     writeBlockdata(path, map->blockdata);
+    map->history.save();
 }
 
 void Project::writeBlockdata(QString path, Blockdata *blockdata) {
 void Project::saveMap(Map *map) {
     saveBlockdata(map);
     saveMapHeader(map);
+    saveMapEvents(map);
 }
 
 void Project::loadTilesetAssets(Tileset* tileset) {
     Asm* parser = new Asm;
     QString category = (tileset->is_secondary == "TRUE") ? "secondary" : "primary";
+    if (tileset->name.isNull()) {
+        return;
+    }
     QString dir_path = root + "/data/tilesets/" + category + "/" + tileset->name.replace("gTileset_", "").toLower();
 
-    QString graphics_text = readTextFile(root + "/data/tilesets/graphics.s");
+    QString graphics_text = readTextFile(root + "/data/tilesets/graphics.inc");
     QList<QStringList> *graphics = parser->parse(graphics_text);
     QStringList *tiles_values = getLabelValues(graphics, tileset->tiles_label);
     QStringList *palettes_values = getLabelValues(graphics, tileset->palettes_label);
 
     QString metatiles_path;
     QString metatile_attrs_path;
-    QString metatiles_text = readTextFile(root + "/data/tilesets/metatiles.s");
+    QString metatiles_text = readTextFile(root + "/data/tilesets/metatiles.inc");
     QList<QStringList> *metatiles_macros = parser->parse(metatiles_text);
     QStringList *metatiles_values = getLabelValues(metatiles_macros, tileset->metatiles_label);
     if (!metatiles_values->isEmpty()) {
         QList<Metatile*> *metatiles = new QList<Metatile*>;
         for (int i = 0; i < num_metatiles; i++) {
             Metatile *metatile = new Metatile;
-            int index = i * 16;
+            int index = i * (2 * 4 * num_layers);
             for (int j = 0; j < 4 * num_layers; j++) {
                 uint16_t word = data[index++] & 0xff;
                 word += (data[index++] & 0xff) << 8;
             metatiles->append(metatile);
         }
         tileset->metatiles = metatiles;
+    } else {
+        tileset->metatiles = new QList<Metatile*>;
+        qDebug() << QString("Could not open '%1'").arg(metatiles_path);
     }
 
     QFile attrs_file(metatile_attrs_path);
             word += (data[i*2 + 1] & 0xff) << 8;
             tileset->metatiles->value(i)->attr = word;
         }
+    } else {
+        qDebug() << QString("Could not open '%1'").arg(metatile_attrs_path);
     }
 
     // palettes
                 QRgb color = qRgb(red * 8, green * 8, blue * 8);
                 palette.prepend(color);
             }
+        } else {
+            for (int j = 0; j < 16; j++) {
+                palette.append(qRgb(j * 16, j * 16, j * 16));
+            }
+            qDebug() << QString("Could not open '%1'").arg(path);
         }
         //qDebug() << path;
         palettes->append(palette);
     QFile file(path);
     if (!file.open(QIODevice::ReadOnly)) {
         //QMessageBox::information(0, "Error", QString("Could not open '%1': ").arg(path) + file.errorString());
-        return NULL;
+        qDebug() << QString("Could not open '%1': ").arg(path) + file.errorString();
+        return QString();
     }
     QTextStream in(&file);
     QString text = "";
     QFile file(path);
     if (file.open(QIODevice::WriteOnly)) {
         file.write(text.toUtf8());
+    } else {
+        qDebug() << QString("Could not open '%1' for writing: ").arg(path) + file.errorString();
     }
 }
 
 void Project::readMapGroups() {
-    QString text = readTextFile(root + "/data/maps/_groups.s");
-    if (text == NULL) {
+    QString text = readTextFile(root + "/data/maps/_groups.inc");
+    if (text.isNull()) {
         return;
     }
     Asm *parser = new Asm;
         }
     }
 
-    QList<QStringList*> *maps = new QList<QStringList*>;
+    QList<QStringList*> *groupedMaps = new QList<QStringList*>;
     for (int i = 0; i < groups->length(); i++) {
         QStringList *list = new QStringList;
-        maps->append(list);
+        groupedMaps->append(list);
     }
 
+    QStringList *maps = new QStringList;
     int group = -1;
     for (int i = 0; i < commands->length(); i++) {
         QStringList params = commands->value(i);
         } else if (macro == ".4byte") {
             if (group != -1) {
                 for (int j = 1; j < params.length(); j++) {
-                    QStringList *list = maps->value(group);
+                    QStringList *list = groupedMaps->value(group);
                     list->append(params.value(j));
+                    maps->append(params.value(j));
                 }
             }
         }
     }
 
     groupNames = groups;
-    groupedMapNames = maps;
+    groupedMapNames = groupedMaps;
+    mapNames = maps;
 }
 
 QList<QStringList>* Project::parse(QString text) {
 
 QStringList Project::getSongNames() {
     QStringList names;
-    QString text = readTextFile(root + "/constants/songs.s");
-    if (text != NULL) {
+    QString text = readTextFile(root + "/constants/songs.inc");
+    if (!text.isNull()) {
         QList<QStringList> *commands = parse(text);
         for (int i = 0; i < commands->length(); i++) {
             QStringList params = commands->value(i);
 
 QString Project::getSongName(int value) {
     QStringList names;
-    QString text = readTextFile(root + "/constants/songs.s");
-    if (text != NULL) {
+    QString text = readTextFile(root + "/constants/songs.inc");
+    if (!text.isNull()) {
         QList<QStringList> *commands = parse(text);
         for (int i = 0; i < commands->length(); i++) {
             QStringList params = commands->value(i);
 
 QMap<QString, int> Project::getMapObjGfxConstants() {
     QMap<QString, int> constants;
-    QString text = readTextFile(root + "/constants/map_object_constants.s");
-    if (text != NULL) {
+    QString text = readTextFile(root + "/constants/map_object_constants.inc");
+    if (!text.isNull()) {
         QList<QStringList> *commands = parse(text);
         for (int i = 0; i < commands->length(); i++) {
             QStringList params = commands->value(i);
     return path;
 }
 
-void Project::loadObjectPixmaps(QList<ObjectEvent*> objects) {
+void Project::loadObjectPixmaps(QList<Event*> objects) {
     bool needs_update = false;
-    for (ObjectEvent *object : objects) {
+    for (Event *object : objects) {
         if (object->pixmap.isNull()) {
             needs_update = true;
             break;
 
     QMap<QString, int> constants = getMapObjGfxConstants();
 
-    QString pointers_path = root + "/data/graphics/field_objects/map_object_graphics_info_pointers.s";
-    QString pointers_text = readTextFile(pointers_path);
-    if (pointers_text == NULL) {
-        return;
-    }
-    QString info_path = root + "/data/graphics/field_objects/map_object_graphics_info.s";
-    QString info_text = readTextFile(info_path);
-    if (info_text == NULL) {
-        return;
-    }
-    QString pic_path = root + "/data/graphics/field_objects/map_object_pic_tables.s";
-    QString pic_text = readTextFile(pic_path);
-    if (pic_text == NULL) {
-        return;
-    }
-    QString assets_path = root + "/data/graphics/field_objects/map_object_graphics.s";
-    QString assets_text = readTextFile(assets_path);
-    if (assets_text == NULL) {
-        return;
-    }
+    QString pointers_text = readTextFile(root + "/include/data/field_map_obj/map_object_graphics_info_pointers.h");
+    QString info_text = readTextFile(root + "/include/data/field_map_obj/map_object_graphics_info.h");
+    QString pic_text = readTextFile(root + "/include/data/field_map_obj/map_object_pic_tables.h");
+    QString assets_text = readTextFile(root + "/src/field_map_obj.c");
 
-    QStringList *pointers = getLabelValues(parse(pointers_text), "gMapObjectGraphicsInfoPointers");
-    QList<QStringList> *info_commands = parse(info_text);
-    QList<QStringList> *asset_commands = parse(assets_text);
-    QList<QStringList> *pic_commands = parse(pic_text);
+    QStringList pointers = readCArray(pointers_text, "gMapObjectGraphicsInfoPointers");
 
-    for (ObjectEvent *object : objects) {
+    for (Event *object : objects) {
         if (!object->pixmap.isNull()) {
             continue;
         }
-        int id = constants.value(object->sprite);
-        QString info_label = pointers->value(id);
-        QStringList *info = getLabelValues(info_commands, info_label);
-        QString pic_label = info->value(12);
-
-        QList<QStringList> *pic = getLabelMacros(pic_commands, pic_label);
-        for (int i = 0; i < pic->length(); i++) {
-            QStringList command = pic->value(i);
-            QString macro = command.value(0);
-            if (macro == "obj_frame_tiles") {
-                QString label = command.value(1);
-                QStringList *incbins = getLabelValues(asset_commands, label);
-                QString path = incbins->value(0).section('"', 1, 1);
+        QString event_type = object->get("event_type");
+        if (event_type == "object") {
+            object->pixmap = QPixmap(":/images/Entities_16x16.png").copy(0, 0, 16, 16);
+        } else if (event_type == "warp") {
+            object->pixmap = QPixmap(":/images/Entities_16x16.png").copy(16, 0, 16, 16);
+        } else if (event_type == "trap") {
+            object->pixmap = QPixmap(":/images/Entities_16x16.png").copy(32, 0, 16, 16);
+        } else if (event_type == "sign" || event_type == "hidden item") {
+            object->pixmap = QPixmap(":/images/Entities_16x16.png").copy(48, 0, 16, 16);
+        }
+
+        if (event_type == "object") {
+
+            int sprite_id = constants.value(object->get("sprite"));
+
+            QString info_label = pointers.value(sprite_id).replace("&", "");
+            QString pic_label = readCArray(info_text, info_label).value(14);
+            QString gfx_label = readCArray(pic_text, pic_label).value(0);
+            gfx_label = gfx_label.section(QRegExp("[\\(\\)]"), 1, 1);
+            QString path = readCIncbin(assets_text, gfx_label);
+
+            if (!path.isNull()) {
                 path = fixGraphicPath(path);
                 QPixmap pixmap(root + "/" + path);
-                object->pixmap = pixmap;
-                break;
+                if (!pixmap.isNull()) {
+                    object->pixmap = pixmap;
+                }
             }
+
         }
     }
+
+}
+
+void Project::saveMapEvents(Map *map) {
+    QString path = root + QString("/data/maps/events/%1.inc").arg(map->name);
+    QString text = "";
+
+    text += QString("%1::\n").arg(map->object_events_label);
+    for (int i = 0; i < map->events["object"].length(); i++) {
+        Event *object_event = map->events["object"].value(i);
+        int radius_x = object_event->getInt("radius_x");
+        int radius_y = object_event->getInt("radius_y");
+        QString radius = QString("%1").arg((radius_x & 0xf) + ((radius_y & 0xf) << 4));
+        uint16_t x = object_event->getInt("x");
+        uint16_t y = object_event->getInt("y");
+
+        text += QString("\tobject_event %1").arg(i + 1);
+        text += QString(", %1").arg(object_event->get("sprite"));
+        text += QString(", %1").arg(object_event->get("replacement"));
+        text += QString(", %1").arg(x & 0xff);
+        text += QString(", %1").arg((x >> 8) & 0xff);
+        text += QString(", %1").arg(y & 0xff);
+        text += QString(", %1").arg((y >> 8) & 0xff);
+        text += QString(", %1").arg(object_event->get("elevation"));
+        text += QString(", %1").arg(object_event->get("behavior"));
+        text += QString(", %1").arg(radius);
+        text += QString(", 0");
+        text += QString(", %1").arg(object_event->get("property"));
+        text += QString(", 0");
+        text += QString(", %1").arg(object_event->get("sight_radius"));
+        text += QString(", 0");
+        text += QString(", %1").arg(object_event->get("script_label"));
+        text += QString(", %1").arg(object_event->get("event_flag"));
+        text += QString(", 0");
+        text += QString(", 0");
+        text += "\n";
+    }
+    text += "\n";
+
+    text += QString("%1::\n").arg(map->warps_label);
+    for (Event *warp : map->events["warp"]) {
+        text += QString("\twarp_def %1").arg(warp->get("x"));
+        text += QString(", %1").arg(warp->get("y"));
+        text += QString(", %1").arg(warp->get("elevation"));
+        text += QString(", %1").arg(warp->get("destination_warp"));
+        text += QString(", %1").arg(warp->get("destination_map"));
+        text += "\n";
+    }
+    text += "\n";
+
+    text += QString("%1::\n").arg(map->coord_events_label);
+    for (Event *coords : map->events["trap"]) {
+        text += QString("\tcoord_event %1").arg(coords->get("x"));
+        text += QString(", %1").arg(coords->get("y"));
+        text += QString(", %1").arg(coords->get("elevation"));
+        text += QString(", 0");
+        text += QString(", %1").arg(coords->get("coord_unknown1"));
+        text += QString(", %1").arg(coords->get("coord_unknown2"));
+        text += QString(", 0");
+        text += QString(", %1").arg(coords->get("script_label"));
+        text += "\n";
+    }
+    text += "\n";
+
+    text += QString("%1::\n").arg(map->bg_events_label);
+    for (Event *sign : map->events["sign"]) {
+        text += QString("\tbg_event %1").arg(sign->get("x"));
+        text += QString(", %1").arg(sign->get("y"));
+        text += QString(", %1").arg(sign->get("elevation"));
+        text += QString(", %1").arg(sign->get("type"));
+        text += QString(", 0");
+        text += QString(", %1").arg(sign->get("script_label"));
+        text += "\n";
+    }
+    for (Event *item : map->events["hidden item"]) {
+        text += QString("\tbg_event %1").arg(item->get("x"));
+        text += QString(", %1").arg(item->get("y"));
+        text += QString(", %1").arg(item->get("elevation"));
+        text += QString(", %1").arg(item->get("type"));
+        text += QString(", 0");
+        text += QString(", %1").arg(item->get("item"));
+        text += QString(", %1").arg(item->get("item_unknown5"));
+        text += QString(", %1").arg(item->get("item_unknown6"));
+        text += "\n";
+    }
+    text += "\n";
+
+    text += QString("%1::\n").arg(map->events_label);
+    text += QString("\tmap_events %1, %2, %3, %4\n")
+            .arg(map->object_events_label)
+            .arg(map->warps_label)
+            .arg(map->coord_events_label)
+            .arg(map->bg_events_label);
+
+    saveTextFile(path, text);
 }
 
 void Project::readMapEvents(Map *map) {
     // lazy
-    QString path = root + QString("/data/maps/events/%1.s").arg(map->name);
+    QString path = root + QString("/data/maps/events/%1.inc").arg(map->name);
     QString text = readTextFile(path);
+    if (text.isNull()) {
+        return;
+    }
 
     QStringList *labels = getLabelValues(parse(text), map->events_label);
     map->object_events_label = labels->value(0);
     map->bg_events_label = labels->value(3);
 
     QList<QStringList> *object_events = getLabelMacros(parse(text), map->object_events_label);
-    map->object_events.clear();
+    map->events["object"].clear();
     for (QStringList command : *object_events) {
         if (command.value(0) == "object_event") {
-            ObjectEvent *object = new ObjectEvent;
+            Event *object = new Event;
+            object->put("map_name", map->name);
             // This macro is not fixed as of writing, but it should take fewer args.
             bool old_macro = false;
             if (command.length() >= 20) {
                 command.removeAt(15);
                 command.removeAt(13);
                 command.removeAt(11);
-                command.removeAt(7);
-                command.removeAt(5);
                 command.removeAt(1); // id. not 0, but is just the index in the list of objects
                 old_macro = true;
             }
             int i = 1;
-            object->sprite = command.value(i++);
-            object->replacement = command.value(i++);
-            object->x_ = command.value(i++);
-            object->y_ = command.value(i++);
-            object->elevation_ = command.value(i++);
-            object->behavior = command.value(i++);
+            object->put("sprite", command.value(i++));
+            object->put("replacement", command.value(i++));
+            int16_t x = command.value(i++).toInt(nullptr, 0) | (command.value(i++).toInt(nullptr, 0) << 8);
+            int16_t y = command.value(i++).toInt(nullptr, 0) | (command.value(i++).toInt(nullptr, 0) << 8);
+            object->put("x", x);
+            object->put("y", y);
+            object->put("elevation", command.value(i++));
+            object->put("behavior", command.value(i++));
             if (old_macro) {
                 int radius = command.value(i++).toInt(nullptr, 0);
-                object->radius_x = QString("%1").arg(radius & 0xf);
-                object->radius_y = QString("%1").arg((radius >> 4) & 0xf);
+                object->put("radius_x", radius & 0xf);
+                object->put("radius_y", (radius >> 4) & 0xf);
             } else {
-                object->radius_x = command.value(i++);
-                object->radius_y = command.value(i++);
+                object->put("radius_x", command.value(i++));
+                object->put("radius_y", command.value(i++));
             }
-            object->property = command.value(i++);
-            object->sight_radius = command.value(i++);
-            object->script_label = command.value(i++);
-            object->event_flag = command.value(i++);
+            object->put("property", command.value(i++));
+            object->put("sight_radius", command.value(i++));
+            object->put("script_label", command.value(i++));
+            object->put("event_flag", command.value(i++));
 
-            map->object_events.append(object);
+            object->put("event_type", "object");
+            map->events["object"].append(object);
         }
     }
 
     QList<QStringList> *warps = getLabelMacros(parse(text), map->warps_label);
-    map->warps.clear();
+    map->events["warp"].clear();
     for (QStringList command : *warps) {
         if (command.value(0) == "warp_def") {
-            Warp *warp = new Warp;
+            Event *warp = new Event;
+            warp->put("map_name", map->name);
             int i = 1;
-            warp->x_ = command.value(i++);
-            warp->y_ = command.value(i++);
-            warp->elevation_ = command.value(i++);
-            warp->destination_warp = command.value(i++);
-            warp->destination_map = command.value(i++);
-            map->warps.append(warp);
+            warp->put("x", command.value(i++));
+            warp->put("y", command.value(i++));
+            warp->put("elevation", command.value(i++));
+            warp->put("destination_warp", command.value(i++));
+            warp->put("destination_map", command.value(i++));
+
+            warp->put("event_type", "warp");
+            map->events["warp"].append(warp);
         }
     }
 
     QList<QStringList> *coords = getLabelMacros(parse(text), map->coord_events_label);
-    map->coord_events.clear();
+    map->events["trap"].clear();
     for (QStringList command : *coords) {
         if (command.value(0) == "coord_event") {
-            CoordEvent *coord = new CoordEvent;
+            Event *coord = new Event;
+            coord->put("map_name", map->name);
             bool old_macro = false;
             if (command.length() >= 9) {
                 command.removeAt(7);
-                command.removeAt(6);
                 command.removeAt(4);
                 old_macro = true;
             }
             int i = 1;
-            coord->x_ = command.value(i++);
-            coord->y_ = command.value(i++);
-            coord->elevation_ = command.value(i++);
-            coord->unknown1 = command.value(i++);
-            coord->script_label = command.value(i++);
-            map->coord_events.append(coord);
+            coord->put("x", command.value(i++));
+            coord->put("y", command.value(i++));
+            coord->put("elevation", command.value(i++));
+            coord->put("coord_unknown1", command.value(i++));
+            coord->put("coord_unknown2", command.value(i++));
+            coord->put("script_label", command.value(i++));
+            //coord_unknown3
+            //coord_unknown4
+
+            coord->put("event_type", "trap");
+            map->events["trap"].append(coord);
         }
     }
 
-    QList<QStringList> *bgs = getLabelMacros(parse(text), map->warps_label);
-    map->hidden_items.clear();
-    map->signs.clear();
+    QList<QStringList> *bgs = getLabelMacros(parse(text), map->bg_events_label);
+    map->events["hidden item"].clear();
+    map->events["sign"].clear();
     for (QStringList command : *bgs) {
         if (command.value(0) == "bg_event") {
-            BGEvent *bg = new BGEvent;
+            Event *bg = new Event;
+            bg->put("map_name", map->name);
             int i = 1;
-            bg->x_ = command.value(i++);
-            bg->y_ = command.value(i++);
-            bg->elevation_ = command.value(i++);
-            bg->type = command.value(i++);
+            bg->put("x", command.value(i++));
+            bg->put("y", command.value(i++));
+            bg->put("elevation", command.value(i++));
+            bg->put("type", command.value(i++));
             i++;
-            if (bg->is_item()) {
-                HiddenItem *item = new HiddenItem(*bg);
-                item->item = command.value(i++);
-                item->unknown5 = command.value(i++);
-                item->unknown6 = command.value(i++);
-                map->hidden_items.append(item);
+            if (bg->is_hidden_item()) {
+                bg->put("item", command.value(i++));
+                bg->put("item_unknown5", command.value(i++));
+                bg->put("item_unknown6", command.value(i++));
+
+                bg->put("event_type", "hidden item");
+                map->events["hidden item"].append(bg);
             } else {
-                Sign *sign = new Sign(*bg);
-                sign->script_label = command.value(i++);
-                map->signs.append(sign);
+                bg->put("script_label", command.value(i++));
+                //sign_unknown7
+
+                bg->put("event_type", "sign");
+                map->events["sign"].append(bg);
             }
         }
     }
 
 }
+
+QStringList Project::readCArray(QString text, QString label) {
+    QStringList list;
+
+    if (label.isNull()) {
+        return list;
+    }
+
+    QRegExp *re = new QRegExp(QString("\\b%1\\b\\s*\\[?\\s*\\]?\\s*=\\s*\\{([^\\}]*)\\}").arg(label));
+    int pos = re->indexIn(text);
+    if (pos != -1) {
+        QString body = re->cap(1);
+        body = body.replace(QRegExp("\\s*"), "");
+        list = body.split(',');
+        /*
+        QRegExp *inner = new QRegExp("&?\\b([A-Za-z0-9_\\(\\)]*)\\b,");
+        int pos = 0;
+        while ((pos = inner->indexIn(body, pos)) != -1) {
+            list << inner->cap(1);
+            pos += inner->matchedLength();
+        }
+        */
+    }
+
+    return list;
+}
+
+QString Project::readCIncbin(QString text, QString label) {
+    QString path;
+
+    if (label.isNull()) {
+        return path;
+    }
+
+    QRegExp *re = new QRegExp(QString(
+        "\\b%1\\b"
+        "\\s*\\[?\\s*\\]?\\s*=\\s*"
+        "INCBIN_[US][0-9][0-9]?"
+        "\\(\"([^\"]*)\"\\)").arg(label));
+
+    int pos = re->indexIn(text);
+    if (pos != -1) {
+        path = re->cap(1);
+    }
+
+    return path;
+}

project.h

 public:
     Project();
     QString root;
-    QStringList *groupNames;
-    QList<QStringList*> *groupedMapNames;
+    QStringList *groupNames = NULL;
+    QList<QStringList*> *groupedMapNames = NULL;
+    QStringList *mapNames = NULL;
 
     QMap<QString, Map*> *map_cache;
     Map* loadMap(QString);
     Map* getMap(QString);
 
-    QMap<QString, Tileset*> *tileset_cache;
+    QMap<QString, Tileset*> *tileset_cache = NULL;
     Tileset* loadTileset(QString);
     Tileset* getTileset(QString);
 
     QStringList getMapTypes();
     QStringList getBattleScenes();
 
-    void loadObjectPixmaps(QList<ObjectEvent*> objects);
+    void loadObjectPixmaps(QList<Event*> objects);
     QMap<QString, int> getMapObjGfxConstants();
     QString fixGraphicPath(QString path);
 
 
     void loadMapBorder(Map *map);
     QString getMapBorderPath(Map *map);
+
+    void saveMapEvents(Map *map);
+
+    QStringList readCArray(QString text, QString label);
+    QString readCIncbin(QString text, QString label);
 };
 
 #endif // PROJECT_H

resources/images.qrc

         <file>icons/folder_map.ico</file>
         <file>icons/image.ico</file>
         <file>icons/map.ico</file>
+        <file>icons/cursor.ico</file>
+        <file>icons/fill_color.ico</file>
+        <file>icons/pencil.ico</file>
+        <file>icons/pipette.ico</file>
+        <file>images/Entities_16x16.png</file>
+        <file>icons/add.ico</file>
+        <file>icons/delete.ico</file>
+        <file>icons/viewsprites.ico</file>
     </qresource>
 </RCC>

tileset.h

     QString callback_label;
     QString metatile_attrs_label;
 
-    QList<QImage> *tiles;
-    QList<Metatile*> *metatiles;
-    QList<QList<QRgb>> *palettes;
+    QList<QImage> *tiles = NULL;
+    QList<Metatile*> *metatiles = NULL;
+    QList<QList<QRgb>> *palettes = NULL;
 };
 
 #endif // TILESET_H