Macaw/radio
3
0
Fork 0
Code Issues 3 Pull requests Releases Wiki Activity

initial commit

Browse source
This commit is contained in:
Blue 2018-08-05 00:46:25 +03:00 • committed by Юрий Губич
commit 4b60ece582
327 changed files with 28286 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

19
libjs/wController/CMakeLists.txt Normal file
View file

@ -0,0 +1,19 @@
cmake_minimum_required(VERSION 2.8.12)
configure_file(controller.js controller.js)
configure_file(globalControls.js globalControls.js)
configure_file(link.js link.js)
configure_file(list.js list.js)
configure_file(navigationPanel.js navigationPanel.js)
configure_file(page.js page.js)
configure_file(pageStorage.js pageStorage.js)
configure_file(panesList.js panesList.js)
configure_file(string.js string.js)
configure_file(theme.js theme.js)
configure_file(themeSelecter.js themeSelecter.js)
configure_file(vocabulary.js vocabulary.js)
configure_file(attributes.js attributes.js)
configure_file(localModel.js localModel.js)
configure_file(catalogue.js catalogue.js)
configure_file(imagePane.js imagePane.js)
configure_file(file/file.js file/file.js)

1
libjs/wController/attributes.js Normal file
View file

@ -0,0 +1 @@
"use strict";

141
libjs/wController/catalogue.js Normal file
View file

@ -0,0 +1,141 @@
"use strict";
var Controller = require("./controller");
var AbstractOrder = require("../wContainer/abstractorder");
var Uint64 = require("../wType/uint64");
var Vocabulary = require("../wType/vocabulary");
var Boolean = require("../wType/boolean");
var String = require("../wType/string");
var IdOrder = AbstractOrder.template(Uint64);
var Catalogue = Controller.inherit({
"className": "Catalogue",
"constructor": function(addr, options) {
Controller.fn.constructor.call(this, addr);
this._hasSorting = false;
this._hasFilter = false;
this._filter = undefined;
this.data = new IdOrder(true);
if (options.sorting) {
this._hasSorting = true;
this._sorting = new Vocabulary();
this._sorting.insert("ascending", new Boolean(options.sorting.ascending));
this._sorting.insert("field", new String(options.sorting.field));
}
if (options.filter) {
var filter = new Vocabulary();
for (var key in options.filter) {
if (options.filter.hasOwnProperty(key)) {
filter.insert(key, options.filter[key]);
}
}
if (filter.length()) {
this._filter = filter;
this._hasFilter = true;
} else {
filter.destructor();
}
}
this.addHandler("get");
this.addHandler("addElement");
this.addHandler("removeElement");
this.addHandler("moveElement");
this.addHandler("clear");
},
"destructor": function() {
this.data.destructor();
if (this._hasSorting) {
this._sorting.destructor();
}
if (this._hasFilter) {
this._filter.destructor();
}
Controller.fn.destructor.call(this);
},
"addElement": function(element, before) {
if (before === undefined) {
this.data.push_back(element);
} else {
this.data.insert(element, before);
}
this.trigger("addElement", element, before);
},
"clear": function() {
this.data.clear();
this.trigger("clear");
},
"_createSubscriptionVC": function() {
var vc = Controller.fn._createSubscriptionVC.call(this);
var p = new Vocabulary();
if (this._hasSorting) {
p.insert("sorting", this._sorting.clone());
}
if (this._hasFilter) {
p.insert("filter", this._filter.clone());
}
vc.insert("params", p);
return vc;
},
"_h_addElement": function(ev) {
var data = ev.getData();
var id = data.at("id").clone();
var before = undefined;
if (data.has("before")) {
before = data.at("before").clone();
}
this.addElement(id, before);
},
"_h_get": function(ev) {
this.clear();
var data = ev.getData().at("data");
var size = data.length();
for (var i = 0; i < size; ++i) {
this.addElement(data.at(i).clone());
}
this.initialized = true;
this.trigger("data");
},
"_h_moveElement": function(ev) {
var data = ev.getData();
var id = data.at("id").clone();
var before = undefined;
if (data.has("before")) {
before = data.at("before").clone();
}
this.data.erase(id);
if (before === undefined) {
this.data.push_back(element);
} else {
this.data.insert(element, before);
}
this.trigger("moveElement", id, before);
},
"_h_removeElement": function(ev) {
var data = ev.getData();
this.removeElement(data.at("id").clone());
},
"_h_clear": function(ev) {
this.clear();
},
"removeElement": function(id) {
this.data.erase(id);
this.trigger("removeElement", id);
}
});
module.exports = Catalogue;

382
libjs/wController/controller.js Normal file
View file

@ -0,0 +1,382 @@
"use strict";
var counter = 0;
var Subscribable = require("../utils/subscribable");
var Handler = require("../wDispatcher/handler");
var Address = require("../wType/address");
var String = require("../wType/string");
var Vocabulary = require("../wType/vocabulary");
var Event = require("../wType/event");
var counter = 0;
var Controller = Subscribable.inherit({
"className": "Controller",
"constructor": function(addr) {
Subscribable.fn.constructor.call(this);
this.id = ++counter;
this.initialized = false;
this._subscribed = false;
this._registered = false;
this._pairAddress = addr;
this._address = new Address([this.className.toString() + counter++]);
this._handlers = [];
this._controllers = [];
this.properties = [];
this._foreignControllers = [];
this.addHandler("properties");
},
"destructor": function() {
var i;
if (this._subscribed) {
this.unsubscribe();
}
if (this._registered) {
this.unregister();
}
for (i = 0; i < this._foreignControllers.length; ++i) {
this._foreignControllers[i].c.destructor();
}
for (i = 0; i < this._controllers.length; ++i) {
this._controllers[i].destructor();
}
for (i = 0; i < this._handlers.length; ++i) {
this._handlers[i].destructor();
}
this._pairAddress.destructor();
this._address.destructor();
Subscribable.fn.destructor.call(this);
},
"addController": function(controller, before) {
if (!(controller instanceof Controller)) {
throw new Error("An attempt to add not a controller into " + this.className);
}
controller.on("serviceMessage", this._onControllerServiceMessage, this);
var index = this._controllers.length;
if (before === undefined) {
this._controllers.push(controller);
} else {
index = before;
this._controllers.splice(before, 0, controller);
}
if (this._registered) {
controller.register(this._dp, this._socket);
}
if (this._subscribed && !controller._subscribed) {
this._subscribeChildController(index);
}
this.trigger("newController", controller, index);
},
"addForeignController": function(nodeName, ctrl) {
if (!(ctrl instanceof Controller)) {
throw new Error("An attempt to add not a controller into " + this.className);
}
this._foreignControllers.push({n: nodeName, c: ctrl});
ctrl.on("serviceMessage", this._onControllerServiceMessage, this);
if (this._registered) {
global.registerForeignController(nodeName, ctrl);
}
if (this._subscribed) {
global.subscribeForeignController(nodeName, ctrl);
}
},
"addHandler": function(name) {
if (!(this["_h_" + name] instanceof Function)) {
throw new Error("An attempt to create handler without a handling method");
}
var handler = new Handler(this._address["+"](new Address([name])), this, this["_h_" + name]);
this._handlers.push(handler);
if (this._registered) {
this._dp.registerHandler(handler);
}
},
"clearChildren": function() {
while (this._controllers.length) {
var controller = this._controllers[this._controllers.length - 1]
this._removeController(controller);
controller.destructor();
}
},
"_createSubscriptionVC": function() {
return new Vocabulary();
},
"getPairAddress": function() {
return this._pairAddress.clone();
},
"_h_properties": function(ev) {
this.trigger("clearProperties");
this.properties = [];
var data = ev.getData();
var list = data.at("properties");
var size = list.length();
for (var i = 0; i < size; ++i) {
var vc = list.at(i);
var pair = {p: vc.at("property").toString(), k: vc.at("key").toString()};
this.properties.push(pair);
this.trigger("addProperty", pair.k, pair.p);
}
},
"_onControllerServiceMessage": function(msg, severity) {
this.trigger("serviceMessage", msg, severity);
},
"_onSocketDisconnected": function() {
this._subscribed = false;
},
"register": function(dp, socket) {
var i;
if (this._registered) {
throw new Error("Controller " + this._address.toString() + " is already registered");
}
this._dp = dp;
this._socket = socket;
socket.on("disconnected", this._onSocketDisconnected, this);
for (i = 0; i < this._controllers.length; ++i) {
this._controllers[i].register(this._dp, this._socket);
}
for (i = 0; i < this._handlers.length; ++i) {
dp.registerHandler(this._handlers[i]);
}
for (i = 0; i < this._foreignControllers.length; ++i) {
var pair = this._foreignControllers[i]
global.registerForeignController(pair.n, pair.c);
}
this._registered = true;
},
"removeController": function(ctrl) {
if (!(ctrl instanceof Controller)) {
throw new Error("An attempt to remove not a controller from " + this.className);
}
var index = this._controllers.indexOf(ctrl);
if (index !== -1) {
this._removeControllerByIndex(index);
} else {
throw new Error("An attempt to remove not not existing controller from " + this.className);
}
},
"removeForeignController": function(ctrl) {
if (!(ctrl instanceof Controller)) {
throw new Error("An attempt to remove not a controller from " + this.className);
}
for (var i = 0; i < this._foreignControllers.length; ++i) {
if (this._foreignControllers[i].c === ctrl) {
break;
}
}
if (i === this._foreignControllers.length) {
throw new Error("An attempt to remove not not existing controller from " + this.className);
} else {
var pair = this._foreignControllers[i];
if (this._subscribed) {
global.unsubscribeForeignController(pair.n, pair.c);
}
if (this._registered) {
global.registerForeignController(pair.n, pair.c);
}
pair.c.off("serviceMessage", this._onControllerServiceMessage, this);
this._foreignControllers.splice(i, 1);
}
},
"_removeControllerByIndex": function(index) {
var ctrl = this._controllers[index];
if (this._subscribed) {
this._unsubscribeChildController(index);
}
if (this._dp) {
ctrl.unregister();
}
this._controllers.splice(index, 1);
this.trigger("removedController", ctrl, index);
},
"send": function(vc, handler) {
if (!this._registered) {
throw new Error("An attempt to send event from model " + this._address.toString() + " which is not registered");
}
var addr = this._pairAddress["+"](new Address([handler]));
var id = this._socket.getId().clone();
vc.insert("source", this._address.clone());
var ev = new Event(addr, vc);
ev.setSenderId(id);
this._socket.send(ev);
ev.destructor();
},
"subscribe": function() {
if (this._subscribed) {
throw new Error("An attempt to subscribe model " + this._address.toString() + " which is already subscribed");
}
this._subscribed = true;
var vc = this._createSubscriptionVC();
this.send(vc, "subscribe");
for (var i = 0; i < this._controllers.length; ++i) {
this._subscribeChildController(i)
}
for (var i = 0; i < this._foreignControllers.length; ++i) {
var pair = this._foreignControllers[i]
global.subscribeForeignController(pair.n, pair.c);
}
},
"_subscribeChildController": function(index) {
var ctrl = this._controllers[index];
ctrl.subscribe();
},
"unregister": function() {
if (!this._registered) {
throw new Error("Controller " + this._address.toString() + " is not registered");
}
var i;
for (i = 0; i < this._foreignControllers.length; ++i) {
var pair = this._foreignControllers[i]
global.unregisterForeignController(pair.n, pair.c);
}
for (i = 0; i < this._controllers.length; ++i) {
this._controllers[i].unregister();
}
for (i = 0; i < this._handlers.length; ++i) {
this._dp.unregisterHandler(this._handlers[i]);
}
this._socket.off("disconnected", this._onSocketDisconnected, this);
delete this._dp;
delete this._socket;
this._registered = false;
},
"unsubscribe": function() {
if (!this._subscribed) {
throw new Error("An attempt to unsubscribe model " + this._address.toString() + " which is not subscribed");
}
this._subscribed = false;
if (this._socket.isOpened()) {
var vc = new Vocabulary();
this.send(vc, "unsubscribe");
}
for (var i = 0; i < this._foreignControllers.length; ++i) {
var pair = this._foreignControllers[i]
global.unsubscribeForeignController(pair.n, pair.c);
}
for (var i = 0; i < this._controllers.length; ++i) {
this._unsubscribeChildController(i);
}
},
"_unsubscribeChildController": function(index) {
var ctrl = this._controllers[index];
ctrl.unsubscribe();
}
});
Controller.createByType = function(type, address) {
var typeName = this.ReversedModelType[type];
if (typeName === undefined) {
throw new Error("Unknown ModelType: " + type);
}
var Type = this.constructors[typeName];
if (Type === undefined) {
throw new Error("Constructor is not loaded yet, something is wrong");
}
return new Type(address);
}
Controller.initialize = function(rc, cb) {
var deps = [];
var types = [];
for (var key in this.ModelTypesPaths) {
if (this.ModelTypesPaths.hasOwnProperty(key)) {
if (!rc || rc.indexOf(key) !== -1) {
deps.push(this.ModelTypesPaths[key]);
types.push(key);
}
}
}
require(deps, function() {
for (var i = 0; i < types.length; ++i) {
Controller.constructors[types[i]] = arguments[i];
}
cb();
});
}
Controller.ModelType = {
String: 0,
List: 1,
Vocabulary: 2,
Image: 3,
Controller: 4,
Attributes: 50,
GlobalControls: 100,
Link: 101,
Page: 102,
PageStorage: 103,
PanesList: 104,
Theme: 105,
ThemeStorage: 106
};
Controller.ReversedModelType = {
"0": "String",
"1": "List",
"2": "Vocabulary",
"3": "Image",
"4": "Controller",
"50": "Attributes",
"100": "GlobalControls",
"101": "Link",
"102": "Page",
"103": "PageStorage",
"104": "PanesList",
"105": "Theme",
"106": "ThemeStorage"
};
Controller.ModelTypesPaths = {
String: "./string", //resolve as dependency
List: "./list", //resolve as dependency
Vocabulary: "./vocabulary", //resolve as dependency
Attributes: "./attributes", //resolve as dependency
GlobalControls: "./globalControls", //resolve as dependency
Link: "./link", //resolve as dependency
Page: "./page", //resolve as dependency
PageStorage: "./pageStorage", //resolve as dependency
PanesList: "./panesList", //resolve as dependency
Theme: "./theme", //resolve as dependency
ThemeStorage: "./themeStorage", //resolve as dependency
Image: "./image" //resolve as dependency
};
Controller.constructors = {
Controller: Controller
};
module.exports = Controller;

86
libjs/wController/file/file.js Normal file
View file

@ -0,0 +1,86 @@
"use strict";
var Controller = require("../controller");
var WVocabulary = require("../../wType/vocabulary");
var File = Controller.inherit({
"className": "File",
"constructor": function(addr) {
Controller.fn.constructor.call(this, addr);
this._hasData = false;
this._hasAdditional = false;
this.data = null;
this._additional = null;
this._need = 0;
this.addHandler("get");
this.addHandler("getAdditional");
},
"destructor": function() {
if (this._hasData) {
this.data.destructor();
}
if (this._hasAdditional) {
this._additional.destructor();
}
Controller.fn.destructor.call(this);
},
"dontNeedData": function() {
--this._need;
},
"hasData": function() {
return this._hasData
},
"_getAdditional": function(add) {
var ac = !this._hasAdditional || !this._additional["=="](add);
if (ac) {
if (this._hasAdditional) {
this._additional.destructor();
}
this._additional = add.clone();
}
this._hasAdditional = true;
return ac;
},
"getMimeType": function() {
return this._additional.at("mimeType").toString();
},
"_h_get": function(ev) {
var dt = ev.getData();
var ac = this._getAdditional(dt.at("additional"));
if (ac) {
this.trigger("additionalChange")
}
this._hasData = true;
this.data = dt.at("data").clone();
this.trigger("data");
},
"_h_getAdditional": function(ev) {
var ac = this._getAdditional(ev.getData());
if (ac) {
this.trigger("additionalChange");
}
},
"needData": function() {
if (this._need === 0) {
var vc = new WVocabulary();
this.send(vc, "get");
}
++this._need;
},
"subscribe": function() {
Controller.fn.subscribe.call(this);
if (this._need > 0) {
var vc = new WVocabulary();
this.send(vc, "get");
}
}
});
module.exports = File;

60
libjs/wController/globalControls.js Normal file
View file

@ -0,0 +1,60 @@
"use strict";
var List = require("./list");
var String = require("./string");
var NavigationPanel = require("./navigationPanel");
var ThemeSelecter = require("./themeSelecter");
var Theme = require("./theme");
var GlobalControls = List.inherit({
"className": "GlobalControls",
"constructor": function(address) {
List.fn.constructor.call(this, address);
},
"addElement": function(vc) {
List.fn.addElement.call(this, vc);
var name = vc.at("name").toString();
var type = vc.at("type").toString();
var addr = vc.at("address");
var ctrl;
var supported = true;
switch (name) {
case "version":
ctrl = new String(addr.clone());
break;
case "navigationPanel":
ctrl = new NavigationPanel(addr.clone());
break;
case "themes":
ctrl = new ThemeSelecter(addr.clone());
ctrl.on("selected", this._onThemeSelected, this);
break;
default:
supported = false;
this.trigger("serviceMessage", "Unsupported global control: " + name + " (" + type + ")", 1);
break;
}
if (supported) {
ctrl.name = name;
this.addController(ctrl);
}
},
"clear": function() {
List.fn.clear.call(this);
this.clearChildren();
},
"_onThemeReady": function(theme) {
this.trigger("themeSelected", theme._data);
this.removeController(theme);
theme.destructor();
},
"_onThemeSelected": function(obj) {
var theme = new Theme(obj.value.clone());
this.addController(theme);
theme.on("ready", this._onThemeReady.bind(this, theme));
}
});
module.exports = GlobalControls;

69
libjs/wController/image.js Normal file
View file

@ -0,0 +1,69 @@
"use strict";
var Address = require("../wType/address");
var Controller = require("./controller");
var File = require("./file/file");
var Image = Controller.inherit({
"className": "Image",
"constructor": function(addr) {
Controller.fn.constructor.call(this, addr);
this.data = undefined;
this._hasCtrl = false;
this._fileCtrl = undefined;
this._need = 0;
this.addHandler("get");
},
"dontNeedData": function() {
--this._need;
},
"getMimeType": function () {
return this._fileCtrl.getMimeType();
},
"hasData": function() {
if (this._hasCtrl) {
return this._fileCtrl.hasData();
}
return false;
},
"_h_get": function(ev) {
var data = ev.getData();
if (this._hasCtrl) {
this.removeForeignController(this._fileCtrl);
this._fileCtrl.destructor();
delete this._fileCtrl;
this._hasCtrl = false;
}
var strId = data.at("data").toString();
if (strId !== "0") {
this._fileCtrl = new File(new Address(["images", strId]));
this.addForeignController("Corax", this._fileCtrl);
this._fileCtrl.on("data", this._onControllerData, this);
this._hasCtrl = true;
if (this._need > 0) {
this._fileCtrl.needData();
}
} else {
this.trigger("clear");
}
},
"needData": function() {
if (this._need === 0 && this._hasCtrl) {
this._fileCtrl.needData();
}
++this._need;
},
"_onControllerData": function() {
this.data = this._fileCtrl.data;
this.trigger("data");
}
});
module.exports = Image;

40
libjs/wController/imagePane.js Normal file
View file

@ -0,0 +1,40 @@
"use strict";
var Address = require("../wType/address");
var Vocabulary = require("./vocabulary");
var File = require("./file/file");
var ImagePane = Vocabulary.inherit({
"className": "ImagePane",
"constructor": function(addr) {
Vocabulary.fn.constructor.call(this, addr);
this._hasImage = false;
this.image = null;
},
"addElement": function(key, element) {
if (key === "image" && !this._hasImage) {
this._hasImage = true;
this.image = new File(new Address(["images", element.toString()]));
this.addForeignController("Corax", this.image);
}
Vocabulary.fn.addElement.call(this, key, element);
},
"hasImage": function() {
return this._hasImage;
},
"removeElement": function(key) {
Vocabulary.fn.removeElement.call(this, key);
if (key === "image" && this._hasImage) {
this.removeForeignController(this.image);
this._hasImage = false;
this.image.destructor();
this.image = null;
}
}
});
module.exports = ImagePane;

38
libjs/wController/link.js Normal file
View file

@ -0,0 +1,38 @@
"use strict";
var Controller = require("./controller");
var String = require("./string");
var Address = require("../wType/address");
var Link = Controller.inherit({
"className": "Link",
"constructor": function(addr) {
Controller.fn.constructor.call(this, addr);
var hop = new Address(["label"]);
this.targetAddress = new Address([]);
this.label = new String(addr['+'](hop));
this.addController(this.label);
this.addHandler("get");
hop.destructor();
},
"destructor": function() {
this.targetAddress.destructor();
Controller.fn.destructor.call(this);
},
"_h_get": function(ev) {
var data = ev.getData();
this.targetAddress = data.at("targetAddress").clone();
this.trigger("data", this.targetAddress);
}
});
module.exports = Link;

51
libjs/wController/list.js Normal file
View file

@ -0,0 +1,51 @@
"use strict";
var Controller = require("./controller");
var Vector = require("../wType/vector");
var List = Controller.inherit({
"className": "List",
"constructor": function(addr) {
Controller.fn.constructor.call(this, addr);
this.data = new Vector();
this.addHandler("get");
this.addHandler("push");
this.addHandler("clear");
},
"destructor": function() {
this.data.destructor();
Controller.fn.destructor.call(this);
},
"addElement": function(element) {
this.data.push(element);
this.trigger("newElement", element);
},
"clear": function() {
this.data.clear();
this.trigger("clear");
},
"_h_clear": function(ev) {
this.clear();
},
"_h_get": function(ev) {
this.clear();
var data = ev.getData().at("data");
var size = data.length();
for (var i = 0; i < size; ++i) {
this.addElement(data.at(i).clone());
}
this.initialized = true;
this.trigger("data");
},
"_h_push": function(ev) {
var data = ev.getData();
var element = data.at("data").clone();
this.addElement(element);
}
});
module.exports = List;

28
libjs/wController/localModel.js Normal file
View file

@ -0,0 +1,28 @@
"use strict";
var counter = 0;
var Subscribable = require("../utils/subscribable");
var LocalModel = Subscribable.inherit({
"className": "LocalModel",
"constructor": function(properties) {
Subscribable.fn.constructor.call(this);
this.properties = [];
this._controllers = [];
if (properties) {
for (var key in properties) {
if (properties.hasOwnProperty(key)) {
var pair = {p: key, k: properties[key]};
this.properties.push(pair);
}
}
}
},
"setData": function(data) {
this.data = data;
this.trigger("data");
}
});
module.exports = LocalModel;

24
libjs/wController/navigationPanel.js Normal file
View file

@ -0,0 +1,24 @@
"use strict";
var List = require("./list");
var Link = require("./link");
var NavigationPanel = List.inherit({
"className": "NavigationPanel",
"constructor": function(addr) {
List.fn.constructor.call(this, addr);
},
"addElement": function(element) {
var address = element.at("address").clone();
var ctrl = new Link(address);
this.addController(ctrl);
List.fn.addElement.call(this, element);
},
"clear": function() {
List.fn.clear.call(this);
this.clearChildren();
}
});
module.exports = NavigationPanel;

120
libjs/wController/page.js Normal file
View file

@ -0,0 +1,120 @@
"use strict";
var Controller = require("./controller");
var String = require("./string");
var Vocabulary = require("../wType/vocabulary");
var Address = require("../wType/address");
var AbstractMap = require("../wContainer/abstractmap");
var ContentMap = AbstractMap.template(Address, Object);
var Page = Controller.inherit({
"className": "Page",
"constructor": function(addr) {
Controller.fn.constructor.call(this, addr);
this.data = new ContentMap(false);
this.addHandler("get");
this.addHandler("addItem");
this.addHandler("removeItem");
this.addHandler("clear");
this.elements = [];
},
"destructor": function() {
this.data.destructor();
Controller.fn.destructor.call(this);
},
"addItem": function(element) {
var type = element.at("type").valueOf();
var address = element.at("address").clone();
var col = element.at("col").valueOf();
var row = element.at("row").valueOf();
var colspan = element.at("colspan").valueOf();
var rowspan = element.at("rowspan").valueOf();
var aligment = element.at("aligment").valueOf();
var viewType = element.at("viewType").valueOf();
var opts = Page.deserializeOptions(element.at("viewOptions"));
var controller = Page.createByType(type, address);
this.addController(controller);
var el = {
type: type,
col: col,
row: row,
colspan: colspan,
rowspan: rowspan,
aligment: aligment,
viewType: viewType,
viewOptions: opts,
controller: controller
}
this.data.insert(address, el);
this.trigger("addItem", address, el);
},
"clear": function() {
this.data.clear();
this.trigger("clear");
this.clearChildren();
},
"_h_clear": function(ev) {
this.clear();
},
"_h_get": function(ev) {
this.clear();
var data = ev.getData().at("data");
var size = data.length();
for (var i = 0; i < size; ++i) {
this.addItem(data.at(i).clone());
}
},
"_h_addItem": function(ev) {
var data = ev.getData().clone();
this.addItem(data);
},
"_h_removeItem": function(ev) {
var data = ev.getData();
var address = data.at("address").clone();
this.removeItem(address);
},
"removeItem": function(address) {
var itr = this.data.find(address);
var pair = itr["*"]();
this.data.erase(itr);
this.trigger("removeItem", pair.first);
this.removeController(pair.second.controller);
pair.second.controller.destructor();
}
});
Page.deserializeOptions = function(vc) {
var opts = Object.create(null);
var keys = vc.getKeys();
for (var i = 0; i < keys.length; ++i) {
var value = vc.at(keys[i]);
if (value instanceof Vocabulary) {
value = this.deserializeOptions(value);
} else if(value instanceof Address) { //todo vector!
value = value.clone();
} else {
value = value.valueOf();
}
opts[keys[i]] = value;
}
return opts;
}
module.exports = Page;

38
libjs/wController/pageStorage.js Normal file
View file

@ -0,0 +1,38 @@
"use strict";
var Controller = require("./controller");
var Vocabulary = require("../wType/vocabulary");
var String = require("../wType/string");
var PageStorage = Controller.inherit({
"className": "PageStorage",
"constructor": function(addr) {
Controller.fn.constructor.call(this, addr);
this.addHandler("pageAddress");
this.addHandler("pageName");
},
"getPageAddress": function(url) {
var vc = new Vocabulary();
vc.insert("url", new String(url));
this.send(vc, "getPageAddress");
},
"getPageName": function(address) {
var vc = new Vocabulary();
vc.insert("address", address.clone());
this.send(vc, "getPageName");
},
"_h_pageAddress": function(ev) {
var data = ev.getData();
this.trigger("pageAddress", data.at("address").clone());
},
"_h_pageName": function(ev) {
var data = ev.getData();
this.trigger("pageName", data.at("name").toString());
}
});
module.exports = PageStorage;

80
libjs/wController/panesList.js Normal file
View file

@ -0,0 +1,80 @@
"use strict";
var List = require("./list");
var ImagePane = require("./imagePane");
var Address = require("../wType/address");
var PanesList = List.inherit({
"className": "PanesList",
"constructor": function PanesListModel(addr) {
List.fn.constructor.call(this, addr);
this._subscriptionStart = 0;
this._subscriptionEnd = Infinity;
},
"addElement": function(element) {
var size = this.data.length();
List.fn.addElement.call(this, element);
if (size >= this._subscriptionStart && size < this._subscriptionEnd) {
var controller = new ImagePane(this._pairAddress["+"](new Address([element.toString()])));
this.addController(controller);
}
},
"clear": function() {
List.fn.clear.call(this);
this.clearChildren();
},
"setSubscriptionRange": function(s, e) {
var needStart = s !== this._subscriptionStart;
var needEnd = e !== this._subscriptionEnd;
if (needStart || needEnd) {
var os = this._subscriptionStart;
var oe = this._subscriptionEnd;
this._subscriptionStart = s;
this._subscriptionEnd = e;
if (this._subscribed) {
this.trigger("rangeStart");
if (needStart) {
if (s > os) {
var limit = Math.min(s - os, this._controllers.length);
for (var i = 0; i < limit; ++i) {
var ctrl = this._controllers[0];
this._removeControllerByIndex(0);
ctrl.destructor();
}
} else {
var limit = Math.min(os, e) - s;
for (var i = 0; i < limit; ++i) {
var ctrl = new ImagePane(this._pairAddress["+"](new Address([this.data.at(i + s).toString()])));
this.addController(ctrl, i);
}
}
}
if (needEnd) {
var ce = Math.min(this.data.length(), e);
var coe = Math.min(this.data.length(), oe);
if (ce > coe) {
var start = Math.max(s, oe);
var amount = ce - start; //it can be negative, it's fine
for (var i = 0; i < amount; ++i) {
var ctrl = new ImagePane(this._pairAddress["+"](new Address([this.data.at(start + i).toString()])));
this.addController(ctrl);
}
} else if (ce < coe) {
var amount = Math.min(coe - ce, coe - os);
for (var i = 0; i < amount; ++i) {
var index = this._controllers.length - 1;
var ctrl = this._controllers[index];
this._removeControllerByIndex(index);
ctrl.destructor();
}
}
}
this.trigger("rangeEnd");
}
}
}
});
module.exports = PanesList;

22
libjs/wController/string.js Normal file
View file

@ -0,0 +1,22 @@
"use strict";
var Controller = require("./controller");
var String = Controller.inherit({
"className": "String",
"constructor": function(addr) {
Controller.fn.constructor.call(this, addr);
this.data = "";
this.addHandler("get");
},
"_h_get": function(ev) {
var data = ev.getData();
this.data = data.at("data").toString();
this.trigger("data");
}
});
module.exports = String;

31
libjs/wController/theme.js Normal file
View file

@ -0,0 +1,31 @@
"use strict";
var Controller = require("./controller");
var Theme = Controller.inherit({
"className": "Theme",
"constructor": function(addr) {
Controller.fn.constructor.call(this, addr);
this._data = {};
this._deferredReady = this._onReady.bind(this);
this.addHandler("get");
},
"_h_get": function(ev) {
var pairs = ev.getData();
this.trigger("clear");
var data = pairs.at("data");
var keys = data.getKeys();
for (var i = 0; i < keys.length; ++i) {
this._data[keys[i]] = data.at(keys[i]).valueOf()
}
setTimeout(this._deferredReady, 1);
},
"_onReady": function() {
this.trigger("ready", this._data);
}
});
module.exports = Theme;

56
libjs/wController/themeSelecter.js Normal file
View file

@ -0,0 +1,56 @@
"use strict";
var Controller = require("./controller");
var ThemeSelecter = Controller.inherit({
"className": "ThemeSelecter",
"constructor": function(addr) {
Controller.fn.constructor.call(this, addr);
this._data = {};
this._selected = undefined;
this.addHandler("get");
this.addHandler("insert");
},
"destructor": function() {
for (var i = 0; i < this._views.length; ++i) {
this._views[i].off("select", this.select, this);
}
Controller.fn.destructor.call(this);
},
"addView": function(view) {
Controller.fn.addView.call(this, view);
view.on("select", this.select, this);
},
"_h_get": function(ev) {
var pairs = ev.getData();
this.trigger("clear");
var data = pairs.at("data");
var keys = data.getKeys();
for (var i = 0; i < keys.length; ++i) {
this._data[keys[i]] = data.at(keys[i]).clone()
this.trigger("newElement", {key: keys[i], value: this._data[keys[i]] });
}
this.select(pairs.at("default").toString());
},
"_h_insert": function(ev) {
var data = ev.getData();
var key = data.at().toString();
var value = data.at().clone()
this._data[key] = value;
this.trigger("newElement", {key: key, value: value});
},
"select": function(key) {
if (!this._data[key]) {
throw new Error("No such key");
}
this._selected = key;
this.trigger("selected", {key: key, value: this._data[key]});
}
});
module.exports = ThemeSelecter;

69
libjs/wController/vocabulary.js Normal file
View file

@ -0,0 +1,69 @@
"use strict";
var Controller = require("./controller");
var WVocabulary = require("../wType/vocabulary");
var Vocabulary = Controller.inherit({
"className": "Vocabulary",
"constructor": function(addr) {
Controller.fn.constructor.call(this, addr);
this.data = new WVocabulary();
this.addHandler("get");
this.addHandler("change");
this.addHandler("clear");
},
"destructor": function() {
this.data.destructor();
Controller.fn.destructor.call(this);
},
"addElement": function(key, element) {
this.data.insert(key, element);
this.trigger("newElement", key, element);
},
"removeElement": function(key) {
this.data.erase(key);
this.trigger("removeElement", key);
},
"clear": function() {
this.data.clear();
this.trigger("clear");
},
"_h_change": function(ev) {
var key;
var data = ev.getData();
var erase = data.at("erase");
var insert = data.at("insert");
var eSize = erase.length();
for (var i = 0; i < eSize; ++i) {
key = erase.at(i).toString();;
this.removeElement(key);
}
var keys = insert.getKeys();
for (var j = 0; j < keys.length; ++j) {
key = keys[i];
this.addElement(key, insert.at(key).clone());
}
this.trigger("change", data.clone());
},
"_h_clear": function(ev) {
this.clear();
},
"_h_get": function(ev) {
this.clear();
var data = ev.getData().at("data");
var keys = data.getKeys();
for (var i = 0; i < keys.length; ++i) {
var key = keys[i];
this.addElement(key, data.at(key).clone());
}
this.trigger("data");
}
});
module.exports = Vocabulary;