Create Xzing

[skimtiyaz]

/**

• Copyright 2016 Boris Seang
• Licensed under the Apache License, Version 2.0 (the "License");
• you may not use this file except in compliance with the License.
• You may obtain a copy of the License at

•  http://www.apache.org/licenses/LICENSE-2.0
  

• Unless required by applicable law or agreed to in writing, software
• distributed under the License is distributed on an "AS IS" BASIS,
• WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
• See the License for the specific language governing permissions and
• limitations under the License.
  */

zxing = {
version: "0.0.1"
};

// Most utilities from Leaflet, BSD license.
zxing.Util = {
// extend an object with properties of one or more other objects
extend: function (dest) {
var i, j, len, src;

    for (j = 1, len = arguments.length; j < len; j++) {
        src = arguments[j];
        for (i in src) {
            dest[i] = src[i];
        }
    }
    return dest;
},

// create an object from a given prototype
create: Object.create || (function () {
    function F() {}
    return function (proto) {
        F.prototype = proto;
        return new F();
    };
})(),

// bind a function to be called with a given context
bind: function (fn, obj) {
    var slice = Array.prototype.slice;

    if (fn.bind) {
        return fn.bind.apply(fn, slice.call(arguments, 1));
    }

    var args = slice.call(arguments, 2);

    return function () {
        return fn.apply(obj, args.length ? args.concat(slice.call(arguments)) : arguments);
    };
}

};

// shortcuts for most used utility functions
zxing.extend = zxing.Util.extend;
zxing.bind = zxing.Util.bind;

/*

• zxing.Class powers the OOP facilities of the library.
  */

zxing.Class = function () {};

zxing.Class.extend = function (props) {

// extended class with the new prototype
var NewClass = function () {

    // call the constructor
    if (this.initialize) {
        this.initialize.apply(this, arguments);
    }

    // call all constructor hooks
    this.callInitHooks();
};

var parentProto = NewClass.__super__ = this.prototype;

var proto = zxing.Util.create(parentProto);
proto.constructor = NewClass;

NewClass.prototype = proto;

// inherit parent's statics
for (var i in this) {
    if (this.hasOwnProperty(i) && i !== "prototype") {
        NewClass[i] = this[i];
    }
}

// mix static properties into the class
if (props.statics) {
    zxing.extend(NewClass, props.statics);
    delete props.statics;
}

// mix includes into the prototype
if (props.includes) {
    zxing.extend.apply(null, [proto].concat(props.includes));
    delete props.includes;
}

// merge options
if (proto.options) {
    props.options = zxing.extend(zxing.Util.create(proto.options), props.options);
}

// mix given properties into the prototype
zxing.extend(proto, props);

proto._initHooks = [];

// add method for calling all hooks
proto.callInitHooks = function () {

    if (this._initHooksCalled) { return; }

    if (parentProto.callInitHooks) {
        parentProto.callInitHooks.call(this);
    }

    this._initHooksCalled = true;

    for (var i = 0, len = proto._initHooks.length; i < len; i++) {
        proto._initHooks[i].call(this);
    }
};

return NewClass;

};

zxing.decode = function (canvas, options) {

};

zxing._getLuminance = function () {

};