function mousemoveHandler(event){
var dx = Math.abs(event.mouseX - lastMouseX);
var dy = Math.abs(event.mouseY - lastMouseY);
var cursor = event.sender;
if (inspectDepth && lastMouseX && dx < DEPTH_MODE_MOVE_THRESHOLD && dy < DEPTH_MODE_MOVE_THRESHOLD) {
return;
}
lastMouseX = event.mouseX;
lastMouseY = event.mouseY;
while (cursor) {
if (api.isComponentRootNode(cursor)) {
pickupTarget.set({
node: cursor,
instance: api.getInstanceByNode(cursor)
});
return;
}
cursor = cursor.parentNode;
}
pickupTarget.set();
}
function mousemoveHandler(event) {
var dx = Math.abs(event.mouseX - lastMouseX);
var dy = Math.abs(event.mouseY - lastMouseY);
var cursor = event.sender;
if (inspectDepth && lastMouseX && dx < DEPTH_MODE_MOVE_THRESHOLD && dy < DEPTH_MODE_MOVE_THRESHOLD) {
return;
}
if (cursor === prevMouseMoveElement || cursor === document) {
return;
}
prevMouseMoveElement = cursor;
lastMouseX = event.mouseX;
lastMouseY = event.mouseY;
while (cursor) {
if (api.isComponentRootNode(cursor)) {
pickupTargetNode.set(cursor);
return;
}
cursor = cursor.parentNode;
}
pickupTargetNode.set();
}
init: function(){
if (this.property)
this.value = this.property.value;
// inherit
ComplexField.prototype.init.call(this);
this.setSatellite('captionItem', new this.childClass({
delegate: Value.from(this.selection, 'itemsChanged', function(selection){
return selection.pick();
}),
getTitle: function(){
if (this.delegate)
return this.delegate.getTitle();
},
getValue: function(){
if (this.delegate)
return this.delegate.getValue();
},
handler: {
delegateChanged: function(){
this.updateBind('title');
}
}
}));
// create items popup
this.popup = new this.popupClass(this.popup);
this.setSatellite('popup', this.popup);
this.opened = Value.from(this.popup, 'show hide', 'visible');
if (this.property)
this.property.link(this, this.setValue);
},
inspectors.add(inspector.inspectMode.link(new DataObject, function(value){
if (value)
currentInspector.set(inspector);
else
if (currentInspector.value === inspector)
currentInspector.set();
this.update({ mode: value });
}));
inspector.inspectMode.link(null, function(value){
if (value) {
currentInspector.set(inspector);
} else {
if (currentInspector.value === inspector) {
currentInspector.set();
}
}
});
function stopInspect(){
if (inspectMode.value) {
domEventUtils.removeGlobalHandler('mousemove', mousemoveHandler);
domEventUtils.removeGlobalHandler('mousewheel', mouseWheelHandler);
domEventUtils.removeGlobalHandler('wheel', mouseWheelHandler);
domEventUtils.removeGlobalHandler('DOMMouseScroll', mouseWheelHandler);
domEventUtils.removeGlobalHandler('mousedown', domEventUtils.kill);
domEventUtils.removeGlobalHandler('mouseup', domEventUtils.kill);
domEventUtils.removeGlobalHandler('contextmenu', contextmenuHandler);
domEventUtils.removeGlobalHandler('click', pickHandler);
inspectMode.set(false);
pickupTarget.set();
}
}
function mouseWheelHandler(event){
var delta = event.wheelDelta;
var sender = event.sender;
var cursor = sender;
var tempDepth = inspectDepth + delta;
var curDepth = 0;
var lastNode;
var lastDepth;
do {
if (api.isComponentRootNode(cursor)) {
lastDepth = curDepth;
lastNode = cursor;
if (tempDepth < 0 || curDepth == tempDepth)
break;
curDepth++;
}
} while (cursor = cursor.parentNode);
inspectDepth = lastDepth;
pickupTarget.set({
node: lastNode,
instance: api.getInstanceByNode(lastNode)
});
event.die();
}
activate: function(){
if (!this.active)
{
activeOverlay.set(this);
this.apply();
}
},
deactivate: function(){
if (this.active)
{
clearInterval(checkTimer);
activeOverlay.set();
this.clear();
}
},
basis.setImmediate(function(){
if (inspectBasis.resource(filename).hasChanges())
basis.array.add(permamentFiles, filename);
else
basis.array.remove(permamentFiles, filename);
permamentFilesCount.set(permamentFiles.length);
});
enter: function(e){
if (this.data.used)
hoveredBinding.set(this.data.name);
if (this.data.loc)
{
templateApi.setSourceFragment(this.data.loc);
jsSourcePopup().show(e.actionTarget);
}
},
sourceLoc.as(function(loc) {
if (loc && getSourceFragment.available) {
getSourceFragment(loc, function(result) {
if (loc === sourceLoc.value) {
source.set(result);
popup.realign();
}
});
}
source.set('');
});
function startInspect() {
if (!inspectMode.value) {
selectedNode.set();
domEventUtils.addGlobalHandler('mousemove', mousemoveHandler);
domEventUtils.addGlobalHandler('mousewheel', mouseWheelHandler);
domEventUtils.addGlobalHandler('wheel', mouseWheelHandler);
domEventUtils.addGlobalHandler('DOMMouseScroll', mouseWheelHandler);
domEventUtils.addGlobalHandler('mousedown', domEventUtils.kill);
domEventUtils.addGlobalHandler('mouseup', domEventUtils.kill);
domEventUtils.addGlobalHandler('contextmenu', contextmenuHandler);
domEventUtils.addGlobalHandler('click', pickHandler);
inspectMode.set(true);
}
}
addIndex: function(key, IndexClass){
if (!IndexClass || IndexClass.prototype instanceof Index === false)
{
/** @cut */ basis.dev.warn('basis.data.IndexMap#addIndex(): `IndexClass` should be subclass of `basis.data.index.Index`');
return;
}
if (this.indexes[key])
{
/** @cut */ basis.dev.warn('basis.data.IndexMap#addIndex(): Index `' + key + '` already exists');
return;
}
var index = new IndexWrapper(Value.from(this, 'sourceChanged', 'source'), IndexClass);
this.indexes[key] = index;
this.indexValues[key] = index.value;
index.link(this, function(value){
this.indexValues[key] = value;
this.indexUpdated = true;
this.scheduleRecalc();
});
},
var Value = require('basis.data').Value;
var Node = require('basis.ui').Node;
var satellite = new Node({
selected: Value.query('owner.data.foo').as(function(foo){
return foo > 0;
})
});
var owner = new Node({
satellite: {
foo: satellite
},
data: {
foo: 123
}
});
module.exports = satellite.selectedRA_.source;
var Value = require('basis.data').Value;
var Popup = require('basis.ui.popup').Popup;
var getSourceFragment = require('../remote.js').getRemoteMethod('getSourceFragment');
var sourceLoc = new Value();
var source = new Value({ value: '' });
sourceLoc.as(function(loc) {
if (loc && getSourceFragment.available) {
getSourceFragment(loc, function(result) {
if (loc === sourceLoc.value) {
source.set(result);
popup.realign();
}
});
}
source.set('');
});
var popup = new Popup({
loc: sourceLoc,
dir: 'top left bottom left',
autorotate: [
'bottom left top left'
],
template: resource('./template/popup.tmpl'),
binding: {
isOpenFileSupported: basis.fn.$const(true), // FIXME: use real value
loc: sourceLoc.as(function(loc) {
return (loc || '').replace(/(:\d+){1,4}$/, '');
{
mutedEvents[eventName] = Boolean(toMute[eventName]);
if (toMute[eventName])
inspectBasisEvent.captureEvent(eventName, eventUtils.kill);
else
inspectBasisEvent.releaseEvent(eventName);
}
}
//
// Current overlay if any
//
var refreshTimer;
var activeOverlay = new Value();
activeOverlay.link(null, function(newOverlay, oldOverlay){
if (oldOverlay)
{
domUtils.remove(oldOverlay.element);
oldOverlay.deactivate();
}
else
{
startWatch();
refreshTimer = setInterval(update, REFRESH_TIMER);
}
if (newOverlay)
{
muteEvents(newOverlay.muteEvents || {});
getSourceFragment(loc, function(result) {
if (loc === sourceLoc.value) {
source.set(result);
popup.realign();
}
});
return res;
},
{}
),
satellite: {
example: {
events: 'exampleChanged',
existsIf: function(owner){
return owner.example;
},
satelliteClass: UINode.subclass({
className: namespace + '.Example',
template: templates.Example,
binding: {
example: Value
.factory('ownerChanged', 'owner')
.pipe('exampleChanged', 'example')
}
})
},
description: {
events: 'descriptionChanged',
existsIf: function(owner){
return owner.description;
},
satelliteClass: UINode.subclass({
className: namespace + '.Description',
template: templates.Description,
binding: {
example: Value
.factory('ownerChanged', 'owner')
var inspectBasis = require('devpanel').inspectBasis;
var Value = require('basis.data').Value;
var createTreeBuilder = require('./build-tree.js');
var input = new Value();
var selectedObject = new basis.Token();
var tree = selectedObject
.as(createTreeBuilder({
sandbox: inspectBasis
}))
// pass through stringify/parse to avoid notification about the same structure
.as(JSON.stringify)
.as(JSON.parse);
// rebuild graph by timer
input.link(selectedObject, selectedObject.set);
setInterval(function(){
if (selectedObject.value)
selectedObject.apply();
}, 100);
module.exports = {
input: input,
output: Value.from(tree)
};
selectedPath.as(function(value){
var list = inspectBasisTracker.getInfo(value);
return list ? wrapData(list) : null;
}).attach(trackingList.setChildNodes, trackingList);
//
// Roles tree
//
var rolesTree = new Node({
template: resource('./template/roles-tree.tmpl'),
childClass: {
childClass: basis.Class.SELF,
template: resource('./template/roles-tree-leaf.tmpl'),
selected: Value.from(selectedPath)
.as(function(value){
return inspectBasisTracker.stringifyPath(value);
}).compute(function(node, path){
return node.fullpath === path;
}),
binding: {
matched: 'matched',
role: function(node){
return inspectBasisTracker.stringifyRole(node.data);
}
},
action: {
select: function(){
selectedDomNode.set(this.node);
}
runnerState: new Expression(
runner.state,
runner.count.total,
runner.count.fault,
runner.count.left,
function(state, total, fault, left){
if (fault)
return 'fault';
if (state != 'running' && total && !left)
return 'ok';
return state;
}
),
// values
name: Value.from(toc, 'update', 'data.name'),
time: runner.time.as(function(val){
return (val / 1000).toFixed(1);
}),
total: runner.count.total,
assert: runner.count.assert,
left: runner.count.left,
done: runner.count.done
}
});
// table of content setup
toc.setDelegate(view);
toc.addHandler({
delegateChanged: function(){
var cursor = this;
module.exports = Value.subclass({
className: 'basis.data.index.IndexWrapper',
extendConstructor_: false,
source: null,
sourceRA_: null,
dataset: null,
indexConstructor: null,
index: null,
init: function(source, indexConstructor){
this.source = source;
this.indexConstructor = indexConstructor;
this.value = indexConstructor.prototype.value;
Value.prototype.init.call(this);
source.bindingBridge.attach(source, basis.fn.$undef, this, this.destroy);
this.setDataset(source);
},
setDataset: function(source){
var oldDataset = this.dataset;
var newDataset = resolveDataset(this, this.setDataset, source, 'sourceRA_');
if (newDataset !== oldDataset)
{
var index = this.index;
if (index)
{
index.removeHandler(INDEXWRAPPER_HANDLER, this);
index.wrapperCount -= 1;
if (!index.wrapperCount && !index.explicit)
index.destroy();
else
index.unlink(this, Value.prototype.set);
}
if (newDataset)
{
index = Index.getDatasetIndex(newDataset, this.indexConstructor);
index.wrapperCount += 1;
index.link(this, Value.prototype.set);
index.addHandler(INDEXWRAPPER_HANDLER, this);
}
else
{
index = null;
Value.prototype.set.call(this, this.initValue);
}
/** @cut */ basis.dev.patchInfo(this, 'sourceInfo', {
/** @cut */ type: 'IndexWrapper',
/** @cut */ source: index,
/** @cut */ sourceTarget: source
/** @cut */ });
this.dataset = newDataset;
this.index = index;
}
},
set: function(){
/** @cut */ basis.dev.warn(this.className + ': value can\'t be set as IndexWrapper is read only');
},
destroy: function(){
this.source.bindingBridge.detach(this.source, basis.fn.$undef, this);
this.setDataset();
Value.prototype.destroy.call(this);
this.source = null;
this.indexConstructor = null;
}
});
var inspectBasis = require('devpanel').inspectBasis;
var inspectBasisL10n = inspectBasis.require('basis.l10n');
var Value = require('basis.data').Value;
var Menu = require('./Menu.js');
module.exports = new Menu({
childClass: {
binding: {
title: 'value',
selected: Value
.from(inspectBasisL10n.culture)
.compute(function(node, value){
return node.value == value;
})
},
action: {
select: function(){
inspectBasisL10n.setCulture(this.value);
}
}
},
childNodes: inspectBasisL10n.getCultureList().map(function(culture){
return {
value: culture
};
})
});
var wrap = require('basis.data').wrap;
var Node = require('basis.ui').Node;
var templateApi = require('../api.js');
var fileApi = require('api').ns('file');
var jsSourcePopup = resource('./js-source-popup.js');
var dataFlowPopup = resource('./data-flow-popup.js');
var Value = require('basis.data').Value;
var hoveredBinding = new Value();
var View = Node.subclass({
hover: hoveredBinding,
autoDelegate: true,
handler: {
update: function(sender, delta){
if ('bindings' in delta)
this.setChildNodes(wrap(this.data.bindings));
}
},
sorting: 'data.name',
grouping: {
rule: 'data.used',
childClass: {
template: resource('./bindings/group.tmpl'),
binding: {
name: function(node){
return node.data.id ? 'used' : 'notUsed';
}
}
leave: function(){
hoveredBinding.set();
jsSourcePopup().hide();
},
delta.inserted.forEach(function(file){
output.set(file.data);
listenFileChanges(file);
});
var Value = require('basis.data').Value;
var DataObject = require('basis.data').Object;
var Dataset = require('basis.data').Dataset;
var wrap = require('basis.data').wrap;
var sum = require('basis.data.index').sum;
var object = new DataObject({
data: {
foo: new Dataset({
items: wrap([1, 2, 3, 4], true)
})
}
});
var indexFactory = sum(Value.query('data.foo'), 'update', 'data.value');
module.exports = indexFactory(object);
var STATE = require('basis.data').STATE;
var Value = require('basis.data').Value;
var Node = require('basis.ui').Node;
var appProfile = require('type').AppProfile();
module.exports = new Node({
active: true,
delegate: appProfile,
disabled: Value.query('state').as(function(state){
return state == STATE.PROCESSING;
}),
template: resource('./template/app-profile-button.tmpl'),
binding: {
processing: {
events: 'stateChanged',
getter: function(node){
return node.state == STATE.PROCESSING;
}
},
error: {
events: 'stateChanged',
getter: function(node){
if (node.state == STATE.ERROR)
return node.state.data;
}
}
},
action: {
update: function(){
this.deprecate();
}
update: function(){
output.set(this.data);
}