Restructure source tree

include/ui/bordermetatilespixmapitem.h

@@ -0,0 +1,25 @@
+#ifndef BORDERMETATILESPIXMAPITEM_H
+#define BORDERMETATILESPIXMAPITEM_H
+
+#include "map.h"
+#include "metatileselector.h"
+#include <QGraphicsPixmapItem>
+
+class BorderMetatilesPixmapItem : public QObject, public QGraphicsPixmapItem {
+    Q_OBJECT
+public:
+    BorderMetatilesPixmapItem(Map *map_, MetatileSelector *metatileSelector) {
+        this->map = map_;
+        this->metatileSelector = metatileSelector;
+        setAcceptHoverEvents(true);
+    }
+    MetatileSelector *metatileSelector;
+    Map* map;
+    void draw();
+signals:
+    void borderMetatilesChanged();
+protected:
+    void mousePressEvent(QGraphicsSceneMouseEvent*);
+};
+
+#endif // BORDERMETATILESPIXMAPITEM_H

include/ui/collisionpixmapitem.h

@@ -0,0 +1,37 @@
+#ifndef COLLISIONPIXMAPITEM_H
+#define COLLISIONPIXMAPITEM_H
+
+#include "metatileselector.h"
+#include "movementpermissionsselector.h"
+#include "mappixmapitem.h"
+#include "map.h"
+#include "settings.h"
+
+class CollisionPixmapItem : public MapPixmapItem {
+    Q_OBJECT
+public:
+    CollisionPixmapItem(Map *map, MovementPermissionsSelector *movementPermissionsSelector, MetatileSelector *metatileSelector, Settings *settings)
+        : MapPixmapItem(map, metatileSelector, settings){
+        this->movementPermissionsSelector = movementPermissionsSelector;
+    }
+    MovementPermissionsSelector *movementPermissionsSelector;
+    void updateMovementPermissionSelection(QGraphicsSceneMouseEvent *event);
+    virtual void paint(QGraphicsSceneMouseEvent*);
+    virtual void floodFill(QGraphicsSceneMouseEvent*);
+    virtual void pick(QGraphicsSceneMouseEvent*);
+    virtual void draw(bool ignoreCache = false);
+
+signals:
+    void mouseEvent(QGraphicsSceneMouseEvent *, CollisionPixmapItem *);
+    void hoveredMapMovementPermissionChanged(int, int);
+    void hoveredMapMovementPermissionCleared();
+
+protected:
+    void hoverMoveEvent(QGraphicsSceneHoverEvent*);
+    void hoverLeaveEvent(QGraphicsSceneHoverEvent*);
+    void mousePressEvent(QGraphicsSceneMouseEvent*);
+    void mouseMoveEvent(QGraphicsSceneMouseEvent*);
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent*);
+};
+
+#endif // COLLISIONPIXMAPITEM_H

include/ui/connectionpixmapitem.h

@@ -0,0 +1,44 @@
+#ifndef CONNECTIONPIXMAPITEM_H
+#define CONNECTIONPIXMAPITEM_H
+
+#include "mapconnection.h"
+#include <QGraphicsPixmapItem>
+#include <QPainter>
+
+class ConnectionPixmapItem : public QObject, public QGraphicsPixmapItem {
+    Q_OBJECT
+public:
+    ConnectionPixmapItem(QPixmap pixmap, MapConnection* connection, int x, int y, int baseMapWidth, int baseMapHeight): QGraphicsPixmapItem(pixmap) {
+        this->basePixmap = pixmap;
+        this->connection = connection;
+        setFlag(ItemIsMovable);
+        setFlag(ItemSendsGeometryChanges);
+        this->initialX = x;
+        this->initialY = y;
+        this->initialOffset = connection->offset.toInt();
+        this->baseMapWidth = baseMapWidth;
+        this->baseMapHeight = baseMapHeight;
+    }
+    QPixmap basePixmap;
+    MapConnection* connection;
+    int initialX;
+    int initialY;
+    int initialOffset;
+    int baseMapWidth;
+    int baseMapHeight;
+    void render(qreal opacity = 1);
+    int getMinOffset();
+    int getMaxOffset();
+
+protected:
+    QVariant itemChange(GraphicsItemChange change, const QVariant &value);
+    void mousePressEvent(QGraphicsSceneMouseEvent*);
+    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent*);
+
+signals:
+    void connectionItemSelected(ConnectionPixmapItem* connectionItem);
+    void connectionItemDoubleClicked(ConnectionPixmapItem* connectionItem);
+    void connectionMoved(MapConnection*);
+};
+
+#endif // CONNECTIONPIXMAPITEM_H

include/ui/currentselectedmetatilespixmapitem.h

@@ -0,0 +1,20 @@
+#ifndef CURRENTSELECTEDMETATILESPIXMAPITEM_H
+#define CURRENTSELECTEDMETATILESPIXMAPITEM_H
+
+#include "map.h"
+#include "metatileselector.h"
+#include <QGraphicsPixmapItem>
+
+class CurrentSelectedMetatilesPixmapItem : public QObject, public QGraphicsPixmapItem {
+    Q_OBJECT
+public:
+    CurrentSelectedMetatilesPixmapItem(Map *map, MetatileSelector *metatileSelector) {
+        this->map = map;
+        this->metatileSelector = metatileSelector;
+    }
+    Map* map = nullptr;
+    MetatileSelector *metatileSelector;
+    void draw();
+};
+
+#endif // CURRENTSELECTEDMETATILESPIXMAPITEM_H

include/ui/eventpropertiesframe.h

@@ -0,0 +1,22 @@
+#ifndef EVENTPROPERTIESFRAME_H
+#define EVENTPROPERTIESFRAME_H
+
+#include <QFrame>
+
+namespace Ui {
+class EventPropertiesFrame;
+}
+
+class EventPropertiesFrame : public QFrame
+{
+    Q_OBJECT
+
+public:
+    explicit EventPropertiesFrame(QWidget *parent = nullptr);
+    ~EventPropertiesFrame();
+
+public:
+    Ui::EventPropertiesFrame *ui;
+};
+
+#endif // EVENTPROPERTIESFRAME_H

include/ui/graphicsview.h

@@ -0,0 +1,26 @@
+#ifndef GRAPHICSVIEW_H
+#define GRAPHICSVIEW_H
+
+#include <QGraphicsView>
+#include <QMouseEvent>
+
+class Editor;
+
+class GraphicsView : public QGraphicsView
+{
+public:
+    GraphicsView() : QGraphicsView() {}
+    GraphicsView(QWidget *parent) : QGraphicsView(parent) {}
+
+public:
+//    GraphicsView_Object object;
+    Editor *editor;
+protected:
+    void mousePressEvent(QMouseEvent *event);
+    void mouseMoveEvent(QMouseEvent *event);
+    void mouseReleaseEvent(QMouseEvent *event);
+};
+
+//Q_DECLARE_METATYPE(GraphicsView)
+
+#endif // GRAPHICSVIEW_H

include/ui/imageproviders.h

@@ -0,0 +1,14 @@
+#ifndef IMAGEPROVIDERS_H
+#define IMAGEPROVIDERS_H
+
+#include "block.h"
+#include "tileset.h"
+#include <QImage>
+#include <QPixmap>
+
+QImage getCollisionMetatileImage(Block);
+QImage getCollisionMetatileImage(int, int);
+QImage getMetatileImage(int, Tileset*, Tileset*);
+QImage getTileImage(int, Tileset*, Tileset*);
+
+#endif // IMAGEPROVIDERS_H

include/ui/mappixmapitem.h

@@ -0,0 +1,55 @@
+#ifndef MAPPIXMAPITEM_H
+#define MAPPIXMAPITEM_H
+
+#include "map.h"
+#include "settings.h"
+#include "metatileselector.h"
+#include <QGraphicsPixmapItem>
+
+class MapPixmapItem : public QObject, public QGraphicsPixmapItem {
+    Q_OBJECT
+public:
+    MapPixmapItem(Map *map_, MetatileSelector *metatileSelector, Settings *settings) {
+        this->map = map_;
+        this->metatileSelector = metatileSelector;
+        this->settings = settings;
+        setAcceptHoverEvents(true);
+    }
+    Map *map;
+    MetatileSelector *metatileSelector;
+    Settings *settings;
+    bool active;
+    bool right_click;
+    int paint_tile_initial_x;
+    int paint_tile_initial_y;
+    QPoint selection_origin;
+    QList<QPoint> selection;
+    virtual void paint(QGraphicsSceneMouseEvent*);
+    virtual void floodFill(QGraphicsSceneMouseEvent*);
+    void _floodFill(int x, int y);
+    void _floodFillSmartPath(int initialX, int initialY);
+    virtual void pick(QGraphicsSceneMouseEvent*);
+    virtual void select(QGraphicsSceneMouseEvent*);
+    virtual void shift(QGraphicsSceneMouseEvent*);
+    virtual void draw(bool ignoreCache = false);
+    void updateMetatileSelection(QGraphicsSceneMouseEvent *event);
+
+private:
+    void paintNormal(int x, int y);
+    void paintSmartPath(int x, int y);
+    static QList<int> smartPathTable;
+
+signals:
+    void mouseEvent(QGraphicsSceneMouseEvent *, MapPixmapItem *);
+    void hoveredMapMetatileChanged(int x, int y);
+    void hoveredMapMetatileCleared();
+
+protected:
+    void hoverMoveEvent(QGraphicsSceneHoverEvent*);
+    void hoverLeaveEvent(QGraphicsSceneHoverEvent*);
+    void mousePressEvent(QGraphicsSceneMouseEvent*);
+    void mouseMoveEvent(QGraphicsSceneMouseEvent*);
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent*);
+};
+
+#endif // MAPPIXMAPITEM_H

include/ui/mapsceneeventfilter.h

@@ -0,0 +1,19 @@
+#ifndef MAPSCENEEVENTFILTER_H
+#define MAPSCENEEVENTFILTER_H
+
+#include <QObject>
+
+class MapSceneEventFilter : public QObject
+{
+    Q_OBJECT
+protected:
+    bool eventFilter(QObject *obj, QEvent *event) override;
+public:
+    explicit MapSceneEventFilter(QObject *parent = nullptr);
+
+signals:
+    void wheelZoom(int delta);
+public slots:
+};
+
+#endif // MAPSCENEEVENTFILTER_H

include/ui/metatileselector.h

@@ -0,0 +1,51 @@
+#ifndef METATILESELECTOR_H
+#define METATILESELECTOR_H
+
+#include "selectablepixmapitem.h"
+#include "tileset.h"
+
+class MetatileSelector: public SelectablePixmapItem {
+    Q_OBJECT
+public:
+    MetatileSelector(int numMetatilesWide, Tileset *primaryTileset, Tileset *secondaryTileset): SelectablePixmapItem(16, 16) {
+        this->externalSelection = false;
+        this->numMetatilesWide = numMetatilesWide;
+        this->primaryTileset = primaryTileset;
+        this->secondaryTileset = secondaryTileset;
+        this->selectedMetatiles = new QList<uint16_t>();
+        this->externalSelectedMetatiles = new QList<uint16_t>();
+        setAcceptHoverEvents(true);
+    }
+    QPoint getSelectionDimensions();
+    void draw();
+    void select(uint16_t metatile);
+    void setTilesets(Tileset*, Tileset*);
+    QList<uint16_t>* getSelectedMetatiles();
+    void setExternalSelection(int, int, QList<uint16_t>*);
+protected:
+    void mousePressEvent(QGraphicsSceneMouseEvent*);
+    void mouseMoveEvent(QGraphicsSceneMouseEvent*);
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent*);
+    void hoverMoveEvent(QGraphicsSceneHoverEvent*);
+    void hoverLeaveEvent(QGraphicsSceneHoverEvent*);
+private:
+    bool externalSelection;
+    int numMetatilesWide;
+    Tileset *primaryTileset;
+    Tileset *secondaryTileset;
+    QList<uint16_t> *selectedMetatiles;
+    int externalSelectionWidth;
+    int externalSelectionHeight;
+    QList<uint16_t> *externalSelectedMetatiles;
+
+    void updateSelectedMetatiles();
+    uint16_t getMetatileId(int x, int y);
+    QPoint getMetatileIdCoords(uint16_t);
+
+signals:
+    void hoveredMetatileSelectionChanged(uint16_t);
+    void hoveredMetatileSelectionCleared();
+    void selectedMetatilesChanged();
+};
+
+#endif // METATILESELECTOR_H

include/ui/movementpermissionsselector.h

@@ -0,0 +1,29 @@
+#ifndef MOVEMENTPERMISSIONSSELECTOR_H
+#define MOVEMENTPERMISSIONSSELECTOR_H
+
+#include "selectablepixmapitem.h"
+
+class MovementPermissionsSelector: public SelectablePixmapItem {
+    Q_OBJECT
+public:
+    MovementPermissionsSelector(): SelectablePixmapItem(32, 32, 1, 1) {
+        setAcceptHoverEvents(true);
+    }
+    void draw();
+    uint16_t getSelectedCollision();
+    uint16_t getSelectedElevation();
+    void select(uint16_t collision, uint16_t elevation);
+
+protected:
+    void hoverMoveEvent(QGraphicsSceneHoverEvent*);
+    void hoverLeaveEvent(QGraphicsSceneHoverEvent*);
+
+private:
+    void setSelectedMovementPermissions(QPointF);
+
+signals:
+    void hoveredMovementPermissionChanged(uint16_t, uint16_t);
+    void hoveredMovementPermissionCleared();
+};
+
+#endif // MOVEMENTPERMISSIONSSELECTOR_H

include/ui/neweventtoolbutton.h

@@ -0,0 +1,37 @@
+#ifndef NEWEVENTTOOLBUTTON_H
+#define NEWEVENTTOOLBUTTON_H
+
+#include "event.h"
+#include <QToolButton>
+
+class NewEventToolButton : public QToolButton
+{
+    Q_OBJECT
+public:
+    explicit NewEventToolButton(QWidget *parent = nullptr);
+    QString getSelectedEventType();
+public slots:
+    void newObject();
+    void newWarp();
+    void newHealLocation();
+    void newCoordScript();
+    void newCoordWeather();
+    void newSign();
+    void newHiddenItem();
+    void newSecretBase();
+signals:
+    void newEventAdded(QString);
+private:
+    QString selectedEventType;
+    QAction *newObjectAction;
+    QAction *newWarpAction;
+    QAction *newHealLocationAction;
+    QAction *newCoordScriptAction;
+    QAction *newCoordWeatherAction;
+    QAction *newSignAction;
+    QAction *newHiddenItemAction;
+    QAction *newSecretBaseAction;
+    void init();
+};
+
+#endif // NEWEVENTTOOLBUTTON_H

include/ui/noscrollcombobox.h

@@ -0,0 +1,17 @@
+#ifndef NOSCROLLCOMBOBOX_H
+#define NOSCROLLCOMBOBOX_H
+
+#include <QComboBox>
+
+class NoScrollComboBox : public QComboBox
+{
+    Q_OBJECT
+
+public:
+    explicit NoScrollComboBox(QWidget *parent = nullptr);
+    void wheelEvent(QWheelEvent *event);
+
+private:
+};
+
+#endif // NOSCROLLCOMBOBOX_H

include/ui/noscrollspinbox.h

@@ -0,0 +1,17 @@
+#ifndef NOSCROLLSPINBOX_H
+#define NOSCROLLSPINBOX_H
+
+#include <QSpinBox>
+
+class NoScrollSpinBox : public QSpinBox
+{
+    Q_OBJECT
+
+public:
+    explicit NoScrollSpinBox(QWidget *parent = nullptr);
+    void wheelEvent(QWheelEvent *event);
+
+private:
+};
+
+#endif // NOSCROLLSPINBOX_H

include/ui/selectablepixmapitem.h

@@ -0,0 +1,40 @@
+#ifndef SELECTABLEPIXMAPITEM_H
+#define SELECTABLEPIXMAPITEM_H
+
+#include <QGraphicsPixmapItem>
+#include <QGraphicsSceneMouseEvent>
+
+class SelectablePixmapItem : public QObject, public QGraphicsPixmapItem {
+    Q_OBJECT
+public:
+    SelectablePixmapItem(int cellWidth, int cellHeight): SelectablePixmapItem(cellWidth, cellHeight, INT_MAX, INT_MAX) {}
+    SelectablePixmapItem(int cellWidth, int cellHeight, int maxSelectionWidth, int maxSelectionHeight) {
+        this->cellWidth = cellWidth;
+        this->cellHeight = cellHeight;
+        this->maxSelectionWidth = maxSelectionWidth;
+        this->maxSelectionHeight = maxSelectionHeight;
+    }
+    virtual QPoint getSelectionDimensions();
+    virtual void draw() = 0;
+
+protected:
+    int cellWidth;
+    int cellHeight;
+    int maxSelectionWidth;
+    int maxSelectionHeight;
+    int selectionInitialX;
+    int selectionInitialY;
+    int selectionOffsetX;
+    int selectionOffsetY;
+
+    QPoint getSelectionStart();
+    void select(int, int, int, int);
+    void updateSelection(int, int);
+    QPoint getCellPos(QPointF);
+    void mousePressEvent(QGraphicsSceneMouseEvent*);
+    void mouseMoveEvent(QGraphicsSceneMouseEvent*);
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent*);
+    virtual void drawSelection();
+};
+
+#endif // SELECTABLEPIXMAPITEM_H