ccb 0.0.1

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/extensions/cocostudio/loader/parsers/compatible.js

@@ -0,0 +1,251 @@
+/****************************************************************************
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+
+ http://www.cocos2d-x.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+
+
+/*
+ This file is for compatibility compatibility with older versions of GUIReader and SceneReader
+ todo: deprecated all
+ */
+
+(function(){
+
+    ccs.uiReader = {
+
+        _fileDesignSizes: {},
+
+        //@deprecated This function will be deprecated sooner or later please use ccs.load
+        /**
+         * Create CCUI Node
+         * @param file
+         * @returns {*}
+         */
+        widgetFromJsonFile: function(file){
+            var json = cc.loader.getRes(file);
+            if(json)
+                this._fileDesignSizes[file] = cc.size(json["designWidth"]||0, json["designHeight"]||0);
+
+            var version = json["Version"] || json["version"];
+            var versionNum = ccs.uiReader.getVersionInteger(version);
+            if(!version || versionNum >= 1700){
+                cc.warn("Not supported file types, Please try use the ccs.load");
+                return null;
+            }
+            return ccs._load(file, "ccui");
+        },
+
+        //@deprecated This function will be deprecated sooner or later please use parser.registerParser
+        /**
+         * Register a custom Widget reader
+         * @param classType
+         * @param ins
+         * @param object
+         * @param callback
+         * @deprecated This function will be deprecated sooner or later please use parser.registerParser
+         */
+        registerTypeAndCallBack: function(classType, ins, object, callback){
+            var parser = ccs._load.getParser("ccui")["*"];
+            var func = callback.bind(object);
+            parser.registerParser(classType, function(options, resourcePath){
+                var widget = new ins();
+                var uiOptions = options["options"];
+                object.setPropsFromJsonDictionary && object.setPropsFromJsonDictionary(widget, uiOptions);
+                this.generalAttributes(widget, uiOptions);
+                var customProperty = uiOptions["customProperty"];
+                if(customProperty)
+                    customProperty = JSON.parse(customProperty);
+                else
+                    customProperty = {};
+                func(classType, widget, customProperty);
+                this.colorAttributes(widget, uiOptions);
+                this.anchorPointAttributes(widget, uiOptions);
+                this.parseChild.call(this, widget, options, resourcePath);
+                return widget;
+            });
+        },
+
+        //@deprecated This function will be deprecated sooner or later
+        /**
+         * Gets the version number by version string.
+         * @param {String} version version string.
+         * @returns {Number}
+         */
+        getVersionInteger: function(version){
+            if(!version || typeof version != "string") return 0;
+            var arr = version.split(".");
+            if (arr.length != 4)
+                return 0;
+            var num = 0;
+            arr.forEach(function(n, i){
+                num += n * Math.pow(10, 3 - i);
+            });
+            return num;
+        },
+
+        //@deprecated This function will be deprecated sooner or later
+        /**
+         * stores the designSize of UI file.
+         * @param {String} fileName
+         * @param {cc.Size} size
+         */
+        storeFileDesignSize: function (fileName, size) {
+            this._fileDesignSizes[fileName] = size;
+        },
+
+        //@deprecated This function will be deprecated sooner or later
+        /**
+         * Gets the design size by filename.
+         * @param {String} fileName
+         * @returns {cc.Size}
+         */
+        getFileDesignSize: function (fileName) {
+            return this._fileDesignSizes[fileName];
+        },
+
+        //@deprecated This function will be deprecated sooner or later
+        /**
+         * Returns the file path
+         * @returns {string}
+         */
+        getFilePath: function(){
+            return this._filePath;
+        },
+
+        //@deprecated This function will be deprecated sooner or later
+        setFilePath: function(path){
+            this._filePath = path;
+        },
+
+        //@deprecated This function will be deprecated sooner or later
+        /**
+         * Returns the parsed object map. (analytic function)
+         * @returns {Object}
+         */
+        getParseObjectMap: function(){
+            return ccs._load.getParser("ccui")["*"]["parsers"];
+        },
+
+        //@deprecated This function will be deprecated sooner or later
+        /**
+         * Returns the parsed callback map. (analytic function)
+         * @returns {*}
+         */
+        getParseCallBackMap: function(){
+            return ccs._load.getParser("ccui")["*"]["parsers"];
+        },
+
+        //@deprecated This function will be deprecated sooner or later
+        clear: function(){}
+    };
+
+    var parser = ccs._load.getParser("ccui")["*"];
+    ccs.imageViewReader  = {setPropsFromJsonDictionary: parser.ImageViewAttributes};
+    ccs.buttonReader     = {setPropsFromJsonDictionary: parser.ButtonAttributes};
+    ccs.checkBoxReader   = {setPropsFromJsonDictionary: parser.CheckBoxAttributes};
+    ccs.labelAtlasReader = {setPropsFromJsonDictionary: parser.TextAtlasAttributes};
+    ccs.labelBMFontReader= {setPropsFromJsonDictionary: parser.TextBMFontAttributes};
+    ccs.labelReader      = {setPropsFromJsonDictionary: parser.TextAttributes};
+    ccs.layoutReader     = {setPropsFromJsonDictionary: parser.LayoutAttributes};
+    ccs.listViewReader   = {setPropsFromJsonDictionary: parser.ListViewAttributes};
+    ccs.loadingBarReader = {setPropsFromJsonDictionary: parser.LoadingBarAttributes};
+    ccs.pageViewReader   = {setPropsFromJsonDictionary: parser.PageViewAttributes};
+    ccs.scrollViewReader = {setPropsFromJsonDictionary: parser.ScrollViewAttributes};
+    ccs.sliderReader     = {setPropsFromJsonDictionary: parser.SliderAttributes};
+    ccs.textFieldReader  = {setPropsFromJsonDictionary: parser.TextFieldAttributes};
+})();
+
+(function(){
+    ccs.sceneReader = {
+
+        _node: null,
+
+        //@deprecated This function will be deprecated sooner or later please use ccs.load
+        /**
+         * Create Scene Node
+         * @param file
+         * @returns {*}
+         */
+        createNodeWithSceneFile: function(file){
+            var node = ccs._load(file, "scene");
+            this._node = node;
+            return node;
+        },
+
+        /**
+         * Get a node by tag.
+         * @param {Number} tag
+         * @returns {cc.Node|null}
+         */
+        getNodeByTag: function(tag){
+            if (this._node == null)
+                return null;
+            if (this._node.getTag() == tag)
+                return this._node;
+            return this._nodeByTag(this._node, tag);
+        },
+
+        _nodeByTag: function (parent, tag) {
+            if (parent == null)
+                return null;
+            var retNode = null;
+            var children = parent.getChildren();
+            for (var i = 0; i < children.length; i++) {
+                var child = children[i];
+                if (child && child.getTag() == tag) {
+                    retNode = child;
+                    break;
+                } else {
+                    retNode = this._nodeByTag(child, tag);
+                    if (retNode)
+                        break;
+                }
+            }
+            return retNode;
+        },
+
+        //@deprecated This function will be deprecated sooner or later
+        /**
+         * Returns the version of ccs.SceneReader.
+         * @returns {string}
+         */
+        version: function(){
+            return "*";
+        },
+
+        //@deprecated This function will be deprecated sooner or later
+        /**
+         * Sets the listener to reader.
+         * Cannot use
+         */
+        setTarget: function(){},
+
+        //@deprecated This function will be deprecated sooner or later
+        /**
+         * Clear all triggers and stops all sounds.
+         */
+        clear: function(){
+            ccs.triggerManager.removeAll();
+            cc.audioEngine.end();
+        }
+    };
+})();

data/lib/ccb/builder/templates/project/folder/frameworks/cocos2d-html5/extensions/cocostudio/loader/parsers/scene-1.x.js

@@ -0,0 +1,262 @@
+/****************************************************************************
+ Copyright (c) 2013-2014 Chukong Technologies Inc.
+
+ http://www.cocos2d-x.org
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+
+(function(load, baseParser){
+
+    var Parser = baseParser.extend({
+
+        getNodeJson: function(json){
+            return json;
+        },
+
+        parseNode: function(json, resourcePath){
+            var parser = this.parsers[this.getClass(json)];
+            var node = null;
+            if(parser)
+                node = parser.call(this, json, resourcePath);
+            else
+                cc.log("Can't find the parser : %s", this.getClass(json));
+
+            return node;
+        },
+
+        deferred: function(json, resourcePath, node, file){
+            ccs.triggerManager.parse(json["Triggers"]||[]);
+            if(ccs.sceneReader)
+                ccs.sceneReader._node = node;
+        },
+
+        setPropertyFromJsonDict: function(node, json){
+            var x = (cc.isUndefined(json["x"]))?0:json["x"];
+            var y = (cc.isUndefined(json["y"]))?0:json["y"];
+            node.setPosition(x, y);
+
+            var bVisible = Boolean((cc.isUndefined(json["visible"]))?1:json["visible"]);
+            node.setVisible(bVisible);
+
+            var nTag = (cc.isUndefined(json["objecttag"]))?-1:json["objecttag"];
+            node.setTag(nTag);
+
+            var nZorder = (cc.isUndefined(json["zorder"]))?0:json["zorder"];
+            node.setLocalZOrder(nZorder);
+
+            var fScaleX = (cc.isUndefined(json["scalex"]))?1:json["scalex"];
+            var fScaleY = (cc.isUndefined(json["scaley"]))?1:json["scaley"];
+            node.setScaleX(fScaleX);
+            node.setScaleY(fScaleY);
+
+            var fRotationZ = (cc.isUndefined(json["rotation"]))?0:json["rotation"];
+            node.setRotation(fRotationZ);
+
+            var sName = json["name"] || "";
+            node.setName(sName);
+        }
+
+    });
+
+    var parser = new Parser();
+
+    parser.parseChild = function(node, objects, resourcePath){
+        for (var i = 0; i < objects.length; i++) {
+            var child,
+                options = objects[i];
+            if(options)
+                child = this.parseNode(options, resourcePath);
+            if(child)
+                node.addChild(child);
+        }
+    };
+
+    var componentsParser = {
+        "CCSprite": function(node, component, resourcePath){
+            var child = new cc.Sprite();
+            loadTexture(component["fileData"], resourcePath, function(path, type){
+                if(type == 0)
+                    child.setTexture(path);
+                else if(type == 1){
+                    var spriteFrame = cc.spriteFrameCache.getSpriteFrame(path);
+                    child.setSpriteFrame(spriteFrame);
+                }
+            });
+            var render = new ccs.ComRender(child, "CCSprite");
+            node.addComponent(render);
+            return render;
+        },
+        "CCTMXTiledMap": function(node, component, resourcePath){
+            var child = null;
+            loadTexture(component["fileData"], resourcePath, function(path, type){
+                if(type == 0)
+                    child = new cc.TMXTiledMap(path);
+            });
+            var render = new ccs.ComRender(child, "CCTMXTiledMap");
+            node.addComponent(render);
+            return render;
+        },
+        "CCParticleSystemQuad": function(node, component, resourcePath){
+            var child = null;
+            loadTexture(component["fileData"], resourcePath, function(path, type){
+                if(type == 0)
+                    child = new cc.ParticleSystem(path);
+                else
+                    cc.log("unknown resourcetype on CCParticleSystemQuad!");
+                child.setPosition(0, 0);
+            });
+            var render = new ccs.ComRender(child, "CCParticleSystemQuad");
+            node.addComponent(render);
+            return render;
+        },
+        "CCArmature": function(node, component, resourcePath){
+            var child = null;
+            loadTexture(component["fileData"], resourcePath, function(path, type){
+                if(type == 0){
+                    var jsonDict = cc.loader.getRes(path);
+                    if (!jsonDict) cc.log("Please load the resource [%s] first!", path);
+                    var armature_data = jsonDict["armature_data"];
+                    var subData = armature_data[0];
+                    var name = subData["name"];
+                    ccs.armatureDataManager.addArmatureFileInfo(path);
+                    child = new ccs.Armature(name);
+                }
+            });
+            if(child){
+                var render = new ccs.ComRender(child, "CCArmature");
+                node.addComponent(render);
+                var actionName = component["selectedactionname"];
+                if (actionName && child.getAnimation())
+                    child.getAnimation().play(actionName);
+
+                return render;
+            }
+
+        },
+        "CCComAudio": function(node, component, resourcePath){
+            var audio = null;
+            loadTexture(component["fileData"], resourcePath, function(path, type){
+                if(type == 0){
+                    audio = new ccs.ComAudio();
+                    audio.preloadEffect(path);
+                    var name = component["name"];
+                    if(name)
+                        audio.setName(name);
+                    node.addComponent(audio);
+                }
+            });
+        },
+        "CCComAttribute": function(node, component, resourcePath){
+            var attribute = null;
+            loadTexture(component["fileData"], resourcePath, function(path, type){
+                if(type == 0){
+                    attribute = new ccs.ComAttribute();
+                    if (path != "")
+                        attribute.parse(path);
+                    node.addComponent(attribute);
+                }else
+                    cc.log("unknown resourcetype on CCComAttribute!");
+            });
+            return attribute;
+        },
+        "CCBackgroundAudio": function(node, component, resourcePath){
+            var audio = null;
+            loadTexture(component["fileData"], resourcePath, function(path, type){
+                if(type == 0){
+                    audio = new ccs.ComAudio();
+                    audio.preloadBackgroundMusic(path);
+                    audio.setFile(path);var bLoop = Boolean(component["loop"] || 0);
+                    audio.setLoop(bLoop);
+                    var name = component["name"];
+                    if(name)
+                        audio.setName(name);
+                    node.addComponent(audio);
+                    audio.playBackgroundMusic(path, bLoop);
+                }
+            });
+        },
+        "GUIComponent": function(node, component, resourcePath){
+            var widget = null;
+            loadTexture(component["fileData"], resourcePath, function(path, type){
+                widget = ccs._load(path, "ccui");
+            });
+            var render = new ccs.ComRender(widget, "GUIComponent");
+            node.addComponent(render);
+            return render;
+        },
+        "CCScene": function(){}
+    };
+    var loadedPlist = {};
+    var loadTexture = function(json, resourcePath, cb){
+        if(json != null){
+            var path = json["path"];
+            var type = json["resourceType"];
+            var plist = json["plist"];
+            if(!path)
+                return;
+            if(plist){
+                if(cc.loader.getRes(resourcePath + plist)){
+                    loadedPlist[resourcePath + plist] = true;
+                    cc.spriteFrameCache.addSpriteFrames(resourcePath + plist);
+                }else{
+                    if(!loadedPlist[resourcePath + plist])
+                        cc.log("%s need to be preloaded", resourcePath + plist);
+                }
+            }
+            if(type !== 0)
+                cb(path, type);
+            else
+                cb(resourcePath + path, type);
+        }
+    };
+
+    parser.parseComponents = function(node, json, resourcePath){
+        if(!node || !json)
+            return;
+        json.forEach(function(component){
+            var parser = componentsParser[component["classname"]];
+            var render = null;
+            if(parser)
+                render = parser(node, component, resourcePath);
+            else
+                cc.log("Can't find the component parser : %s", component["classname"]);
+            var name = component["name"];
+            if(render && name){
+                render.setName(name);
+            }
+        });
+    };
+
+    parser.registerParser("CCNode", function(options, resourcePath){
+        var node = new cc.Node();
+        this.setPropertyFromJsonDict(node, options);
+        this.parseChild.call(this, node, options["gameobjects"], resourcePath);
+        this.parseComponents(node, options["components"], resourcePath);
+        var size = options["CanvasSize"];
+        if (size)
+            node.setContentSize(cc.size(size["_width"], size["_height"]));
+
+        return node;
+    });
+
+    load.registerParser("scene", "*", parser);
+
+
+})(ccs._load, ccs._parser);