gsettings_bridge.js

/*
 * GPII Node.js GSettings Bridge
 *
 * Copyright 2012 Steven Githens
 *
 * Licensed under the New BSD license. You may not use this file except in
 * compliance with this License.
 *
 * You may obtain a copy of the License at
 * https://github.com/GPII/linux/blob/master/LICENSE.txt
 *
 * The research leading to these results has received funding from the European Union's
 * Seventh Framework Programme (FP7/2007-2013)
 * under grant agreement no. 289016.
 */

"use strict";

var fluid = require("universal");
var gpii = fluid.registerNamespace("gpii");
var nodeGSettings = require("./nodegsettings/build/Release/nodegsettings.node");

fluid.registerNamespace("gpii.gsettings");
fluid.registerNamespace("gpii.gsettings.launch");

fluid.defaults("gpii.gsettings.setSingleKey", {
    gradeNames: "fluid.function",
    argumentMap: {
        schemaId: 0,
        key: 1,
        value: 2
    }
});

fluid.defaults("gpii.gsettings.getSingleKey", {
    gradeNames: "fluid.function",
    argumentMap: {
        schemaId: 0,
        key: 1
    }
});

gpii.gsettings.getSingleKey = function (schemaId, key) {
    return nodeGSettings.get_gsetting(schemaId, key);
};

gpii.gsettings.setSingleKey = function (schemaId, key, value) {
    nodeGSettings.set_gsetting(schemaId, key, value);
};

gpii.gsettings.get = function (settingsArray) {
    return gpii.settingsHandlers.transformPayload(settingsArray, function (entry) {
        var schemaId = entry.options.schema;
        var settings = entry.settings;
        var keys = nodeGSettings.get_gsetting_keys(schemaId);

        if (settings === null) {
            settings = {};
            for (var k = 0; k < keys.length; k++) {
                var key = keys[k];
                settings[key] = nodeGSettings.get_gsetting(schemaId, key);
            }
        }
        else {
            for (var settingKey in settings) {
                if (keys.indexOf(settingKey) === -1) {
                    continue;
                }
                settings[settingKey] = nodeGSettings.get_gsetting(schemaId, settingKey);
            }
        }
        return { settings: settings };
    });
};

gpii.gsettings.set = function (settingsArray) {
    return gpii.settingsHandlers.transformPayload(settingsArray, function (entry) {
        var schemaId = entry.options.schema;
        var settings = entry.settings;
        var keys = nodeGSettings.get_gsetting_keys(schemaId);

        for (var settingKey in settings) {
            if (keys.indexOf(settingKey) === -1) {
                continue;
            }
            var value = settings[settingKey];
            var oldValue = nodeGSettings.get_gsetting(schemaId, settingKey);
            nodeGSettings.set_gsetting(schemaId, settingKey, value);
            settings[settingKey] = {
                "oldValue": oldValue,
                "newValue": value
            };
        }
        return { settings: settings};
    });
};


gpii.gsettings.launch.get = function (settingsArray) {
    return gpii.settingsHandlers.transformPayload(settingsArray, function (entry) {
        var options = entry.options;
        var keys = nodeGSettings.get_gsetting_keys(options.schema);
        if (keys.indexOf(options.key) === -1) {
            fluid.log(fluid.logLevel.FAIL, "ERROR: invalid key " + options.key +
                " sent to gsettings launch (get) handler for schema " + options.schema);
            return {};
        }

        return {
            settings: {
                running: nodeGSettings.get_gsetting(options.schema, options.key)
            }
        };
    });
};

gpii.gsettings.launch.set = function (settingsArray) {
    return gpii.settingsHandlers.transformPayload(settingsArray, function (entry) {
        var options = entry.options;
        var action = entry.settings.running;
        var keys = nodeGSettings.get_gsetting_keys(options.schema);
        if (keys.indexOf(options.key) === -1) {
            fluid.log(fluid.logLevel.FAIL, "ERROR: invalid key " + options.key +
                " sent to gsettings launch (set) handler for schema " + options.schema);
            return {};
        }

        var oldValue = nodeGSettings.get_gsetting(options.schema, options.key);
        nodeGSettings.set_gsetting(options.schema, options.key, action);
        return {
            settings: {
                running: {
                    "oldValue": oldValue,
                    "newValue": action
                }
            }
        };
    });
};