var fontObj = this.objs.get(fontRefName).fontObj;
if (!fontObj) {
- throw 'Can\'t find font for ' + fontRefName;
+ error('Can\'t find font for ' + fontRefName);
}
var name = fontObj.loadedName || 'sans-serif';
} else if (IR[0] == 'RadialAxial' || IR[0] == 'Dummy') {
var pattern = Pattern.shadingFromIR(this.ctx, IR);
} else {
- throw 'Unkown IR type';
+ error('Unkown IR type ' + IR[0]);
}
return pattern;
},
if (callback)
callback(e);
else
- throw e;
+ error(e);
}
}.bind(this),
function pageDisplayReadPromiseError(reason) {
if (callback)
callback(reason);
else
- throw reason;
+ error(reason);
}
);
}
if (!globalScope.PDFJS.disableWorker && typeof Worker !== 'undefined') {
var workerSrc = PDFJS.workerSrc;
if (typeof workerSrc === 'undefined') {
- throw 'No PDFJS.workerSrc specified';
+ error('No PDFJS.workerSrc specified');
}
try {
});
break;
default:
- throw 'Got unkown object type ' + type;
+ error('Got unkown object type ' + type);
}
}, this);
if (page.displayReadyPromise)
page.displayReadyPromise.reject(data.error);
else
- throw data.error;
+ error(data.error);
}, this);
messageHandler.on('jpeg_decode', function(data, promise) {
}
r = 0;
}
- throw 'Out of packets';
+ error('Out of packets');
};
}
function ResolutionLayerComponentPositionIterator(context) {
}
l = 0;
}
- throw 'Out of packets';
+ error('Out of packets');
};
}
function buildPackets(context) {
new ResolutionLayerComponentPositionIterator(context);
break;
default:
- throw 'Unsupported progression order';
+ error('Unsupported progression order ' + progressionOrder);
}
}
function parseTilePackets(context, data, offset, dataLength) {
if (lbox == 0)
lbox = length - position + headerSize;
if (lbox < headerSize)
- throw 'Invalid box field size';
+ error('Invalid box field size');
var dataLength = lbox - headerSize;
var jumpDataLength = true;
switch (tbox) {
scalarExpounded = true;
break;
default:
- throw 'Invalid SQcd value';
+ error('Invalid SQcd value ' + sqcd);
}
qcd.noQuantization = spqcdSize == 8;
qcd.scalarExpounded = scalarExpounded;
scalarExpounded = true;
break;
default:
- throw 'Invalid SQcd value';
+ error('Invalid SQcd value ' + sqcd);
}
qcc.noQuantization = spqcdSize == 8;
qcc.scalarExpounded = scalarExpounded;
cod.terminationOnEachCodingPass ||
cod.verticalyStripe || cod.predictableTermination ||
cod.segmentationSymbolUsed)
- throw 'Unsupported COD options: ' + uneval(cod);
+ error('Unsupported COD options: ' + uneval(cod));
if (context.mainHeader)
context.COD = cod;
// skipping content
break;
default:
- throw 'Unknown codestream code: ' + code.toString(16);
+ error('Unknown codestream code: ' + code.toString(16));
}
position += length;
}
var stream, parser;
if (e.uncompressed) {
if (e.gen != gen)
- throw ('inconsistent generation in XRef');
+ error('inconsistent generation in XRef');
stream = this.stream.makeSubStream(e.offset);
parser = new Parser(new Lexer(stream), true, this);
var obj1 = parser.getObj();
// If there isn't an object yet or the object isn't resolved, then the
// data isn't ready yet!
if (!obj || !obj.isResolved) {
- throw 'Requesting object that isn\'t resolved yet ' + objId;
+ error('Requesting object that isn\'t resolved yet ' + objId);
return null;
} else {
return obj.data;
JpegStream.prototype.ensureBuffer = function jpegStreamEnsureBuffer(req) {
if (this.bufferLength)
return;
- var jpegImage = new JpegImage();
- if (this.colorTransform != -1)
- jpegImage.colorTransform = this.colorTransform;
- jpegImage.parse(this.bytes);
- var width = jpegImage.width;
- var height = jpegImage.height;
- var data = jpegImage.getData(width, height);
- this.buffer = data;
- this.bufferLength = data.length;
+ try {
+ var jpegImage = new JpegImage();
+ if (this.colorTransform != -1)
+ jpegImage.colorTransform = this.colorTransform;
+ jpegImage.parse(this.bytes);
+ var width = jpegImage.width;
+ var height = jpegImage.height;
+ var data = jpegImage.getData(width, height);
+ this.buffer = data;
+ this.bufferLength = data.length;
+ } catch (e) {
+ error(e);
+ }
};
JpegStream.prototype.getIR = function jpegStreamGetIR() {
return bytesToString(this.bytes);
return;
}
if (this._data !== EMPTY_PROMISE) {
- throw 'Promise ' + this.name +
- ': Cannot set the data of a promise twice';
+ error('Promise ' + this.name +
+ ': Cannot set the data of a promise twice');
}
this._data = value;
this.hasData = true;
get data() {
if (this._data === EMPTY_PROMISE) {
- throw 'Promise ' + this.name + ': Cannot get data that isn\'t set';
+ error('Promise ' + this.name + ': Cannot get data that isn\'t set');
}
return this._data;
},
resolve: function promiseResolve(data) {
if (this.isResolved) {
- throw 'A Promise can be resolved only once ' + this.name;
+ error('A Promise can be resolved only once ' + this.name);
}
if (this.isRejected) {
- throw 'The Promise was already rejected ' + this.name;
+ error('The Promise was already rejected ' + this.name);
}
this.isResolved = true;
reject: function proimseReject(reason) {
if (this.isRejected) {
- throw 'A Promise can be rejected only once ' + this.name;
+ error('A Promise can be rejected only once ' + this.name);
}
if (this.isResolved) {
- throw 'The Promise was already resolved ' + this.name;
+ error('The Promise was already resolved ' + this.name);
}
this.isRejected = true;
then: function promiseThen(callback, errback) {
if (!callback) {
- throw 'Requiring callback' + this.name;
+ error('Requiring callback' + this.name);
}
// If the promise is already resolved, call the callback directly.
delete callbacks[callbackId];
callback(data.data);
} else {
- throw 'Cannot resolve callback ' + callbackId;
+ error('Cannot resolve callback ' + callbackId);
}
} else if (data.action in ah) {
var action = ah[data.action];
action[0].call(action[1], data.data);
}
} else {
- throw 'Unkown action from worker: ' + data.action;
+ error('Unkown action from worker: ' + data.action);
}
};
}
on: function messageHandlerOn(actionName, handler, scope) {
var ah = this.actionHandler;
if (ah[actionName]) {
- throw 'There is already an actionName called "' + actionName + '"';
+ error('There is already an actionName called "' + actionName + '"');
}
ah[actionName] = [handler, scope];
},
timeEnd: function timeEnd(name) {
var time = consoleTimer[name];
if (time == null) {
- throw 'Unkown timer name ' + name;
+ error('Unkown timer name ' + name);
}
this.log('Timer:', name, Date.now() - time);
}
projects / pdf.js.git / commitdiff