define(function (require, exports, module) {
"use strict";
var derive = require("base/derive");
var LayoutPropTypes = require("boost/LayoutPropTypes");
var StyleSheet = require("boost/StyleSheet");
module.exports = derive(StyleSheet, LayoutPropTypes);
});
$.widget = function (name, proto) {
var dataKey = "__widget_" + name + "__";
proto = copyProperties({}, proto, {
widgetName: name
});
var constructor = derive($.Widget, proto);
$.fn[name] = function (options) {
var isMethodCall = typeof options === 'string';
var args = slice.call(arguments, 1);
var returnValue = this;
if (isMethodCall) {
this.each(function () {
var $this = $(this);
var instance = $this.data(dataKey);
var methodValue;
if (!instance) {
throw new Error('cannot call methods on ' + name + ' prior to initialization; ' +
'attempted to call method "' + options + '"');
}
if (!isFunction(instance[options]) || options.charAt(0) === '_') {
throw new Error('no such method "' + options + '" for ' + name + ' widget instance');
}
methodValue = instance[options].apply(instance, args);
if (methodValue !== instance && methodValue !== undefined) {
returnValue = methodValue;
return false;
}
});
} else {
this.each(function () {
var $this = $(this);
$this.data(dataKey, new constructor(options, this));
/*
var instance = $this.data(dataKey);
if (instance) {
// 已经初始化过
instance.option(options || {});
if (instance._init) {
instance._init();
}
} else {
$this.data(dataKey, new constructor(options, this));
}
*/
});
}
return returnValue;
};
};
define(function (require, exports, module) {
"use strict";
var derive = require("base/derive");
var assert = require("base/assert");
var EventTarget = require("boost/EventTarget");
var NativeObject = require("boost/NativeObject");
var NativeElement = require("boost/NativeElement");
var AnimationEvent = require("boost/AnimationEvent");
var nativeGlobal = NativeObject.global;
var Animation = derive(EventTarget, function (type, config) {
EventTarget.call(this);
this.__type__ = type;
this.__native__ = null;
//this.__config__ = config;
this.__create(this.__type__, config);
}, {
__create: function (type, config) {
var self = this;
var nativeObj = this.__native__ = new NativeObject();
var tag = nativeObj.tag;
nativeObj.__onEvent = function (type, e) {
self.__onEvent(type, e);
};
nativeGlobal.createAnimation(tag, type, config);
},
start: function (element) {
assert(element instanceof NativeElement, "Animation must apply on NativeElement");
nativeGlobal.startAnimation(element.nativeObject.tag, this.__native__.tag);
},
cancel: function () {
nativeGlobal.cancelAnimation(this.__native__.tag);
},
__onEvent: function (type, e) {
var event;
switch (type) {
case "animationstart":
case "animationend":
event = new AnimationEvent(this, type);
this.dispatchEvent(event);
break;
default:
console.log("unknow event:" + type, e);
}
}
});
module.exports = Animation;
});
define(function (require, exports, module) {
"use strict";
var derive = require("base/derive");
var assert = require("base/assert");
var Event = require("boost/Event");
var FocusEvent = derive(Event, function (target, type) {
assert(type === "focus" || type === "blur", "unknow focus event type:\"" + type + "\"")
Event.call(this, target, type);
});
module.exports = FocusEvent;
});
define(function (require, exports, module) {
"use strict";
var derive = require("base/derive");
var assert = require("base/assert");
var NativeElement = require("boost/NativeElement");
var LayoutStyle = require("boost/LayoutStyle");
//var NATIVE_VIEW_TYPE = "WrappedScrollView";
var NATIVE_VIEW_TYPE = 3;
var ScrollView = derive(NativeElement, function () {
//this._super(NATIVE_VIEW_TYPE, "ScrollView");
NativeElement.call(this, NATIVE_VIEW_TYPE, "ScrollView");
}, {
__getStyle: function () {
//assert(false, "ScrollView 不支持 style 属性");
return new LayoutStyle();
}
});
module.exports = ScrollView;
});
define(function (require, exports, module) {
"use strict";
var derive = require("base/derive");
var Event = require("boost/Event");
var TouchEvent = derive(Event, function (target, type, x, y) {
//this._super(target, type);
Event.call(this, target, type);
this.__x__ = x;
this.__y__ = y;
}, {
"get x": function () {
return this.__x__;
},
"get y": function () {
return this.__y__;
}
});
module.exports = TouchEvent;
});
define(function (require, exports, module) {
"use strict";
var derive = require("base/derive");
var each = require("base/each");
var hasOwnProperty = require("base/hasOwnProperty");
var assert = require("base/assert");
var Element = require("boost/Element");
var EventTarget = require("boost/EventTarget");
var NativeElement = require("boost/NativeElement");
var View = require("boost/View");
var Text = require("boost/Text");
var TextInput = require("boost/TextInput");
var Image = require("boost/Image");
var ScrollView = require("boost/ScrollView");
var Slider = require("boost/Slider");
var webMap = require("boost/webMap");
var webDebugger = require('./webDebugger');
var ROOT_ELEMENT_TAG = "tag_nativeview";
var TAG_MAP = {
"View": View,
"Text": Text,
"TextInput": TextInput,
"Image": Image,
"ScrollView": ScrollView,
"Slider": Slider,
};
var documentProto = {
constructor: function () {
//this._super();
EventTarget.call(this);
this.__tagMap__ = {};
this.__docuemntElement__ = null;
},
"get documentElement": function () {
if (this.__docuemntElement__ === null) {
this.__docuemntElement__ = NativeElement.__rootElement;
if (webDebugger.isActive()) {
webMap.set(this.__docuemntElement__, document.documentElement);
}
}
return this.__docuemntElement__;
},
createElement: function (tagName) {
tagName = tagName.toUpperCase();
assert(hasOwnProperty(this.__tagMap__, tagName), "unknow tag \"" + tagName + "\"");
var element = new this.__tagMap__[tagName]();
if (webDebugger.isActive() && !webDebugger.doNotUpdateWeb) {
var webElement = document.createElement(tagName);
webMap.set(element, webElement);
}
return element;
},
registerElement: function (tagName, options) {
var constructor;
if (options.constructor) {
constructor = options.constructor;
} else {
constructor = Element;
}
this.__tagMap__[tagName.toUpperCase()] = constructor;
}
};
function bridgeDocumentElement(obj, method) {
obj[method] = function () {
var documentElement = this.documentElement;
return documentElement[method].apply(documentElement, arguments);
};
}
bridgeDocumentElement(documentProto, "getElementById");
bridgeDocumentElement(documentProto, "getElementsByClassName");
bridgeDocumentElement(documentProto, "getElementsByTagName");
bridgeDocumentElement(documentProto, "querySelector");
bridgeDocumentElement(documentProto, "querySelectorAll");
var BoostDocument = derive(EventTarget, documentProto);
var boost = new BoostDocument();
each(TAG_MAP, function (constructor, tagName) {
boost.registerElement(tagName, {
constructor: constructor
});
});
module.exports = boost;
});
define(function (require, exports, module) {
"use strict";
var derive = require("base/derive");
var NativeElement = require("boost/NativeElement");
var TextStylePropTypes = require("boost/TextStylePropTypes");
var StyleSheet = require("boost/StyleSheet");
var validator = require("boost/validator");
var FocusEvent = require("boost/FocusEvent");
//var NATIVE_VIEW_TYPE = "WrappedEditText";
var NATIVE_VIEW_TYPE = 5;
var TextStyle = derive(StyleSheet, TextStylePropTypes);
var TextInput = derive(NativeElement, function () {
//this._super(NATIVE_VIEW_TYPE, "TextInput");
NativeElement.call(this, NATIVE_VIEW_TYPE, "TextInput");
}, {
__getStyle: function () {
return new TextStyle();
},
__onEvent: function (type, e) {
var event;
switch (type) {
case "focus":
case "blur":
event = new FocusEvent(this, type);
this.dispatchEvent(event);
break;
case "change":
this.__config__.value = e.text;
break;
default:
console.log("unknow event:" + type, e);
}
},
"get value": function () {
return this.__config__.value || "";
},
"set value": function (value) {
this.__update("value", value);
},
"get editable": function () {
return this.__config__.editable || true;
},
"set editable": function (value) {
this.__update("editable", validator.boolean(value));
},
"get multiline": function () {
return this.__config__.multiline || true;
},
"set multiline": function (value) {
this.__update("multiline", validator.boolean(value));
},
"get password": function () {
return this.__config__.password || false;
},
"set password": function (value) {
this.__update("password", validator.boolean(value));
},
"set keyboardType": function (value) {
this.__update("keyboardType", validator.string(value));
},
"set numberOfLines": function (value) {
this.__update("numberOfLines", validator.number(value));
},
"set placeholder": function (value) {
this.__update("placeholder", validator.string(value));
},
"set placeholderTextColor": function (value) {
this.__update("placeholderTextColor", validator.color(value));
}
});
module.exports = TextInput;
});
define(function (require, exports, module) {
"use strict";
var derive = require("base/derive");
var assert = require("base/assert");
var type = require("base/type");
var hasOwnProperty = require("base/hasOwnProperty");
var EventTarget = derive(Object, function () {
this.__listeners__ = {};
}, {
addEventListener: function (eventType, listener, useCapture) {
var listeners = this.__listeners__;
if (!hasOwnProperty(listeners, eventType)) {
listeners[eventType] = [];
}
assert(type(listeners[eventType]) === "array", "__listeners__ is not an array");
//TODO useCapture
listeners[eventType].push(listener);
return true;
},
removeEventListener: function (eventType, listener, useCapture) {
var listeners = this.__listeners__;
var index;
var found;
if (!hasOwnProperty(listeners, eventType)) {
return false;
}
found = false;
//TODO useCapture
while ((index = listeners[eventType].indexOf(listener)) > -1) {
listeners[eventType].splice(index, 1);
found = true;
}
return found;
},
removeAllEventListeners: function () {
this.__listeners__ = {};
},
dispatchEvent: function (event) {
var type = event.type;
var listeners = this.__listeners__;
if (hasOwnProperty(listeners, type)) {
return listeners[type].forEach(function (listener) {
listener.call(this, event);
}, this);
}
return !event.defaultPrevented;
}
});
module.exports = EventTarget;
});