#

API Docs for: 1.4.3
Show: Inherited Protected Private Deprecated

# File: src/pixi/loaders/JsonLoader.js

    /**
     * @author Mat Groves http://matgroves.com/ @Doormat23
     */

    /**
     * The json file loader is used to load in JSON data and parse it
     * When loaded this class will dispatch a 'loaded' event
     * If loading fails this class will dispatch an 'error' event
     *
     * @class JsonLoader
     * @uses EventTarget
     * @constructor
     * @param url {String} The url of the JSON file
     * @param crossorigin {Boolean} Whether requests should be treated as crossorigin
     */
    PIXI.JsonLoader = function (url, crossorigin) {
        PIXI.EventTarget.call(this);

        /**
         * The url of the bitmap font data
         *
         * @property url
         * @type String
         */
        this.url = url;

        /**
         * Whether the requests should be treated as cross origin
         *
         * @property crossorigin
         * @type Boolean
         */
        this.crossorigin = crossorigin;

        /**
         * [read-only] The base url of the bitmap font data
         *
         * @property baseUrl
         * @type String
         * @readOnly
         */
        this.baseUrl = url.replace(/[^\/]*$/, '');

        /**
         * [read-only] Whether the data has loaded yet
         *
         * @property loaded
         * @type Boolean
         * @readOnly
         */
        this.loaded = false;

    };

    // constructor
    PIXI.JsonLoader.prototype.constructor = PIXI.JsonLoader;

    /**
     * Loads the JSON data
     *
     * @method load
     */
    PIXI.JsonLoader.prototype.load = function () {
        this.ajaxRequest = new PIXI.AjaxRequest();
        var scope = this;
        this.ajaxRequest.onreadystatechange = function () {
            scope.onJSONLoaded();
        };

        this.ajaxRequest.open('GET', this.url, true);
        if (this.ajaxRequest.overrideMimeType) this.ajaxRequest.overrideMimeType('application/json');
        this.ajaxRequest.send(null);
    };

    /**
     * Invoke when JSON file is loaded
     *
     * @method onJSONLoaded
     * @private
     */
    PIXI.JsonLoader.prototype.onJSONLoaded = function () {
        if (this.ajaxRequest.readyState === 4) {
            if (this.ajaxRequest.status === 200 || window.location.protocol.indexOf('http') === -1) {
                this.json = JSON.parse(this.ajaxRequest.responseText);

                if(this.json.frames)
                {
                    // sprite sheet
                    var scope = this;
                    var textureUrl = this.baseUrl + this.json.meta.image;
                    var image = new PIXI.ImageLoader(textureUrl, this.crossorigin);
                    var frameData = this.json.frames;

                    this.texture = image.texture.baseTexture;
                    image.addEventListener('loaded', function() {
                        scope.onLoaded();
                    });

                    for (var i in frameData) {
                        var rect = frameData[i].frame;
                        if (rect) {
                            PIXI.TextureCache[i] = new PIXI.Texture(this.texture, {
                                x: rect.x,
                                y: rect.y,
                                width: rect.w,
                                height: rect.h
                            });

                            // check to see ifthe sprite ha been trimmed..
                            if (frameData[i].trimmed) {

                                var texture =  PIXI.TextureCache[i];

                                texture.trimmed = true;

                                var actualSize = frameData[i].sourceSize;
                                var realSize = frameData[i].spriteSourceSize;

                                texture.trim.x = realSize.x;
                                texture.trim.y = realSize.y;
                                texture.trim.realWidth = actualSize.w;
                                texture.trim.realHeight = actualSize.h;
                            }
                        }
                    }

                    image.load();

                }
                else if(this.json.bones)
                {
                    // spine animation
                    var spineJsonParser = new spine.SkeletonJson();
                    var skeletonData = spineJsonParser.readSkeletonData(this.json);
                    PIXI.AnimCache[this.url] = skeletonData;
                    this.onLoaded();
                }
                else
                {
                    this.onLoaded();
                }
            }
            else
            {
                this.onError();
            }
        }
    };

    /**
     * Invoke when json file loaded
     *
     * @method onLoaded
     * @private
     */
    PIXI.JsonLoader.prototype.onLoaded = function () {
        this.loaded = true;
        this.dispatchEvent({
            type: 'loaded',
            content: this
        });
    };

    /**
     * Invoke when error occured
     *
     * @method onError
     * @private
     */
    PIXI.JsonLoader.prototype.onError = function () {
        this.dispatchEvent({
            type: 'error',
            content: this
        });
    };