function initMarkerPopupStreams() {
var popupOpenStream =
Bacon.fromEventTarget(_markerFeatureGroup, 'popupopen'),
popupClosedStream =
Bacon.fromEventTarget(_markerFeatureGroup, 'popupclose');
var locationForCurrentPopup =
_state.locationChangesProperty.sampledBy(
popupOpenStream.map('.layer.uid'),
findLocationByUid
);
var treeForCurrentPopup =
_state.treeChangesProperty.sampledBy(
locationForCurrentPopup.map('.treeUid'),
findTreeByUid
);
var renderPopupContent = function(loc, popup, tree) {
var species = _.find(_species, {otm_code: tree.species()}),
html = renderTemplate(templates.markerPopup, {
tree: tree,
loc: loc,
speciesName: species && species.common_name
});
popup.setContent(html);
};
// Return a stream that will emit a signal when the popup is closed
// or the relevant tree has been deleted.
var getPopupClosedStream = function(loc) {
return Bacon.mergeAll(
popupClosedStream,
_state.locationRemovedStream.filter(function(uid) {
return loc.uid() === uid;
})
);
};
var updatePopupWhenTreeChages = function(loc, popup, tree) {
_state.treeUpdatedStream
.takeUntil(getPopupClosedStream(loc))
.filter(function(other) {
return tree.uid() === other.uid();
})
.onValue(renderPopupContent, loc, popup);
};
Bacon.zipAsArray(
locationForCurrentPopup,
popupOpenStream.map('.popup'),
treeForCurrentPopup
).onValues(function(loc, popup, tree) {
renderPopupContent(loc, popup, tree);
updatePopupWhenTreeChages(loc, popup, tree);
});
}
function init(options) {
_strings = options.strings;
_urls = new ModelingUrls(options.urls);
_map = options.map;
_mapManager = options.mapManager;
_staticUrl = options.config.staticUrl;
_species = options.species;
_interruptStream = options.interruptStream;
_state = new ScenarioState(_strings);
modelingParamUI.init(_state, _species);
_mapManager.customizeVertexIcons();
// Draw distributions panel.
var html = renderTemplate(templates.distributions);
$(dom.distributionsContainer).append(html);
_state.treeChangesProperty.onValue(redrawTrees);
_state.locationChangesProperty.onValue(redrawMarkers);
_state.polygonChangesProperty.onValue(redrawDistributionPolygon);
initUiStreams();
initMarkerPopupStreams();
initPolygonPopupStreams();
plotMarker.init(_map);
plotMarker.useTreeIcon(true);
setupCollapsiblePanel(dom.distributionRedrawArea);
_map.addLayer(_markerFeatureGroup);
_map.addLayer(_polygonFeatureGroup);
_mapManager.layersControl.addOverlay(_markerFeatureGroup, _strings.TREE_MARKERS);
_mapManager.layersControl.addOverlay(_polygonFeatureGroup, _strings.LAND_USE_DISTRIBUTION_AREA);
// Redraw tree panel if poylgon is added or removed.
_state.treeChangesProperty.sampledBy(
Bacon.mergeAll(
Bacon.fromEventTarget(_polygonFeatureGroup, 'layeradd'),
Bacon.fromEventTarget(_polygonFeatureGroup, 'layerremove')
)
).onValue(redrawTrees);
return {
serializedProperty: _state.serializedProperty,
load: _.bind(_state.load, _state),
reset: _.bind(_state.reset, _state)
};
}
_.each(locations, function(loc) {
var marker = createMarker(new L.LatLng(loc.lat(), loc.lng()));
marker.uid = F.getter(loc.uid());
marker.addTo(_markerFeatureGroup);
Bacon.fromEventTarget(marker, 'dragend')
.takeUntil(Bacon.fromEventTarget(marker, 'remove'))
.map(marker, 'getLatLng')
.map(function(latlng) {
return loc.clone({
lat: latlng.lat,
lng: latlng.lng
});
})
.onValue(_state, 'updateLocation');
});
var relayInputStream = function (relayModule, options) {
return common.eventStream(Bacon.fromEventTarget(relayModule, "latch", function (channelNumber, state) {
return state;
}), {source: options.name, type: "relayState"}, function transformRelayEvent(value, event) {
event.latch = value ? "closed" : "open";
event.channel = options.channel;
}, true);
};
// Draw polygon then add it to the map, unless it was canceled.
function drawArea() {
var interaction = new Interaction(),
newPolygonStream = Bacon.fromEventTarget(_map, 'draw:created')
.takeWhile(interaction.inProgress)
.map('.layer'),
drawer = new L.Draw.Polygon(_map, {showArea: true});
drawer.enable();
managePolygonCreation(
interaction, newPolygonStream, _strings.PROMPT_DRAW_AREA);
interaction.onEnd(function() {
drawer.disable();
});
return newPolygonStream;
}
function selectArea() {
var interaction = new Interaction(),
newPolygonStream = Bacon.fromEventTarget(_map, 'click')
.takeWhile(interaction.inProgress)
.map(getLatLng)
.flatMap(BU.jsonRequest('GET', _urls.boundariesAtPointUrl()))
.flatMap(disambiguateAreas)
.filter('.geom') // ignore clicks that missed all areas
.map(function(area) {
var geoJson = JSON.parse(area.geom),
layerGroup = L.geoJson(geoJson),
layer = layerGroup.getLayers()[0];
return layer;
});
managePolygonCreation(
interaction, newPolygonStream, _strings.PROMPT_SELECT_AREA);
}
start.onValue(value => {
const ws = new WebSocket(value.websocketUrl);
Bacon.fromEventTarget(ws, "message").onValue(event => {
Dispatcher.dispatch(JediConstants.WORLD_CHANGED, JSON.parse(event.data));
});
});
var mutateStream;
var renderTriggerStream;
var renderStream;
// Starting state
initialState = m.hash_map(
'user', null,
'plans', m.vector()
);
// Mutator
mutator = new Mutator(initialState);
// EventStream for every mutation, with detailed payload including previous and
// new states, and a human-readable message.
mutateStream = Bacon.fromEventTarget(mutator, 'change');
// Our global state (Bacon Property)
state = mutateStream
.map('.state')
.toProperty(initialState);
// State History is a mori vector accumulating all the state changes
stateHistory = state.scan(m.vector(), function(history, newState) {
//
//TODO Do we want to limit this?
//
return m.conj(history, newState);
});
// Render trigger stream
var baconStream = _.curry(function (event, target) {
return Bacon.fromEventTarget(target, event);
});
var brukere = bacon.fromPromise($.get('/brukere'))
.map(function(val) {
each(val, function(bruker) {
bruker.value = bruker.name;
bruker.tokens = bruker.value.split(' ');
});
return val;
}).toProperty();
brukere.onValue(function(brukere) {
initTypeahead($('input.navn'), brukere);
});
var leggTilPerson = bacon.fromEventTarget($('#ny-person'), 'click')
.doAction('.preventDefault');
brukere.sampledBy(leggTilPerson).onValue(function(brukere) {
var row = $(template);
$('#kryss form fieldset').append(row);
initTypeahead(row.find('input.navn'), brukere);
});
var lagre = bacon.fromEventTarget($('#lagre'), 'click')
.doAction('.preventDefault');
brukere.sampledBy(lagre).onValue(function(brukere) {
var kommentar = $('#kommentar').val();
var olPris = $('#ol-pris').val();
var kryss = map($('#kryss form fieldset > div'), function(elem) {
'use strict';
import Bacon from 'baconjs';
import keycode from 'keycode';
const EVENT_KEYUP = Bacon.fromEventTarget(document, 'keyup');
const EVENT_KEYDOWN = Bacon.fromEventTarget(document, 'keydown');
/**
* create EventStream from user input
*/
export default {
/**
* @param {String|Number} charKey
* @returns {EventStream}
*/
key(charKey) {
let keyCode = typeof(charKey) === 'string' ? keycode(charKey)
: charKey;
return EVENT_KEYUP.filter(keyCodeIs(keyCode));
},
/**
* @param {String|Number} charKey
* @returns {EventStream}
*/
keydown(charKey) {
let keyCode = typeof(charKey) === 'string' ? keycode(charKey)
: charKey;
return EVENT_KEYDOWN.filter(keyCodeIs(keyCode));
},