API Docs for:
Show:

File: mono.sdoc-zh.js

/**
 * @module mono
 */
mono = {}

/**
 * 数据对象
 * @class mono.Data
 * @constructor
 *
 */
mono.Data = function() {}

mono.Data.prototype = new mono.PropertyChangeDispatcher

/**
 * 获取数据对象的名称
 * @method getName
 * @return {String} 名称
 */
mono.Data.prototype.getName = function() {}

/**
 * 获取数据对象的检索ID值
 * @method getId
 * @return {String} ID
 */
mono.Data.prototype.getId = function() {}

/**
 * 设置组的检索ID值
 * @method setGroupId
 * @param {String} groupId 组的ID值
 */
mono.Data.prototype.setGroupId = function(groupId) {}

/**
 * 获取组的检索ID值
 * @method getGroupId
 * @return {String} 组的检索ID值
 */
mono.Data.prototype.getGroupId = function() {}

/**
 * 判断数据对象是否有孩子对象,有则返回true,没有则返回false
 * @method hasChildren  
 * @return {boolean} 数据对象是否有孩子成员,有则为true,反之为false
 */
mono.Data.prototype.hasChildren = function() {}

/**
 * 获取当前数据对象的孩子对象集合
 * @method getChildren
 * @return {List} 数据对象的孩子对象集合
 */
mono.Data.prototype.getChildren = function() {}

/**
 * 判断数据对象是否是element的子成员,是则返回true,不是则返回false
 * @method isDescendantOf 
 * @param {Object} element
 * @return {boolean} 数据对象是element的子成员则为true,反之为false
 */
mono.Data.prototype.isDescendantOf = function(element) {}

/**
 * 获取当前数据对象的父亲对象
 * @method getParent
 * @return {Object} 父亲对象
 */
mono.Data.prototype.getParent = function() {}

/**
 * 设置当前数据对象的父亲对象
 * @method setParent 
 * @param {Object} parent 要设置的父亲对象
 */
mono.Data.prototype.setParent = function(parent) {}

/**
 * 为当前数据对象增加子对象
 * @method addChild
 * @param {Object} child 子对象
 * @param {int} index 子对象的位置
 * @return {boolean} 子对象增加成功则为true,反之为false
 */
mono.Data.prototype.addChild = function(child, index) {}

/**
 * 删除当前数据对象的子对象
 * @method removeChild
 * @param {Object} child 要删除的子对象
 * @return {boolean} 子对象删除成功则为true,反之则为false
 */
mono.Data.prototype.removeChild = function(child) {}

/**
 * 设置自定义的属性
 * @method setClient
 * @param {String} clientProp 自定义的属性名
 * @param value 自定义属性的内容
 */
mono.Data.prototype.setClient = function(clientProp, value) {}

/**
 * 获取自定义的属性
 * @method getClient
 * @param {String} clientProp 自定义的属性名
 * @return {Object} 自定义属性的内容
 */
mono.Data.prototype.getClient = function(clientProp) {}

/**
 * 网元类
 * @class mono.Element
 * @constructor
 */
mono.Element = function() {}

mono.Element.prototype = new mono.Data

/**
 * 判断网元是否可见状态
 * @method isVisible
 * @return {boolean} 
 */
mono.Element.prototype.isVisible = function() {}

/**
 * 判断网元是否被选中
 * @method isSelectable
 * @return {boolean} 
 */
mono.Element.prototype.isSelected = function() {}

/**
 * 判断网元是否可以被选择的状态
 * @method isSelectable
 * @return {boolean} 
 */
mono.Element.prototype.isSelectable = function() {}

/**
 * 判断网元是否可以编辑的状态
 * @method isEditable
 * @return {boolean} 
 */
mono.Element.prototype.isEditable = function() {}

/**
 * 判断网元是否为固定尺度
 * @method isSizeFixed
 * @return {boolean} 
 */
mono.Element.prototype.isSizeFixed = function() {}

/**
 * 获取网元的告警状态对象,告警状态对象是用于存放网元上的所有告警信息
 * @method getAlarmState
 * @return {mono.AlarmBox} 告警容器
 */
mono.Element.prototype.getAlarmState = function() {}

/**
 * 获取默认的实例对象
 * @method getDedaultInstance
 * @return {Obejct} 实例对象
 */
mono.Element.prototype.getDefaultInstance = function() {}

/**
 * 判断网元的某个样式与之前的样式是否相等
 * @method isStyleEquals
 * @param {String} style 网元的样式
 * @param {String} oldValue 样式的原值
 * @param {String} value 样式的当前值
 * @return {boolean} 相等则为true,反之为false
 */
mono.Element.prototype.isStyleEquals = function(style, oldValue, value) {}

/**
 * 设置网元的样式
 * @method setStyle
 * @param {String} styleProp 网元的样式名
 * @param {String} value 网元样式名对应的样式值
 */
mono.Element.prototype.setStyle = function(styleProp, value) {}

/**
 *  获取网元的样式
 * @method getStyle
 * @param {String} styleProp 网元的样式名
 * @param clone 克隆
 * @param returnDefaultIfNull 如果为空则返回默认样式
 * @return {String} 样式
 */
mono.Element.prototype.getStyle = function(styleProp, clone, returnDefaultIfNull) {}

/**
 * 获取指定对象的克隆对象
 * @method getCloneObject
 * @param {Object} object 欲克隆的对象
 * @return {Object} object克隆的对象
 */
mono.Element.prototype.getCloneObject = function(object) {}

/**
 * 根据标号获取网元的面 
 * 对网元对象的面做出标号,对于像cube之类的面做了标号,比如right:0,left:1
 * @method getSideIndexMapping
 */
mono.Element.prototype.getSideIndexMapping = function() {}


/**
 * 获取网元的默认样式
 * @method getDefaultStyle
 * @param {String} styleProp 欲获取的样式名
 * @param {Object} clone 克隆对象
 * @return {String} 样式名对应的样式
 */
mono.Element.prototype.getDefaultStyle = function(styleProp, clone) {}

/**
 * 判断是否是面样式
 * @method isSideStyle
 * @param {String} styleProp 样式名称
 * @return {boolean} 是则为true,反之为false
 */
mono.Element.prototype.isSideStyle = function(styleProp) {}

/**
 * 设置up方向,默认情况下为{0,1,0}
 * @method setUp
 * @param {int} x x轴坐标
 * @param {int} y y轴坐标
 * @param {int} z z轴坐标
 */
mono.Element.prototype.setUp = function(x, y, z) {}

/**
 * 获取up方向
 * @method getUp
 * @return {mono.Vec3} up方向
 */
mono.Element.prototype.getUp = function() {}

/**
 * 设置网元的位置
 * @method setPosition
 * @param {int} x x轴坐标
 * @param {int} y y轴坐标
 * @param {int} z z轴坐标
 */
mono.Element.prototype.setPosition = function(x, y, z) {}

/**
 * 获取网元的位置坐标信息
 * @method getPosition 
 * @return {mono.Vec3} 网元的位置信息
 */
mono.Element.prototype.getPosition = function() {}

/**
 * 设置网元的x轴坐标
 * @method setPositionX
 * @param {int} x x轴坐标
 */
mono.Element.prototype.setPositionX = function(x) {}

/**
 * 设置网元的x轴坐标
 * @method getPositionX
 * @return {int} x轴坐标
 */
mono.Element.prototype.getPositionX = function() {}

/**
 * 设置网元的y轴坐标
 * @method setPositionY
 * @param {int} y y轴坐标
 */
mono.Element.prototype.setPositionY = function(y) {}

/**
 * 获取网元的y轴坐标
 * @method getPositionY
 * @return {int} y y轴坐标
 */
mono.Element.prototype.getPositionY = function() {}

/**
 * 设置网元的z轴坐标
 * @method setPositionZ
 * @param {int} z z轴坐标
 */
mono.Element.prototype.setPositionZ = function(z) {}

/**
 * 获取网元的z轴坐标
 * @method getPostionZ
 * @return {int} z轴坐标
 */
mono.Element.prototype.getPositionZ = function() {}

/**
 * 设置网元分别在x轴,y轴,z轴上的缩放比例,默认为(1,1,1)
 * scale用于描述原型对象相对于本地坐标系,在x、y、z轴向上的缩放比例,1表示100%无缩放,2表示缩放为200%,
 * @method setScale
 * @param {float} x x轴缩放比例
 * @param {float} y y轴缩放比例
 * @param {float} z z轴缩放比例
 */
mono.Element.prototype.setScale = function(x, y, z) {}

/**
 * 获取网元的缩放比例
 * @method getScale
 * @return {mono.Vec3} 网元的缩放比例
 */
mono.Element.prototype.getScale = function() {}

/**
 * 设置网元在x轴方向上的缩放比例
 * @method setScaleX
 * @param {float} x x轴缩放比例
 */
mono.Element.prototype.setScaleX = function(x) {}

/**
 * 获取网元在x轴方向上的缩放比例
 * @method getScaleX
 * @return {float} x轴缩放比例
 */
mono.Element.prototype.getScaleX = function() {}

/**
 * 设置网元在y轴方向上的缩放比例
 * @method setScaleY
 * @param {float} y y轴缩放比例
 */
mono.Element.prototype.setScaleY = function(y) {}

/**
 * 获取网元在y轴方向上的缩放比例
 * @method getScaleY
 * @return {float} y轴缩放比例
 */
mono.Element.prototype.getScaleY = function() {}

/**
 * 设置网元在x轴方向上的缩放比例
 * @method setScaleZ
 * @param {float} z z轴缩放比例
 */
mono.Element.prototype.setScaleZ = function(z) {}

/**
 * 获取网元在z轴方向上的缩放比例
 * @method getScaleZ
 * @return {float} z轴缩放比例
 */
mono.Element.prototype.getScaleZ = function() {}

/**
 * 设置网元在x,y,z轴方向上的旋转角度
 * @method setRotation
 * @param {float}x x轴弧度
 * @param {float}y y轴弧度
 * @param {float}z z轴弧度
 */
mono.Element.prototype.setRotation = function(x, y, z) {}

/**
 * 获取网元的旋转角度
 * @method getRotation
 * @return {mono.Vec3} 旋转角度
 */
mono.Element.prototype.getRotation = function() {}

/**
 * 设置网元在x轴方向上的旋转角度
 * @method setRotationX
 * @param {float} x x轴方向旋转弧度
 */
mono.Element.prototype.setRotationX = function(x) {}

/**
 * 获取网元在x轴方向的旋转角度
 * @method getRotationX
 * @return {float} x轴方向的旋转弧度
 */
mono.Element.prototype.getRotationX = function() {}

/**
 * 设置网元在y轴方向的旋转角度
 * @method setRotationY
 * @param {float} y y轴方向的旋转弧度
 */
mono.Element.prototype.setRotationY = function(y) {}

/**
 * 获取网元在y轴方向的旋转角度
 * @method getRotationY
 * @return {float} y轴方向的旋转弧度
 */
mono.Element.prototype.getRotationY = function() {}

/**
 * 设置网元在z轴方向的旋转角度
 * @method setRotationZ
 * @param {float} z z轴方向的旋转弧度
 */
mono.Element.prototype.setRotationZ = function(z) {}

/**
 * 获取网元在z轴方向的旋转角度
 * @method getRotationZ
 * @return {float} z轴方向的旋转弧度
 */
mono.Element.prototype.getRotationZ = function() {}

/**
 * 通过矩阵来实现变换
 * @method applyMatrix
 * @param {mono.Mat4} matrix 矩阵
 */
mono.Element.prototype.applyMatrix = function(matrix) {}

/**
 * 将网元沿着轴线axis方向移动
 * @method translate 
 * @param {int} distance 移动的距离
 * @param {String} axis 移动的轴线
 */
mono.Element.prototype.translate = function(distance, axis) {}

/**
 * 沿着x轴方向移动distance距离
 * @method translateX
 * @param {int} distance 移动的距离
 */
mono.Element.prototype.translateX = function(distance) {}

/**
 * 沿着y轴方向移动distance距离
 * @method translateY
 * @param {int} distance 移动的距离
 */
mono.Element.prototype.translateY = function(distance) {}

/**
 * 沿着z轴方向移动distance距离
 * @method translateZ 
 * @param {int} distance 移动的距离
 */
mono.Element.prototype.translateZ = function(distance) {}

/**
 * 沿着轴线旋转angle角度
 * @method  rotateFromAxis
 * @param {String} axisDir 轴线名称
 * @param {int} axisPosition 轴线位置
 * @param {float} angle 旋转的角度
 */
mono.Element.prototype.rotateFromAxis = function(axisDir, axisPosition, angle) {}

/**
 * 获取当前网元相对于other对象的相对变换
 * @method getRalativeTransform
 * @param {TGL.Element} other
 */
mono.Element.prototype.getRelativeTransform = function(other) {}

/**
 * 本地坐标系到世界坐标系变换
 * @method localToWorld
 * @param {mono.Vec3} vector
 */
mono.Element.prototype.localToWorld = function(vector) {}

/**
 *  获取网元的前方方向
 * @method frontDirection 
 * @return {mono.Vec3} 前方方向向量
 */
mono.Element.prototype.frontDirection = function(){}

/**
 * 世界坐标系到本地坐标系变换
 * @method worldToLocal
 * @param {mono.Vec3} vector
 */
mono.Element.prototype.worldToLocal = function(vector) {}

/**
 * lookAt矩阵
 * @method lookAt
 * @param {mono.Vec3} vector Camera的位置
 * @param {mono,Vec3} up Camera的up方向
 */
mono.Element.prototype.lookAt = function(vector, up) {}

/**
 * 迭代器
 * @method iterator
 * @param {function} callback 回调函数
 */
mono.Element.prototype.iterator = function(callback) {}

/**
 * 根据名称获取孩子对象
 * @method getChildByName
 * @param {String} name 欲获取孩子对象的名称
 * @param {boolean} recursive 是否递归查询孩子对象
 */
mono.Element.prototype.getChildByName = function(name, recursive) {}

/**
 * 获取网元的子节点
 * @method getDescendants
 * @param array 子节点存放的数组
 * @return array
 */
mono.Element.prototype.getDescendants = function(array) {}

/**
 * 克隆网元
 * @method clone
 * @param object 欲克隆的对象
 * @param withGeometry 形状
 * @return {Object} 克隆出来的对象
 */
mono.Element.prototype.clone = function(object, withGeometry) {}

/**
 * 基本3D物体的父类,其继承于mono.Element类
 * @class mono.Node
 * @constructor
 */
mono.Node = function() {}

mono.Node.prototype = new mono.Element

/**
 * 获取节点的顶点
 * @method getVertices
 * @return {mono.Vec3} 顶点的坐标
 */
mono.Node.prototype.getVertices = new function(){}

/**
 * 获取节点的表面
 * @method getFaces
 * @return 表面
 */
mono.Node.prototype.getFaces = new function(){}

/**
 * 获取孩子的顶点信息
 * @method getVerticesWithChildren
 * @param {mono.Mat4} matrix 4*4矩阵
 * @param {mono.Vec3} vertices 孩子的顶点信息
 * @return {mono.Vec3} 孩子的顶点信息
 */
mono.Node.prototype.getVerticesWithChildren = function(matrix, vertices) {}

/**
 * 获取孩子的边界框
 * @method getBoundingBoxWithChildren
 * @param siblings
 * @return {mono.BoundingBox} 边界框对象
 */
mono.Node.prototype.getBoundingBoxWithChildren = function(siblings) {}

/**
 * 获取边界框
 * @method getBoundingBox
 * @return  {mono.BoundingBox} 边界框
 */
mono.Node.prototype.getBoundingBox = function() {}

/**
 * 开始批处理
 * @method startBatch
 */
mono.Node.prototype.startBatch = function() {}

/**
 * 结束批处理
 * @method endBatch
 */
mono.Node.prototype.endBatch = function() {}

/**
 * 根据节点的面获取该面所对应的标号
 * @method getIndexSideMapping
 * @return {int} 标号 
 */
mono.Node.prototype.getIndexSideMapping = function() {}

/**
 * 根据标号获取节点所对应的面
 * @method getSideIndexMapping
 * @return 面
 */
mono.Node.prototype.getSideIndexMapping = function() {}

/**
 * 实体类,继承于mono.Node类
 * @class mono.Entity
 * @constructor
 * @param {mono.ArrayMaterial} materialSize 材料的尺寸
 */
mono.Entity = function(materialSize) {}

mono.Entity.prototype = new mono.Node

/**
 * 设置更新标志
 * @method setUpdateFlags
 * @param {boolean} flag 标志
 */
mono.Entity.prototype.setUpdateFlags = function(flag) {}

/**
 * 设置材料尺寸
 * @method setMaterialSize
 * @param {mono.ArrayMaterial} materialSize
 */
mono.Entity.prototype.setMaterialSize = function(materialSize){}

/**
 * 立方体
 * @class mono.Cube
 * @constructor
 */
mono.Cube = function() {}

mono.Cube.prototype = new  mono.Entity

/**
 * 获取立方体的宽度
 * @method getWidth
 * @return {int} 宽度
 */
mono.Cube.prototype.getWidth = new function() {}

/**
 * 获取立方体的高度
 * @method getHeight
 * @return {int} 高度
 */
mono.Cube.prototype.getHeight = new function() {}

/**
 * 获取立方体的深度
 * @method getDepth 
 * @return {int} 深度
 */
mono.Cube.prototype.getDepth = new function() {}

/**
 * 根据标号获取立方体的面
 * @method getSideIndexMapping
 * return {int} 标号
 */
mono.Cube.prototype.getSideIndexMapping = function() {}

/**
 * 球体
 * @class mono.Sphere
 * @constructor
 */
mono.Sphere = function() {}

mono.Sphere.prototype = new mono.Entity

/**
 *  获取球体的半径
 * @method getRadius
 * @return {float} 半径
 */
mono.Sphere.prototype.getRadius = new function() {}

/**
 * 获取球体的横向切片数量,默认值22
 * @method getSegmentsW 
 * @return {int} 横向切片的数量
 */
mono.Sphere.prototype.getSegmentsW =  new function() {}

/**
 * 获取球体的纵向切片数量,默认值15
 * @method getSegmentsH
 * @return {int} 纵向切片的数量
 */
mono.Sphere.prototype.getSegmentsH = new function() {}

/**
 * 设置球体的横向切片数量,默认值22
 * @method setWidthSegments
 * @param {int} segmentsW 切片数量
 */
mono.Sphere.prototype.setWidthSegments = function(segmentsW){}

/**
 * 设置球体的纵向切片数量,默认值22
 * @method setHeightSegments 
 * @param {int} segmentsH 切片数量
 */
mono.Sphere.prototype.setHeightSegments = function(segmentsH){}

/**
 * 平面
 * @class mono.Plane
 * @constructor
 */
mono.Plane = function() {}

mono.Plane.prototype = new mono.Entity

/**
 * 克隆
 * @method clone
 * @return {TGL.Plane} 克隆的对象
 */
mono.Plane.prototype.clone = function() {}

/**
 * 圆柱体
 * @class mono.Cylinder
 * @constructor
 */
mono.Cylinder = function() {}

mono.Cylinder.prototype = new mono.Entity

/**
 * 获取圆柱顶端的半径
 * @method getRadiusTop 
 * @return {float} 半径
 */
mono.Cylinder.prototype.getRadiusTop = new function() {}

/**
 * 获取圆柱底端的半径
 * @method getRadiusBottom 
 * @return {float} 半径
 */
mono.Cylinder.prototype.getRadiusBottom = new function() {}

/**
 * 获取圆柱的高度
 * @method getHeight
 * @return {int} 高度
 */
mono.Cylinder.prototype.getHeight = new function() {}

/**
 * 获取圆柱体的环绕切片数量
 * @method getSegmentsR
 * @return {int} 切片数量
 */
mono.Cylinder.prototype.getSegmentsR = new function() {}

/**
 * 获取圆柱体的纵向切片数量
 * @method getSegmentsH
 * @return 切片数量
 */
mono.Cylinder.prototype.getSegmentsH = new function() {}

/**
 * 获取圆柱体上面是否开口状态
 * @method getOpenTop
 * @return {boolean} 开口状态
 */
mono.Cylinder.prototype.getOpenTop = new function() {}

/**
 * 获取圆柱体下面是否开口状态
 * @method getOpenBottom
 * @return {boolean} 开口状态
 */
mono.Cylinder.prototype.getOpenBottom = new function() {}

/**
 * 获取圆柱体的圆弧长度
 * @method getArcLength 
 * @return {float} 弧长
 */
mono.Cylinder.prototype.getArcLength = new function() {}

/**
 * 获取圆柱体圆弧的起始位置
 * @method getArcStart
 * @return {mono.Vec3} 起始位置
 */
mono.Cylinder.prototype.getArcStart = new function() {}

/**
 * 判断圆柱体上面是否为开口状态
 * @method isOpenTop
 * @return {boolean} 开口状态
 */
mono.Cylinder.prototype.isOpenTop = new function() {}

/**
 * 判断圆柱体下面是否为开口状态
 * @method isOpenBottom
 * @return {boolean} 开口状态 
 */
mono.Cylinder.prototype.isOpenBottom = new function() {}

/**
 * 根据标号获取圆柱体的面
 * @method getSideIndexMapping
 * @return {Object} 圆柱体对应编号的面
 */
mono.Cylinder.prototype.getSideIndexMapping = function() {}

/**
 * 球形
 * @class mono.Circle
 * @constructor
 */
mono.Circle = function() {}

mono.Circle.prototype = new mono.Entity

/**
 * 克隆
 * @method clone
 * @return {mono.Circle} 克隆的对象
 */
mono.Circle.prototype.clone = function() {}

/**
 * 圆环
 * @class mono.Torus
 * @constructor
 */
mono.Torus = function() {}

mono.Torus.prototype = new mono.Entity

/**
 * 获取圆环的半径尺寸
 * @method getRadius
 * @return {float} 圆环的半径
 */
mono.Torus.prototype.getRadius = new function() {}

/**
 * 获取圆环的横切面圆弧的半径尺寸
 * @method getTude
 * @return {float} 半径
 */
mono.Torus.prototype.getTube = new function() {}

/**
 * 获取圆环的分片数量,默认值8
 * @method getSegmentsR
 * @return {int} 分片数量
 */
mono.Torus.prototype.getSegmentsR = new function() {}

/**
 * 获取圆环横切面圆弧的分片数量,默认值6
 * @method getSegmentsT
 * @return {int} 分片数量
 */
mono.Torus.prototype.getSegmentsT = new function() {}

/**
 * 获取弧度
 * @method getArc
 * @return {float} 弧度
 */
mono.Torus.prototype.getArc = new function() {}

/**
 * 箭头
 * @class mono.Arrow
 * @constructor
 */
mono.Arrow = function() {}
mono.Arrow.prototype = new  mono.Entity

/**
 * 缓冲节点
 * @class mono.BufferNode
 * @constructor
 */
mono.BufferNode = function() {}

mono.BufferNode.prototype = new mono.Node

/**
 * 通过矩阵来实现变换
 * @method applyMatrix
 * @param {mono.Mat4} matrix 矩阵
 */
mono.BufferNode.prototype.applyMatrix = function(matrix) {}

/**
 * 正常化法线
 * @method normalizeNormals
 */
mono.BufferNode.prototype.normalizeNormals = function() {}

/**
 * 克隆
 * @method clone
 * @return {mono.BufferNode} 克隆的对象
 */
mono.BufferNode.prototype.clone = function() {}

/**
 * Particle(粒子)对象
 * @class mono.Particle
 * @constructor
 * @param {Array} vertices 顶点
 * @param {Array} colors 颜色
 * @param {String} material 材质
 */
mono.Particle = function(vertices,colors, material) {}

mono.Particle.prototype = new mono.Node
/**
 * 对象克隆
 * @method clone
 * @param {mono.Element} element 被克隆的对象
 */
mono.Particle.prototype.clone = function(element) {}
/**
 * 线条
 * @class mono.Line
 * @constructor
 * @param {Array} vertices 顶点
 * @param {Array} colors 颜色
 * @param {String} material 材质
 * @param {Object} type 类型
 */
mono.Line = function (vertices,colors,material, type) {}

mono.Line.prototype = new mono.Node()
/**
 * 对象克隆
 * @method clone
 * @param {mono} element 被克隆的对象
 */
mono.Line.prototype.clone = function(element) {}
/**
 * Path(路径)对象
 * @class mono.Path
 * @constructor
 * @param {Array} points 点的集合
 */
mono.Path = function(points) {}

mono.Path.prototype = new mono.CurvePath() {}
/**
 * 创建直线并连接所有的点
 * @method fromPoints
 * @param {Array} vectors  mono.Vec3类型的数组 
 */
mono.Path.prototype.fromPoints = function(vectors)
/**
 * 让路径反向
 * @method reverse
 * @return {mono.Path}返回反向后的Path对象
 */
mono.Path.prototype.reverse = function() {}
/**
 * 移动到一个坐标点
 * method moveTo
 * @param {Number} x x坐标
 * @param {Number} y  y坐标
 * @param {Number} z  z坐标
 * @return {mono.Path} 返回Path对象
 */
mono.Path.prototype.moveTo = function(x, y, z) {}
/**
 * 移动到某个位置
 * @method lineTo
 * @param {Number} x x坐标
 * @param {Number} y y坐标
 * @param {Number} z z坐标
 */
mono.Path.prototype.lineTo = function(x, y, z) {}
/**
 * 在当前的路径中增加一个二次方贝塞尔控制点
 * @method curveTo
 * @param {Number} aCPx 贝塞尔控制点的x坐标
 * @param {Number} aCPy 贝塞尔控制点的y坐标
 * @param {Number} aCPz 贝塞尔控制点的z坐标
 * @param {Number} aX 结束点的x坐标
 * @param {Number} aY 结束点的y坐标
 * @param {Number} aZ 结束点的z坐标
 */
mono.Path.prototype.curveTo = function(aCPx, aCPy, aCPz, aX, aY, aZ) {}
/**
 * 判断当前的路径是否是顺时针
 * @method isClockwise
 * @return {Boolean} 如果为顺时针返回true,如果为逆时针返回false
 */
mono.Path.prototype.isClockwise = function() {}
/**
 * 在当前的路径中增加一个三次方贝塞尔控制点
 * @method bCurveTo
 * @param {Number} aCP1x 第一个贝塞尔控制点的x坐标
 * @param {Number} aCP1y 第一个贝塞尔控制点的y坐标
 * @param {Number} aCP1z 第一个贝塞尔控制点的z坐标
 * @param {Number} aCP2x 第二个贝塞尔控制点的x坐标
 * @param {Number} aCP2y 第二个贝塞尔控制点的y坐标
 * @param {Number} aCP2z 第二个贝塞尔控制点的z坐标
 * @param {Number} aX 结束点的x坐标
 * @param {Number} aY 结束点的y坐标
 * @param {Number} aZ 结束点的z坐标
 */
mono.Path.prototype.bCurveTo = function(aCP1x, aCP1y, aCP1z, aCP2x, aCP2y, aCP2z, aX, aY, aZ) {}
/**
 * Path中点的连接方式,如[’moveTo', 'lineTo', 'quadraticCurveTo']
 * @method toArray
 * @return {Array} 路径中点的连接方式
 */
mono.Path.prototype.toArray = function() {}

/**
 * 把mono.Path转换为shape
 * @method toShapes
 * @param {Boolean} isCCW 如果为true,按顺时针转换,如果为false,按逆时针转换
 */
mono.Path.prototype.toShapes = function(isCCW) {}

/**
 * PathNode对象
 * @class mono.PathNode
 * @constructor
 * @param {mono.Path} path mono.Path对象
 * @param {Number} segments 切片数
 * @param {Number} radius 圆管的半径
 * @param {Number} segmentsR 圆管的切片数
 * @param {String} startCap 起始端线帽的样式
 * @param {String} endCap 结束端线帽的样式
 * @param {mono.Shape} shape Shape对象
 * @param {Number} arc 弧度数
 * @param {Number} arcStart 起始弧度 
 * @param {Number} cutSurface 切面类型 ,可以取值为'none','plain','center'
 */
mono.PathNode = function(path, segments, radius, segmentsR, startCap, endCap, shape, arc, arcStart, cutSurface) {}

mono.PathNode.prototype = new mono.Entity
/**
 * 调整路径
 * @method adjustPath
 * @param {mono.Path} path Path对象
 * @param {Number} radius 半径
 * @param {Number} times 次数
 */
mono.PathNode.prototype.adjustPath = function(path, radius, times) {}
/**
 * 返回mono.Path对象
 * @method getPath
 * return {mono.Path} Path对象
 */
mono.PathNode.prototype.getPath = function() {}
/**
 * 设置路径
 * @method setPath
 * @param {mono.Path} path Path对象
 */
mono.PathNode.prototype.setPath = function(path) {}
/**
 * 获取切片数
 * @method getSegments
 * @ return {Number} 切片数
 */
mono.PathNode.prototype.getSegments = function() {}
/**
 * 设置切片数
 * @method setSegments
 * @param {Number} segments  切片数
 */
mono.PathNode.prototype.setSegments = function(segments) {}
/**
 * 获取半径(圆管的半径)
 * @method getRadius
 * @return {Number} 半径
 */
mono.PathNode.prototype.getRadius = function() {}
/**
 * 设置半径(圆管的半径) 
 * @method setRadius
 * @param {Number} radius 半径
 */
mono.PathNode.prototype.setRadius = function(radius) {}
/**
 * 圆管的切片数
 * @method getSegmentsR
 * @return {Number} 切片数
 */
mono.PathNode.prototype.getSegmentsR = function() {}
/**
 * 设置圆管的切片数
 * @method setSegmentsR
 * @param {Number} segmentsR 切片数
 */
mono.PathNode.prototype.setSegmentsR = function(segmentsR) {}
/**
 * 获取起始端线帽的样式
 * @method getStartCap
 * @return {String} 线帽样式
 */
mono.PathNode.prototype.getStartCap = function() {}
/**
 * 设置起始端线帽的样式
 * @method setStartCap
 * @param {String} startCap 线帽样式
 */
mono.PathNode.prototype.setStartCap = function(startCap) {}
/**
 * 获取结束端线帽的样式
 * @method getEndCap
 */
mono.PathNode.prototype.getEndCap = function() {}
/**
 * 设置结束端线帽的样式
 * @method setEndCap
 * @param {String} endCap 线帽样式
 */
mono.PathNode.prototype.setEndCap = function(endCap) {}
/**
 * 获取Shape对象
 * @method getShape
 * @return {mono.Shape} Shape对象
 */
mono.PathNode.prototype.getShape = function() {}
/**
 * 设置Shape对象
 * @method setShape
 * @param {mono.Shape} shape Shape对象
 */
mono.PathNode.prototype.setShape = function(shape) {}
/**
 * 获取起始端线帽的数量
 * @method getStartCapSize
 * @return {Number} 线帽的数量
 */
mono.PathNode.prototype.getStartCapSize = function() {}
/**
 * 设置起始端线帽的数量
 * @method setStartCapSize
 * @param {Number} startCapSize 线帽的数量
 */
mono.PathNode.prototype.setStartCapSize = function(startCapSize) {}
/**
 * 获取结束端线帽的数量
 * @method getEndCapSize
 * @return {Number} 线帽的数量
 */
mono.PathNode.prototype.getEndCapSize = function() {}
/**
 * 设置结束端线帽的数量
 * @method setEndCapSize
 * @param {Number} endCapSize
 */
mono.PathNode.prototype.setEndCapSize = function(endCapSize) {}
/**
 * 获取线帽的切片数
 * @method getSegmentsCap
 * @return {Number} 线帽的切片数
 */
mono.PathNode.prototype.getSegmentsCap = function() {}
/**
 * 设置线帽的切片数
 * @method setSegmentsCap
 * @param {Number} segmentsCap 切片数
 */
mono.PathNode.prototype.setSegmentsCap = function(segmentsCap) {}
/**
 * 获取弧度
 * @method getArc
 * @return {Number} 弧度
 */
mono.PathNode.prototype.getArc = function() {}
/**
 * 设置弧度
 * @method setArc
 * @param {Number} arc 弧度
 */
mono.PathNode.prototype.setArc = function(arc) {}
/**
 * 获取起始弧度
 * @method getArcStart
 * @return {Number} 弧度
 */
mono.PathNode.prototype.getArcStart = function() {}
/**
 * 设置起始弧度
 * @method setArcStart
 * @param {Number} arcStart 起始弧度
 */
mono.PathNode.prototype.setArcStart = function(arcStart) {}
/**
 * 获取切面的类型
 * @method getCutSurface
 * @return {String} 切面的类型
 */
mono.PathNode.prototype.getCutSurface = function() {}
/**
 * 设置切面的类型
 * @method setCutSurface
 * @param {String} cutSurface 切面的类型
 */
mono.PathNode.prototype.setCutSurface = function(cutSurface) {}


/**
 * PathCube对象
 * @class mono.PathCube
 * @constructor
 * @param {mono.Path} path Path对象
 * @param {Number} width  宽度
 * @param {Number} height 高度
 * @param {Number} curveSegements 曲线的切片数
 * @param {Number} repeat 重复次数
 */
mono.PathCube = function(path, width, height, curveSegements, repeat) {}

mono.PathCube.prototype = new mono.Entity
/**
 * 获取PathCube.SideIndexMapping对象
 * @method getSideIndexMapping
 * @return {mono.PathCube.SideIndexMapping} PathCube.SideIndexMapping对象
 */
mono.PathCube.prototype.getSideIndexMapping = function() {}
/**
 * 克隆点
 * @method clonePoints
 * @param {Array} points
 * @return {Array} 返回克隆后的点
 */
mono.PathCube.prototype.clonePoints = function(points) {}
/**
 * ShapeNode对象
 * @class mono.ShapeNode
 * @constructor
 * @param {Array}or{mono.Path} shapes 形状
 * @param {Number} curveSegments 曲线的切片数
 * @param {Number} amount ShapeNode的厚度
 * @param {Boolean} vertical 是否竖直方向
 * @param {Number} repeat 重复次数
 * @param {Object} zMinusHalfAmount 
 */
mono.ShapeNode = function(shapes, curveSegments, amount, vertical, repeat, zMinusHalfAmount) {}

mono.ShapeNode.prototype = new mono.Entity
/**
 * 获取Shape对象数组
 * @method getShapes
 * @return [Array] 形状
 */
mono.ShapeNode.prototype.getShapes = function() {}
/**
 * 设置形状
 * @method setShapes
 * @param {Array} shapes Shape对象数组
 */
mono.ShapeNode.prototype.setShapes = function(shapes) {}
/**
 * 获取曲线的切片数
 * @method getCurveSegments
 * @return {Number} 切片数
 */
mono.ShapeNode.prototype.getCurveSegments = function() {}
/**
 * 设置曲线的切片数
 * @method setCurveSegments
 * @param {Number} curveSegments 曲线的切片数
 */
mono.ShapeNode.prototype.setCurveSegments = function(curveSegments) {}
/**
 * ShapeNode的厚度 
 * @method getAmount
 * @return {Number} 厚度
 */
mono.ShapeNode.prototype.getAmount = function() {}
/**
 * 设置ShapeNode厚度
 * @method setAmount
 * @param {Number} amount 厚度
 */
mono.ShapeNode.prototype.setAmount = function(amount) {}
/** 
 * 是否竖直方向
 * @method isVertical
 * @return {Boolean} 如果是竖直方向,返回true,否则返回false
 */
mono.ShapeNode.prototype.isVertical = function() {}
/**
 * 设置是否竖直
 * @method setVertical
 * @param {Boolean} vertical 如果为true,竖直,如果为false,则水平
 */
mono.ShapeNode.prototype.setVertical = function(vertical) {}
/**
 * @method addShapes 
 * @param {Array} shapes Shape对象数组
 * @param {Object} options 格式为{curveSegments : curveSegments, amount : amount,vertical : vertical, zMinusHalfAmount : zMinusHalfAmount, repeat : repeat || 20}
 */
mono.ShapeNode.prototype.addShapes = function(shapes, options) {}
/**
 * 
 * @method addShape
 * @param {mono.Shape} shape Shape对象
 * @param {Object} options options 格式为{curveSegments : curveSegments, amount : amount,vertical : vertical, zMinusHalfAmount : zMinusHalfAmount, repeat : repeat || 20,}
 * @param {Object} scope 作用域,为空时指的是window
 */
mono.ShapeNode.prototype.addShape = function(shape, options, scope) {}
/**
 * TextNode(文本)对象
 * @class mono.TextNode
 * @constructor
 * @param {String} text 文本内容
 * @param {Number} size 字号
 * @param {Number} height 字体宽度
 * @param {String} font 字体 
 * @param {String} weight 字体的weight
 * @param {String} style  字体的样式
 * @param {Number} curveSegments 曲线的切片数
 * @param {Boolean} bevelEnabled 能否倾斜
 */
mono.TextNode = function (text, size,height,font,weight,style,curveSegments,bevelEnabled) {}

mono.TextNode.prototype = new mono.ShapeNode
/**
 * 获取文本内容
 * @method getText
 * @return {String} 文本内容
 */
mono.TextNode.prototype.getText = function() {}
/**
 * 设置文本内容
 * @method setText
 * @param {String} text
 */
mono.TextNode.prototype.setText = function(text) {}
/**
 * 获取字号
 * @method getSize
 * @retrun {Number} 字号
 */
mono.TextNode.prototype.getSize = function() {}
/**
 * 设置字号
 * @method setSize
 * @param {Number} size
 */
mono.TextNode.prototype.setSize = function(size) {}
/**
 * 获取字体的高度
 * @method getHeight
 * @return {Number} 字体高度
 */
mono.TextNode.prototype.getHeight = function() {}
/**
 * 设置字体的高度
 * @method setHeight
 * @param {Number} height
 */
mono.TextNode.prototype.setHeight = function(height) {}
/**
 * 获取字体
 * @method getFont
 * @return {String} 字体
 */
mono.TextNode.prototype.getFont = function() {}
/**
 * 设置字体
 * @method setFont
 * @param {String} font
 */
mono.TextNode.prototype.setFont = function(font) {}
/**
 * 获取字体的weight
 * @method getWeight
 * @return {String} 字体的weight
 */
mono.TextNode.prototype.getWeight = function() {}
/**
 * 设置字体的weight
 * @method setWeight
 * @param {String} weight
 */
mono.TextNode.prototype.setWeight = function(weight) {}
/**
 * 获取字体的样式
 * @method getFontStyle
 * @return {String} 字体的样式
 */
mono.TextNode.prototype.getFontStyle = function() {}
/**
 * 设置字体的样式
 * @method setFontStyle
 * @param {String} fontStyle 字体的样式
 */
mono.TextNode.prototype.setFontStyle = function(fontStyle) {}

/**
 * LatheNode(车削)对象
 * @class mono.LatheNode
 * @constructor
 * @param {mono.Path} path
 * @param {Number} segmentsH
 * @param {Number} segmentsR
 * @param {Number} arc
 * @param {Boolean} startClosed
 * @param {Boolean} endClosed
 */
mono.LatheNode = function(path, segmentsH, segmentsR,arc, startClosed, endClosed) {}

mono.LatheNode.prototype = new mono.Entity
/**
 * 获取Path
 * @method getPath
 * @return {mono.Path} Path对象
 */
mono.LatheNode.prototype.getPath = function() {}
/**
 * 设置Path
 * @method setPath
 * @param {mono.Path} path Path对象
 */
mono.LatheNode.prototype.setPath = function(path) {}
/**
 * 获取车削中纬度方向的切片数
 * @method getSegmentsH
 * @return {Number} 切片数
 */
mono.LatheNode.prototype.getSegmentsH = function() {}
/**
 * 设置车削中纬度方向的切片数
 * @method setSegmentsH
 * @param {Number} segmentsH
 */
mono.LatheNode.prototype.setSegmentsH = function(segmentsH) {}
/**
 * 车削中经度方向的切片数
 * @method getSegmentsR
 * @return {Number} 切片数
 */
mono.LatheNode.prototype.getSegmentsR = function() {}
/**
 * 设置车削中经度方向的切片数
 * @method setSegmentsR
 * @param {Number} segmentsR 切片数
 */
mono.LatheNode.prototype.setSegmentsR = function(segmentsR) {}
/**
 * 获取弧度
 * @method getArc
 * @return {Number} 弧度
 */
mono.LatheNode.prototype.getArc = function() {}
/**
 * 设置弧度
 * @method setArc
 * @param {Number} arc 弧度
 */
mono.LatheNode.prototype.setArc = function(arc) {}
/**
 * 起始处是否闭合
 * @method isStartClosed
 * @return {Boolean} 如果为true,闭合,否则不闭合
 */
mono.LatheNode.prototype.isStartClosed = function() {}
/**
 * 设置起始处是否闭合
 * @method setStartClosed
 * @param {Boolean} startClosed 如果为true,闭合,否则不闭合
 */
mono.LatheNode.prototype.setStartClosed = function(startClosed) {}
/**
 * 结束处是否闭合
 * @method isEndClosed
 * @return {Boolean} 如果为true,闭合,否则不闭合
 */
mono.LatheNode.prototype.isEndClosed = function() {}
/**
 * 设置结束处是否闭合
 * @method setEndClosed
 * @param {Boolean} endClosed 如果为true,闭合,否则不闭合
 */
mono.LatheNode.prototype.setEndClosed = function(endClosed) {}

/**
 * CurvePlane(曲面)对象
 * @class mono.CurvePlane
 * @constructor
 * @param {mono.Path} pathH 水平方向的Path
 * @param {mono.Path} pathV 竖直方向的Path
 * @param {Number} segmentsH 水平方向的切片数
 * @param {Number} segmentsV 竖直方向的切片数
 */
mono.CurvePlane = function(pathH,pathV,segmentsH,segmentsV) {}

mono.CurvePlane.prototype = new mono.Entity

/**
 * ComboNode(组合)对象
 * @class mono.ComboNode
 * @constructor
 * @param {Array} combos 组合对象的数组
 * @param {Array} operators 操作对象的数组
 */
mono.ComboNode = function(combos, operators) {}

mono.ComboNode.prototype = new mono.Entity
/**
 * 数据容器是用于管理数据对象的。它是一种不可见的对象,在MVC框架中处于M(模型)层,它是所有视图的数据提供者
 * 数据容器可以管理数据对象的增减事件变化,也可以监听到数据的属性事件变化。
 * 数据容器上包含着选择容器,用于管理所有选中的数据
 * @class mono.DataBox
 * @constructor
 * @param {String} name
 * @return {mono.DataBox}
 */
mono.DataBox = function(name) {}

mono.DataBox.prototype = new mono.PropertyChangeDispatcher
/**
 * 返回数据容器的名字
 * @method getName
 * return {String} 数据容器的名字
 */
mono.DataBox.prototype.getName = function() {}
/**
 * 往数据容器中添加一个数据
 * @method add
 * @param {mono.Data} data 数据对象
 * @param {String} index 添加的数据的次序
 */
mono.DataBox.prototype.add = function(data, index) {}
/**
 * 如果节点有孩子,就把节点的孩子添加到数据容器中
 * @method addByDescendant
 * @param {mono.Data} data 数据对象
 */
mono.DataBox.prototype.addByDescendant = function(data) {}
/**
 * 获取网元容器中的告警容器
 * @method getAlarmBox
 * @return {mono.AlarmBox} 告警容器
 */
mono.DataBox.prototype.getAlarmBox = function() {}
/**
 * 通过数据的ID编号从数据容器中删除该数据
 * @method removeById
 * @param {Object} id 数据对象的编号
 */
mono.DataBox.prototype.removeById = function(id) {}
/**
 * 从数据容器中删除某个数据
 * @method remove
 * @param {mono.Data} data 数据对象
 */
mono.DataBox.prototype.remove = function(data) {}
/**
 * 通过数据ID判断是否包含某个数据
 * @method containsById
 * @param {Object} id 数据的ID编号、
 * @return {Boolean} true为包含,false不包含
 */
mono.DataBox.prototype.containsById = function(id) {}
/**
 * 判断是否包含某个数据
 * @method contains
 * @param {mono.Data} data
 * @return {Boolean} true为包含,false不包含
 */
mono.DataBox.prototype.contains = function(data) {}
/**
 * 数据容器的大小,也就是容器中数据的数量
 * @method size
 * @return {Number} 数据容器的大小
 */
mono.DataBox.prototype.size = function() {}
/**
 * 数据容器中光源的数量
 * method lightsSize
 * @return {Number} 数据容器光源的数量
 */
mono.DataBox.prototype.lightsSize = function() {}
/**
 * 获取数据容器中所有的光源
 * @method getLights
 * @return {mono.List} 数据容器中的光源
 */
mono.DataBox.prototype.getLights = function() {}
/**
 * 获取数据容器中所有的光源
 * @method getLightsArray
 * @return {Array} 数据容器中的光源
 */
mono.DataBox.prototype.getLightsArray = function() {}
/**
 * 清空数据容器中所有的数据
 * @method clear
 */
mono.DataBox.prototype.clear = function() {}
/**
 * 开始批处理
 * @method startBatch
 */
mono.DataBox.prototype.startBatch = function() {}
/**
 * 结束批处理
 * @method endBatch
 */
mono.DataBox.prototype.endBatch = function() {}
/**
 * 删除所有选中的数据
 * @method removeSelection
 */
mono.DataBox.prototype.removeSelection = function() {}
/**
 * 取消选中
 * @method clearSelection
 */
mono.DataBox.prototype.clearSelection = function() {}
/**
 * 取消编辑
 * @method clearEditing
 */
mono.DataBox.prototype.clearEditing = function() {}
/**
 * 根据数据的ID编号获取对应的数据
 * @method getDataById
 * @param {Object} id 数据的ID编号
 * @return {mono.Data} 数据对象
 */
mono.DataBox.prototype.getDataById = function(id) {}
/**
 * 添加数据容器的数据增减变化的监听器。当数据容器中的数据发生改变时(增加,删除,清空),就可以通过此方法监听
 * @method addDataBoxChangeListener
 * @param {Function} listener 网元更改事件的监听器
 * @param {Object} scope 监听器的作用域,为空时指的是window
 * @param {Boolean} ahead 是否添加在最前方,如果为空,则添加在最后一个位置
 */
mono.DataBox.prototype.addDataBoxChangeListener = function(listener, scope, ahead) {}
/**
 * 移除数据容器的数据增减变化的监听器
 * @method removeDataBoxChangeListener
 * @param {Function} listener 网元更改事件监听器
 * @param {Object} scope 监听器的作用域,为空时指的是window
 */
mono.DataBox.prototype.removeDataBoxChangeListener = function(listener, scope) {}
/**
 * 添加数据容器中数据的属性更改事件的监听器。当数据容器中的数据属性发生变化时,比如网元位置,网元名称等,都可以通过此方法来监听
 * @method addDataPropertyChangeListener
 * @param {Function} listener 网元属性更改事件的监听器
 * @param {Object} scope 监听器的作用域,为空时指的是window
 * @param {Object} ahead 是否添加在最前方,如果为空,则添加在最后一个位置
 */
mono.DataBox.prototype.addDataPropertyChangeListener = function(listener, scope, ahead) {}
/**
 * 移除数据容器中数据的属性更改事件的监听器
 * @method removeDataPropertyChangeListener
 * @param {Function} listener 网元属性更改事件的监听器
 * @param {Object} scope 监听器的作用域,为空时指的是window
 */
mono.DataBox.prototype.removeDataPropertyChangeListener = function(listener, scope) {}
/**
 * 获取数据容器中的选择容器,选择容器用于存放所有选中的数据对象,更详细的解释请参看SelectionModel类
 * @method getSelectionModel
 * @return {mono.SelectionModel} 选中数据的容器
 */
mono.DataBox.prototype.getSelectionModel = function() {}
/**
 * 数据容器的大小,也就是容器中数据的数量
 * @method size
 * @return {Number} 数据容器的大小
 */
mono.DataBox.prototype.size = function() {}
/**
 * 判断数据容器是否为空。当数据容器中没有数据时返回true,否则返回false
 * @method isEmpty
 * @return {Boolean} 当数据容器中没有数据时返回true,否则返回false
 */
mono.DataBox.prototype.isEmpty = function() {}
/**
 * 获取数据容器的上限数。默认为-1,是没有上限的,一旦设置了上限数,当添加的数据数量大于这个上限数时,mono就会删除最旧的数据
 * @method getLimit
 * @return {Number} 数据容器的上限数
 */
mono.DataBox.prototype.getLimit = function() {}
/**
 * 设置数据容器的上限数。默认为-1,是没有显示的,一旦设置了上限数,当添加的数据数量大于这个上限数时,mono就会删除最旧的数据
 * @method setLimit
 * @param {Number} limit
 */
mono.DataBox.prototype.setLimit = function(limit) {}
/**
 * 从数据容器中删除第一个数据
 * @method removeFirst
 * @param {Number} count 数据容器的大小
 */
mono.DataBox.prototype.removeFirst = function(count) {}
/**
 * 获取指定数据的所有兄弟数据
 * @method getSiblings
 * @param {mono.Data} data 指定的数据对象
 * @return {mono.List} 所有兄弟数据的集合
 */
mono.DataBox.prototype.getSiblings = function(data) {}
/**
 * 获取数据容器中所有根下的数据。根下的数据指的是没有父亲的数据
 * @method getRoots
 * @return {mono.List} 所有根下数据的集合
 */
mono.DataBox.prototype.getRoots = function() {}
/**
 * 获取指定数据在兄弟数据中的序号
 * @method getSiblingIndex
 * @param {mono.Data} data
 * @return {Number} 数据对象的序号
 */
mono.DataBox.prototype.getSiblingIndex = function(data) {}
/**
 * 获取数据容器中的所有节点对象
 * @method getNodes
 * @return {mono.List}
 */
mono.DataBox.prototype.getNodes = function() {}
/**
 * 获取数据容器中的所有Billboard对象
 * @method getBillboards
 * @return {mono.List}
 */
mono.DataBox.prototype.getBillboards = function() {}
/**
 * 获取数据容器中的所有数据
 * @method getDatas
 * @return {mono.List}
 */
mono.DataBox.prototype.getDatas = function() {}
/**
 * 获取数据容器中某个序号上的数据
 * @method getDataAt
 * @param {Object} index 数据的序号
 * @return {mono.Data} 数据对象
 */
mono.DataBox.prototype.getDataAt = function(index) {}
/**
 * 将数据容器中的数据转成集合
 * @method toDatas
 * @param {Object} matchFunction 转换成List集合时回调函数
 * @param {Object} scope 回调函数的作用域,为空时指的是window
 * @return {mono.List} 数据集合
 */
mono.DataBox.prototype.toDatas = function(matchFunction, scope) {}
/**
 * 遍历数据容器中的所有数据
 * @method forEach
 * @param {Function} f 回调函数
 * @param {Object} scope 回调函数的作用域,为空时指的是window
 */
mono.DataBox.prototype.forEach = function(f, scope) {}
/**
 * 反序遍历数据容器中所有数据
 * @method forEachReverse
 * @param {Function} f 回调函数
 * @param {Object} scope 回调函数的作用域,为空时指的是window
 */
mono.DataBox.prototype.forEachReverse = function(f, scope) {}
/**
 * 深度优先遍历数据容器中指定数据的所有子孙数据。如果指定数据为空时,就会遍历数据容器中的所有数据
 * @method forEachByDepthFirst
 * @param {Function} callbackFunction 回调函数
 * @param {mono.Data} data 遍历的数据对象,为空时会遍历数据容器中的所有数据
 * @param {Object} scope 回调函数的作用域,为空时指的是window
 */
mono.DataBox.prototype.forEachByDepthFirst = function(callbackFunction, data, scope) {}
/**
 * 广度优先遍历数据容器中指定数据的所有子孙数据。如果指定数据为空时,就会遍历数据容器中的所有数据
 * @method forEachByBreadthFirst
 * @param {Function} callbackFunction 回调函数
 * @param {mono.Data} data 数据对象
 * @param {Object} scope 回调函数的作用域,为空时指的是window
 */
mono.DataBox.prototype.forEachByBreadthFirst = function(callbackFunction, data, scope) {}

mono.Defaults = {}

/**
 * mono中的工具类,提供了一些常用的方法
 * @class mono.Utils
 * @constructor
 */
mono.Utils = {}
/**
 * 判断一个数是否是2的幂次方
 * @method isPowerOfTwo
 * @static
 * @param {Number} value 数值
 * @return {Boolean} 如果为true,则是2的幂次方,否则不是2的幂次方
 */
mono.Utils.isPowerOfTwo = function(value) {}
/**
 * 创建1个新的Element对象
 * @method createElement
 * @static
 * @param {mono.Element} element1 Element对象 
 * @param {mono.Element} element2 Element对象
 * @param {String} material 材质的url路径
 * @param {Number} materialIndexOffset 偏移量
 * @return {mono.Element} Element对象
 */
mono.Utils.createElement = function(element1, element2, material, materialIndexOffset) {}
/**
 * 如果参数clone为true,克隆一个对象,否则对element进行transform操作
 * @method transformElement
 * @static
 * @param {mono.Element} element Element对象
 * @param {Boolean} clone 如果为true,重新创建一个对象,如果为false,否则对element进行transform操作
 * @return {mono.Element} Element对象
 */
mono.Utils.transformElement = function(element, clone) {}
/**
 * 把element2合并到element1
 * @method mergeElement
 * @static
 * @param {mono.Elment} element1 Element对象
 * @param {mono.Element} element2 Element对象
 * @param {Number} materialIndexOffset 偏移量
 * @return {mono.Element} Element对象
 */
mono.Utils.mergeElement = function(element1, element2, materialIndexOffset) {}
/**
 * 自动调整Network3D的Bounds
 * @method autoAdjustNetworkBounds
 * @static
 * @param {mono.Network3D} network3D对象
 * @param {Object} o {w:width, h: height}
 * @param {Number} w 宽度
 * @param {Number} h 高度
 * @param {Number} left 与最左边的距离
 * @param {Number} top  与最顶部的距离
 */
mono.Utils.autoAdjustNetworkBounds = function(network, o, w, h, left, top) {}
/**
 * 判断某个对象内容是否为空
 * @method isEmptyObject
 * @static
 * @param {Object} obj 对象
 * @return {Boolean} 如果为空,返回true,否则返回false
 */
mono.Utils.isEmptyObject = function(obj) {}
/**
 * 判断某个对象是否是数组
 * @method isArray
 * @static
 * @param {Object} v 数组
 * @return {Boolean} 如果是数组,返回true,否则返回false
 */
mono.Utils.isArray = function(v) {}
/**
 * 判断两个对象是否相同
 * @method isSame
 * @static
 * @param {Object} a
 * @param {Object} b
 * @return {Boolean} 如果相同,返回true,否则返回false
 */
mono.Utils.isSame = function(a, b) {}
/**
 * 将对象转换为字符串
 * @method toString
 * @static
 * @param {Object} a 对象
 */
mono.Utils.toString = function(a) {}
/**
 * 验证license信息
 * @method validateLicense
 * @static
 * @param {String} license license的信息
 */
mono.Utils.validateLicense = function(license) {}

/** 
 * Network3D是一个用于交互的视图组件,可以展示3D场景,并实现用户和3D场景之间的交互,比如旋转镜头,选中3D对象,通过鼠标或键盘移动3D对象等。
 * Network3D需要由一个与之关联的DataBox驱动,显示DataBox中的网元。当初始化Network3D时,DataBox默认会绑定在Network3D上
 * @class mono.Network3D
 * @constructor
 * @param {TGL.DataBox} dataBox  和Network3D绑定的数据容器,如果为空,twaver内部会创建一个数据容器与之绑定
 * @param {TGL.Camera} camera  Network3D场景中的镜头
 * @param {Object} canvas  network3D上用于绘制所有图元的画布,如果为空,twaver内部会创建一张空的画布
 * @param {Object} parameters  其他相关的参数,此对象可以包含下面的属性:clearColor,clearAlpha,precision,fog,
 *                             devicePixelRatio,preserveDrawingBuffer,antialias,maxLights
 */
mono.Network3D = function(dataBox, camera, canvas, parameters) {};

/**
 * 设置和Network3D绑定的数据容器,databox不能为空
 * @method setDataBox
 * @param {mono.DataBox} dataBox
 */
mono.Network3D.prototype.setDataBox = function(dataBox) {}

/** 
 * 设置刷新Network3D之后的回调方法
 * @method setRenderCallback
 * @param {Function} f 回调方法
 */
mono.Network3D.prototype.setRenderCallback = function(f) {}

/**
 * 设置刷新Network3D前的执行方法
 * @method setBeforeRenderFunction
 * @param {Function} f 刷新Network3D之前执行的方法
 */
mono.Network3D.prototype.setBeforeRenderFunction = function(f) {}

/**
 * 获取和Network3D绑定的数据容器
 * @method getDataBox
 * @return {mono.DataBox} 返回和Network3D绑定的数据容器
 */
mono.Network3D.prototype.getDataBox = function() {}

/**
 * 获取network3D的背景色
 * @method getClearColor
 * @return {String} 获取network3D的背景色
 */
mono.Network3D.prototype.getClearColor = function() {}

/**
 * 设置network3D上的背景色
 * @method setClearColor
 * @param {string} clearColor
 */
mono.Network3D.prototype.setClearColor = function(clearColor) {}

/**
 * 设置network3D背景色的透明度,取值范围0~1之间
 * @method setClearAlpha
 * @param {number} clearAlpha
 */
mono.Network3D.prototype.setClearAlpha = function(clearAlpha) {}

/**
 * 获取Network3D的背景色透明度
 * @method getClearAlpha
 * @return {number}
 */
mono.Network3D.prototype.getClearAlpha = function() {}

/**
 * 获取Network3D场景的镜头
 * @method getCamera
 * @return {mono.Camera}
 */
mono.Network3D.prototype.getCamera = function() {}

/**
 * 强制刷新Network3D
 * @method render
 */
mono.Network3D.prototype.render =  function() {}

/**
 * 获取Network3D上的Canvas组件,返回值为canvas
 * @method getView
 * @return {Object} 返回canvas
 */
mono.Network3D.prototype.getView = function() {}

/**
 * 获取根视图
 * @method getRootView
 * @return {Object} 根视图
 */
mono.Network3D.prototype.getRootView = function() {}

/**
 * 调整rootview的宽高
 * @method adjustRootViewBounds
 * @param {Number} w rootview的宽度
 * @param {Number} h rootview的高度
 */
mono.Network3D.prototype.adjustRootViewBounds = function(w, h){}

/**
 * 调整Network的位置及宽高
 * @method adjustBounds
 * @param {Number} w  network的宽度值
 * @param {Number} h  network高度值
 * @param {Number} x  network的top的像素值
 * @param {Number} y  network的left的像素值
 */
mono.Network3D.prototype.adjustBounds = function(w, h, x, y) {}

/**
 * 设置视角窗口大小
 * @method setViewport
 * @param {Number} x 视角窗口的左边像素值
 * @param {Number} y 视角窗口的上边像素值
 * @param {Number} width 视角窗口的宽度
 * @param {Number} height 视角窗口的高度
 */
mono.Network3D.prototype.setViewport = function(x, y, width, height) {}

/**
 * 设置是否显示坐标轴
 * @method setShowAxis
 * @param {Boolean} showAxis  是否显示坐标轴,值为true即显示坐标轴,false则不显示
 */
mono.Network3D.prototype.setShowAxis = function(showAxis) {}

/**
 * 设置是否显示坐标轴文字
 * @method setShowAxisText
 * @param {Boolean} showAxisText 是否显示坐标轴文字,值为true即显示坐标轴文字,false则不显示
 */
mono.Network3D.prototype.setShowAxisText = function(showAxisText) {}

/**
 * 网元是否可选
 * @method isSelectable
 * @param {mono.Data} element 指定的网元
 * @return {Boolean}  值为true即为该网元可选,false则不可选
 */
mono.Network3D.prototype.isSelectable = function(element) {}

/**
 * 设置是否可选过滤器,该过滤器可以用来过滤哪些网元可选,哪些网元不可选
 * @method setSelectableFunction
 * @param {Function} f 可选过滤器的函数
 */
mono.Network3D.prototype.setSelectableFunction = function(f) {}

/**
 * 设置是否需要绘制选择边框的过滤器,该过滤器可以用来过滤哪些选中的网元需要绘制选择边框,哪些不需要
 * @method setRenderSelectFunction
 * @param {Function} f 网元选中时选中边框是否需要绘制的过滤器
 */
mono.Network3D.prototype.setRenderSelectFunction = function(f) {}

/**
 * 将Network3D导出成图片
 * @method toImageData
 * @param {String} type 图片的格式类型,目前支持PNG,JPEG,BMP格式
 * @param {Object} clipBounds  Network3D上需要导出成图片的剪辑区域,它是一个包含x,y,w,h这些属性的对象
 * @param {Number} width 生成的图片的宽度
 * @param {Number} height 生成的图片的高度
 * @return {String} 返回base64的图片资源字符串
 */
mono.Network3D.prototype.toImageData =  function(type, clipBounds, width, height) {}

/**
 * 获取鼠标事件下的网元
 * @method getElementsByMouseEvent
 * @param {Event} event 鼠标事件
 * @param {Boolean} intersectUnVisible 是否获取不可见的网元,如果为true,当鼠标下的网元不可见,也会返回该网元,反之则不返回该网元
 * @return {} 鼠标事件下所有的网元
 */
mono.Network3D.prototype.getElementsByMouseEvent = function(event, intersectUnVisible) {}

/**
 * 将一个3D的坐标投射到2D平面上时所得到的2D的坐标
 * @method getViewPosition
 * @param {mono.Vec3} vector 3D的坐标值
 * @return {Object} 返回一个包含x,y属性的对象
 */
mono.Network3D.prototype.getViewPosition =  function(vector) {}

/**
 * 设置Network3D的交互监听集,例如:
 * var interactions = [selectionInteraction, defaultInteraction];
 * network3d.setInteractions(interactions);
 * @method setInteractions
 * @param {Array} interactions  所有需要设置到Network上的交互监听集合
 */
mono.Network3D.prototype.setInteractions = function(interactions) {}

/**
 * 获取所有的交互监听集
 * @method getInteractions
 * @return {Array} 所有的交互监听集
 */
mono.Network3D.prototype.getInteractions =function() {}

/**
 * 广告牌,它是mono中提供的一种通用的3D对象,它和其他3D对象的区别在于当旋转镜头时,广告牌始终是面朝着镜头
 * @class mono.Billboard
 * @constructor
 */

mono.Billboard = function() {};

/**
 * 将一个广告牌克隆出一个新的广告牌
 * @method clone
 * @param {mono.Billboard} element 被克隆的广告牌对象
 * @return {mono.Billboard} 返回克隆的新广告牌
 */
mono.Billboard.prototype.clone = function(element){};


/**
 * Light是所有灯的基类,在3D场景中,光照是非常重要的元素,它模拟了现实世界,在3D场景中的物体可以反射出光照效果
 * @class mono.Light
 * @constructor
 * @param {Number} color 灯光的颜色值
 */
mono.Light = function(color) {};

/**
 * 设置是否需要显示灯光的阴影
 * @method setCastShadow
 * @param {Boolean} castShadow 是否显示灯光阴影效果
 */
mono.Light.prototype.setCastShadow = function(castShadow) {}

/**
 * 设置光照的颜色值
 * @method setColor
 * @param {Number} color 光照的颜色值
 */
mono.Light.prototype.setColor = function(color){},

/**
 * 获取光照的颜色值
 * @method getColor
 * @return {Number} 返回光照的颜色值
 */
mono.Light.prototype.getColor = function(){return color}

/**
 * 设置环境光照的颜色值
 * @method setAmbient
 * @param {mono.Color} ambient 环境光照的颜色
 */
mono.Light.prototype.setAmbient = function(ambient){}

/**
 * 获取环境光照的颜色值
 * @method getAmbient
 * @return {mono.Color} 返回环境光照的颜色
 */
mono.Light.prototype.getAmbient = function(){return ambient},

/**
 * 设置散射光的颜色值 
 * @method setDiffuse
 * @param {mono.Color} diffuse 散射光的颜色值 
 */
mono.Light.prototype.setDiffuse = function(diffuse){}

/**
 * 获取散射光的颜色值 
 * @method getDiffuse
 * @return {mono.Color} 返回散射光的颜色值 
 */
mono.Light.prototype.getDiffuse = function(){return diffuse}

/**
 * 设置镜面光的颜色值
 * @method setSpecular
 * @param {mono.Color} specular 镜面光的颜色值
 */
mono.Light.prototype.setSpecular = function(specular){},

/**
 * 获取镜面光的颜色值
 * @method getSpecular
 * @return {mono.Color} 返回镜面光的颜色值
 */
mono.Light.prototype.getSpecular =  function(){ return specular }

/**
 * 点光源。在3D场景中创建一个指定颜色的点光源元素
 * @class mono.PointLight
 * @constructor
 * @param {Number} hex 一个包含RGB的十六进制数组
 * @param {Number} intensity 光照强度值,如果为空,默认设置为1
 * @param {Number} distance 光照衰减的距离值
 */
mono.PointLight = function ( hex, intensity, distance ) {};

/**
 * 设置光照的强度
 * @method setIntensity
 * @param {Number} intensity 光照的强度
 */
mono.PointLight.prototype.setIntensity = function(intensity){}

/**
 * 获取光照的强度值
 * @method getIntensity
 * @return {Number} 返回光照的强度值
 */
mono.PointLight.prototype.getIntensity = function(){}

/**
 * 设置光照的衰减距离
 * @method setDistance
 * @param {Number} distance 光照的衰减距离
 */
mono.PointLight.prototype.setDistance =function(distance){}

/**
 * 获取光照的衰减距离
 * @method getDistance
 * @return {Number} 返回光照的衰减距离
 */
mono.PointLight.prototype.getDistance =  function(){}

/**
 * 聚光源。在3D场景中创建一个指定颜色的聚光灯元素
 * @class mono.SpotLight
 * @constructor
 * @param {Number} hex 一个包含RGB的十六进制数组
 * @param {Number} intensity 光照强度值,如果为空,默认设置为1
 * @param {Number} distance 光照衰减的距离值
 * @param {Number} angle 最大可扩散的光照弧度
 * @param {} exponent 
 */
mono.SpotLight = function ( hex, intensity, distance, angle, exponent ) {};

/**
 * 设置光照衰减的距离值
 * @method setDistance
 * @param {Number} distance 光照衰减的距离值
 */
mono.SpotLight.prototype.setDistance = function(distance){}

/**
 * 获取光照衰减的距离值
 * @method getDistance
 * @return {Number} 返回光照的衰减距离
 */
mono.SpotLight.prototype.getDistance = function(){}

/**
 * 设置最大可扩散的光照弧度
 * @method setAngle
 * @param {Number} angle 最大可扩散的光照弧度
 */
mono.SpotLight.prototype.setAngle = function(angle){}

/**
 * 获取最大可扩散的光照弧度
 * @method getAngle
 * @return {Number} 返回最大可扩散的光照弧度
 */
mono.SpotLight.prototype.getAngle = function(){}

/**
 * 方向光源。在3D场景中创建一个指定颜色的方向光照
 * @class mono.DirectionalLight
 * @constructor
 * @param {Number} hex 一个包含RGB的十六进制数组
 * @param {Number} intensity 光照强度值,如果为空,默认设置为1
 */
mono.DirectionalLight = function ( hex, intensity ) {};

/**
 * 环境光,环境光是那些在环境中进行了充分的散射,无法辨认其方向的光。
 * @class mono.AmbientLight
 * @constructor
 * @param {Number} hex 一个包含RGB的十六进制数组
 */
mono.AmbientLight = function(hex) {};

/**
 * 将一个点光源对象克隆出新的对象
 * @method clone
 * @return {mono.AmbientLight} 返回新的点光源对象
 */
mono.AmbientLight.prototype.clone = function() {}


/**
 * 镜头是一个抽象的概念,它在3D场景中用于模仿人的眼睛来观察物体,用于将3D场景中的物体投射到2D的平面上。
 * @class mono.Camera
 * @constructor
 */
mono.Camera = function() {};


/**
 * 镜头观察点的目标位置
 * @method look
 * @param {mono.Vec3} target 目标位置
 */
mono.Camera.prototype.look = function(target){}

/**
 * 获取镜头观察点的目标位置
 * @method getTarget
 * @return {mono.Vec3} 返回观察点的位置坐标
 */
mono.Camera.prototype.getTarget = function(){}

/**
 * 透视投影镜头,透视投影模仿人的眼睛来观察物体,距离镜头越远,在最终图像上看上去就越小,
 * 透视投影的视景体可以看成一个金字塔的平截头体,顶部被一个平行于底面的平面截除。
 * 使用透视投影镜头获得的结果是类似人眼在真实世界中看到的有“近大远小”的效果。
 * @class mono.PerspectiveCamera
 * @constructor
 * @param {Number} fov yz平面上视野的角度值,可选值的范围在0~180之间
 * @param {Number} aspect 视景体的纵横比,也就是宽度除以高度
 * @param {Number} near  观察点到视景体的顶部平面的距离
 * @param {Number} far 观察点到视景体的底部平面的距离
 */
mono.PerspectiveCamera = function ( fov, aspect, near, far ) {};


/**
 * 默认的交互模式,mono中提供的默认交互模式包括可以在3D场景中旋转镜头,通过鼠标滚轮缩放镜头,键盘操作镜头等。
 * @class mono.DefaultInteraction
 * @constructor
 * @param {mono.Network3D} network 用于添加默认交互的3D场景
 */
mono.DefaultInteraction = function(network) {};

/**
 * 获取镜头旋转的速度
 * @method getRotateSpeed
 * @return {Number} 返回镜头旋转的速度
 */
mono.DefaultInteraction.prototype.getRotateSpeed = function(){return rotateSpeed}

 /**
 * 设置镜头旋转的速度
 * @method setRotateSpeed
 * @param {Number} rotateSpeed 镜头旋转的速度
 */
mono.DefaultInteraction.prototype.setRotateSpeed = function(rotateSpeed){}

/**
 * 获取镜头缩放的速度
 * @method getZoomSpeed
 * @return {Number} 返回镜头缩放的速度
 */
mono.DefaultInteraction.prototype.getZoomSpeed = function(){return zoomSpeed}

/**
 * 设置镜头缩放的速度
 * @method setZoomSpeed
 * @param {Number} zoomSpeed 镜头缩放的速度
 */
mono.DefaultInteraction.prototype.setZoomSpeed = function(zoomSpeed){}

/**
 * 获取镜头平移的速度
 * @method getPanSpeed
 * @return {Number} 返回镜头平移的速度
 */
mono.DefaultInteraction.prototype.getPanSpeed = function(){return panSpeed},

/**
 * 设置镜头平移的速度
 * @method setPanSpeed
 * @param {Number} panSpeed 镜头平移的速度
 */
mono.DefaultInteraction.prototype.setPanSpeed = function(panSpeed){}


/**
 * 选择交互默认,当设置3D场景为选择交互模式时,3D场景中的对象可以被选中,也可以按住ctrl键进行框选
 * @class mono.SelectionInteraction
 * @constructor
 * @param {mono.network3D} network 用于添加交互模式的3D场景
 */
mono.SelectionInteraction = function(network) {};

/**
 * 可编辑交互模式,在此模式下可以编辑3D对象,例如平移,缩放,旋转等
 * @class mono.EditInteraction
 * @constructor
 * @param {mono.Network3D} network 用于添加交互默认的3D场景
 */

mono.EditInteraction = function(network) {};

/**
 * 设置是否显示帮助的组件
 * @method setShowHelpers
 * @param {Boolean} showHelpers 是否显示帮助的相关组件
 */
mono.EditInteraction.prototype.setShowHelpers = function(showHelpers) {}

/**
 * 设置是否可缩放
 * @method setScaleable
 * @param {Boolean} scaleable 是否可缩放
 */
mono.EditInteraction.prototype.setScaleable  = function(scaleable) {}

/**
 * 设置是否可旋转
 * @method setRotateable
 * @param {Boolean} rotateable 是否可旋转
 */
mono.EditInteraction.prototype.setRotateable = function(rotateable) {}

/**
 * 设置是否可平移
 * @method setTranslateable
 * @param {Boolean} translateable 是否可平移
 */
mono.EditInteraction.prototype.setTranslateable = function(translateable) {}

/**
 * 设置默认的模式,mono中提供了三种模式:translate,rotate和scale
 * @method setDefaultMode
 * @param {String} defaultMode 默认的模式
 */
mono.EditInteraction.prototype.setDefaultMode = function(defaultMode) {}

 /**
 * 设置缩放率
 * @method setScaleRate
 * @param {Number} scaleRate 缩放率
 */
mono.EditInteraction.prototype.setScaleRate = function(scaleRate) {}

/**
 * 设置是否需要等比例缩放
 * @method setForceSameScale
 * @param {Boolean} forceSameScale 是否等比例缩放
 */
mono.EditInteraction.prototype.setForceSameScale = function(forceSameScale) {}