ActivateEventPublishing.groovy

import org.freeplane.features.map.*
import org.freeplane.features.mode.Controller

import com.rabbitmq.client.Channel
import com.rabbitmq.client.Connection
import com.rabbitmq.client.ConnectionFactory

import groovy.json.JsonOutput

class Publisher {
    void publish(String message) {
        final String QUEUE_NAME = "hello"

        ConnectionFactory factory = new ConnectionFactory()
        factory.setHost("localhost")
        Connection connection = factory.newConnection()
        Channel channel = connection.createChannel()

        channel.queueDeclare(QUEUE_NAME, false, false, false, null)

        channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"))

        channel.close()
        connection.close()
    }
}

class MapChangeListener extends AMapChangeListenerAdapter {
    def publisher

    MapChangeListener(publisher) {
        this.publisher = publisher
    }

    void mapChanged(MapChangeEvent event) {
        def message = [
                event: "map_changed",//TODO
        ]

        send(message)
    }

    void onNodeDeleted(NodeDeletionEvent event) {
        def message = [
                event: "node_deleted",
                parent: event.parent.ID,
                node: event.node.ID,
                index: event.index
        ]

        send(message)
    }

    void onNodeInserted(NodeModel parent, NodeModel child, int newIndex) {
        child.createID() // generate node ID if not yet generated

        def message = [
                event: "node_inserted",
                parent: parent.ID,
                child: child.ID,
                index: newIndex
        ]

        send(message)
    }

    void onNodeMoved(NodeMoveEvent nodeMoveEvent) {
        def message = [
                event: "node_moved",
                oldParent: nodeMoveEvent.oldParent.ID,
                oldIndex: nodeMoveEvent.oldIndex,
                oldSideLeft: nodeMoveEvent.oldSideLeft,
                newParent: nodeMoveEvent.newParent.ID,
                child: nodeMoveEvent.child.ID,
                newIndex: nodeMoveEvent.newIndex,
                newSideLeft: nodeMoveEvent.newSideLeft,
        ]

        send(message)
    }

    void nodeChanged(NodeChangeEvent event) {
        if (NodeModel.NODE_TEXT == event.property) {
            def message = [
                    event: "node_changed",
                    property: event.property,
                    node: event.node.ID,
                    newValue: event.newValue,
                    oldValue: event.oldValue,
            ]

            send(message)
        }
      //TODO
    }

    void onCreate(MapModel map) {
        def message = [
                event: "map_created", //TODO
        ]

        send(message)
    }

    void onRemove(MapModel map) {
        def message = [
                event: "map_removed", //TODO
        ]

        send(message)
    }

    private send(message) {
        def json = JsonOutput.toJson(message)
        publisher.publish(json)
    }
}

def listener = new MapChangeListener(new Publisher())

def mapController = Controller.currentModeController.mapController

mapController.mapChangeListeners
        .findAll { it.getClass().name == MapChangeListener.class.name }
        .each { mapController.removeMapChangeListener(it) }
mapController.addMapChangeListener(listener)

mapController.nodeChangeListeners
        .findAll { it.getClass().name == MapChangeListener.class.name }
        .each { mapController.removeNodeChangeListener(it) }
mapController.addNodeChangeListener(listener)

mapController.mapLifeCycleListeners
        .findAll { it.getClass().name == MapChangeListener.class.name }
        .each { mapController.removeMapLifeCycleListener(it) }
mapController.addMapLifeCycleListener(listener)