@ekisa-web-sdk/addon-wacom-signature
Version:
Ekisa web-SDK addon: wacom-signature
1,198 lines (1,182 loc) • 121 kB
JavaScript
/* eslint-disable prefer-const */
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-unused-vars */
/* eslint-disable @typescript-eslint/no-empty-function */
/* eslint-disable @typescript-eslint/no-this-alias */
/* eslint-disable no-undef */
//==============================================================================
// wgssSigCaptX.js
// Copyright (c) 2015 Wacom Europe GmbH
//
// 01/04/2015 FRE Created
//==============================================================================
// Loosely based on https://github.com/robertodecurnex/J50Npi
export const JSONreq = {
map: {},
counter: 0,
getJSON: function (e, t, n) {
let a = e + (e.indexOf('?') + 1 ? '&' : '?'), c = document.getElementsByTagName('head')[0], s = document.createElement('script'), m = [], r = '', i = 'json-' + this.counter;
this.counter++,
(t.script_name = i),
(t._rand = Math.random()),
(this.map[i] = n),
(t.callback = 'JSONreq.success');
for (r in t)
m.push((r + '=' + encodeURIComponent(t[r])));
(a += m.join('&')),
(s.type = 'text/javascript'),
(s.src = a),
(s.id = i),
c.appendChild(s);
},
success: function (e) {
const t = e.script_name;
delete e.script_name, this.map[t](e);
const n = document.getElementsByTagName('head')[0], a = document.getElementById(t);
n.removeChild(a), delete this.map.script_name;
},
};
/*var JSONreq = {
map: {},
counter: 0,
getJSON: function(url, data, callback) {
var src = url + (url.indexOf("?")+1 ? "&" : "?");
var head = document.getElementsByTagName("head")[0];
var newScript = document.createElement("script");
var params = [];
var param_name = "";
var script_name = "json-" + this.counter;
this.counter++;
data["script_name"] = script_name;
data["_rand"] = Math.random();
this.map[script_name] = callback;
data["callback"] = "JSONreq.success";
for(param_name in data){
params.push(param_name + "=" + encodeURIComponent(data[param_name]));
}
src += params.join("&");
newScript.type = "text/javascript";
newScript.src = src;
newScript.id = script_name;
head.appendChild(newScript);
},
success: function(server_data) {
var script_name = server_data.script_name;
delete server_data.script_name;
this.map[script_name](server_data);
var head = document.getElementsByTagName("head")[0];
var the_script = document.getElementById(script_name);
head.removeChild(the_script);
delete this.map.script_name;
}
};*/
export class WacomGSS_SignatureSDK {
constructor(_onDetectRunning, service_port) {
this._onDetectRunning = _onDetectRunning;
this.service_port = service_port;
this.running = false;
this.session = null;
this.service_detected = false;
const sigsdkptr = this;
window.sdkPtr = sigsdkptr;
let server_url = 'https://localhost:';
this.RBFlags = {
//RenderOutputBinary : 2048, // Not supported in SigCaptX
//RenderOutputFilename : 4096, // Not supported in SigCaptX
RenderOutputPicture: 2097152,
RenderOutputBase64: 8192,
RenderBackgroundTransparent: 65536,
RenderColor1BPP: 131072,
RenderColor24BPP: 262144,
RenderColor32BPP: 524288,
RenderColorAntiAlias: 1048576,
RenderEncodeData: 4194304,
RenderWatermark: 8388608,
RenderClipped: 16777216,
RenderRelative: 33554432,
};
this.IntegrityStatus = {
IntegrityOK: 0,
IntegrityFail: 1,
IntegrityMissing: 2,
IntegrityWrongType: 3,
IntegrityInsufficientData: 4,
IntegrityUncertain: 5,
IntegrityUnsupported: 6,
};
this.HashType = {
HashNone: 0,
HashMD5: 1,
HashSHA1: 2,
HashSHA224: 3,
HashSHA256: 4,
HashSHA384: 5,
HashSHA512: 6,
};
this.KeyType = {
KeyNone: 0,
KeyMD5: 1,
KeyMD5MAC: 2,
KeySHA1: 3,
KeySHA224: 4,
KeySHA256: 5,
KeySHA384: 6,
KeySHA512: 7,
KeyCAPICOM: 8,
};
this.SignedData = {
DataGood: 0,
DataNoHash: 1,
DataBadType: 2,
DataBadHash: 3,
DataError: 4,
DataUncertain: 5,
DataSigMoved: 6,
};
this.CaptData = {
CaptDigitizer: 26,
CaptDigitizerDriver: 27,
CaptMachineOS: 28,
CaptNetworkCard: 29,
};
this.DynamicCaptureResult = {
DynCaptOK: 0,
DynCaptCancel: 1,
DynCaptPadError: 100,
DynCaptError: 101,
DynCaptNotLicensed: 103,
DynCaptAbort: 200,
DynCaptIntegrityKeyInvalid: 102,
};
this.TimeZone = {
TimeLocal: 0,
TimeGMT: 1,
TimeUTC: 1,
};
this.DisplayMode = {
DspForceFit: 0,
DspUseZoom: 1,
DspBestFit: 2,
};
this.ShowText = {
TxtDontShow: 0,
TxtShowLeft: 1,
TxtShowCenter: 2,
TxtShowRight: 4,
};
this.ObjectType = {
ObjectText: 0,
ObjectButton: 1,
ObjectCheckbox: 2,
ObjectSignature: 3,
ObjectInput: 4,
ObjectInputEcho: 5,
ObjectHash: 6,
ObjectImage: 7,
ObjectDisplayAtShutdown: 8,
ObjectInking: 9,
ObjectRadioButton: 10,
};
this.TextOptions = {
TextAlignLeft: 0,
TextAlignRight: 1,
TextAlignCentre: 2,
TextAlignJustify: 3,
};
this.ButtonOptions = {
BtnAlignCentre: 0,
BtnAlignMiddle: 0,
BtnAlignLeft: 1,
BtnAlignRight: 2,
BtnAlignTop: 4,
BtnAlignBottom: 8,
};
this.CheckBoxOptions = {
CheckboxUnchecked: 0,
CheckboxChecked: 1,
CheckboxDisplayTick: 2,
CheckboxDisplayCross: 4,
};
this.ObjectOptionType = {
OBJECTOPTION_STRING: 0,
OBJECTOPTION_INT: 1,
OBJECTOPTION_BOOL: 2,
};
this.VariantType = {
VARIANT_EMPTY: 0,
VARIANT_TEXT: 1,
VARIANT_NUM: 2,
VARIANT_OBJECTOPTIONS: 3,
VARIANT_SIGOBJ: 4,
VARIANT_SIGCTL: 5,
VARIANT_INPUTOBJ: 6,
VARIANT_HASH: 7,
VARIANT_IMGURL: 8,
VARIANT_BASE64: 9,
VARIANT_DYNCAP: 10,
VARIANT_WIZCTL: 11,
VARIANT_FONT: 12,
VARIANT_KEY: 13,
};
this.PrimitiveType = {
PrimitiveLine: 0,
PrimitiveRectangle: 1,
PrimitiveEllipse: 2,
};
this.PrimitiveOptions = {
PrimitiveLineSolid: 0x1,
PrimitiveLineDashed: 0x2,
PrimitiveOutline: 0x4,
PrimitiveFill: 0x8,
PrimitiveFillXOR: 0x10,
};
this.EventType = {
EvTextClicked: 0,
EvButtonClicked: 1,
EvCheckboxChecked: 2,
EvCheckboxUnchecked: 3,
EvInputMinReached: 4,
EvInputMaxReached: 5,
EvInputExceeded: 6,
};
this.EncryptAlg = {
EncryptNone: 0,
EncryptTripleDES: 1,
};
this.ResponseStatus = {
OK: 0,
FAILED: 1,
INVALID_SESSION: 3,
};
this.FontWeight = {
FW_DONTCARE: 0,
FW_THIN: 100,
FW_EXTRALIGHT: 200,
FW_LIGHT: 300,
FW_NORMAL: 400,
FW_MEDIUM: 500,
FW_SEMIBOLD: 600,
FW_BOLD: 700,
FW_EXTRABOLD: 800,
FW_HEAVY: 900,
FW_ULTRALIGHT: 200,
FW_REGULAR: 400,
FW_DEMIBOLD: 600,
FW_ULTRABOLD: 800,
FW_BLACK: 900,
};
this.FontCharset = {
ANSI_CHARSET: 0,
DEFAULT_CHARSET: 1,
SYMBOL_CHARSET: 2,
SHIFTJIS_CHARSET: 128,
HANGEUL_CHARSET: 129,
HANGUL_CHARSET: 129,
GB2312_CHARSET: 134,
CHINESEBIG5_CHARSET: 136,
OEM_CHARSET: 255,
JOHAB_CHARSET: 130,
HEBREW_CHARSET: 177,
ARABIC_CHARSET: 178,
GREEK_CHARSET: 161,
TURKISH_CHARSET: 162,
VIETNAMESE_CHARSET: 163,
THAI_CHARSET: 222,
EASTEUROPE_CHARSET: 238,
RUSSIAN_CHARSET: 204,
MAC_CHARSET: 77,
BALTIC_CHARSET: 186,
FS_LATIN1: 0x00000001,
FS_LATIN2: 0x00000002,
FS_CYRILLIC: 0x00000004,
FS_GREEK: 0x00000008,
FS_TURKISH: 0x00000010,
FS_HEBREW: 0x00000020,
FS_ARABIC: 0x00000040,
FS_BALTIC: 0x00000080,
FS_VIETNAMESE: 0x00000100,
FS_THAI: 0x00010000,
FS_JISJAPAN: 0x00020000,
FS_CHINESESIMP: 0x00040000,
FS_WANSUNG: 0x00080000,
FS_CHINESETRAD: 0x00100000,
FS_JOHAB: 0x00200000,
FS_SYMBOL: 0x80000000,
};
this.Font = function (_name, _size, _weight, _charset, _italic, _underline, _strike) {
this.type = sigsdkptr.VariantType.VARIANT_FONT;
this.fontName = typeof _name == 'undefined' ? 'Arial' : _name;
this.fontSize = typeof _size == 'undefined' ? 8 : _size;
this.sWeight =
typeof _weight == 'undefined'
? sigsdkptr.FontWeight.FW_NORMAL
: _weight;
this.sCharset =
typeof _charset == 'undefined'
? sigsdkptr.FontCharset.ANSI_CHARSET
: _charset;
this.fItalic = typeof _italic == 'undefined' ? 0 : _italic;
this.fUnderline = typeof _underline == 'undefined' ? 0 : _underline;
this.fStrikethrough = typeof _strike == 'undefined' ? 0 : _strike;
};
this.keepAlive = function () {
const data = {
session: sigsdkptr.session,
KeepAlive: 1,
};
JSONreq.getJSON(server_url + 'wacom.js', data, function () { });
setTimeout(sigsdkptr.keepAlive, 2000);
};
function onGetSession(server_data) {
if (0 == server_data.status) {
sigsdkptr.session = server_data.session;
sigsdkptr.running = true;
_onDetectRunning();
setTimeout(sigsdkptr.keepAlive, 2000);
}
else {
console.log('Signature SDK local server error: ' + server_data.status);
}
}
function onGetPort(server_data) {
if (0 == server_data.status) {
sigsdkptr.service_detected = true;
server_url += server_data.port + '/';
const data = {
CreateSession: 1,
};
JSONreq.getJSON(server_url + 'wacom.js', data, onGetSession);
}
else {
console.log('Signature SDK Service error: ' + server_data.status);
}
}
function destroySession() {
if (sigsdkptr.session != 0) {
const u = server_url +
'wacom.js' +
'?DestroySession=1&session=' +
sigsdkptr.session;
sigsdkptr.session = 0;
if (self.Navigator.sendBeacon != undefined) {
self.Navigator.sendBeacon(u);
}
else {
const r = new XMLHttpRequest();
r.open('GET', u, false); // synchronous
r.send(null);
}
}
}
window.addEventListener('unload', function (event) {
destroySession();
});
function checkService() {
const data = { GetPort: 1 };
JSONreq.getJSON(server_url + service_port + '/wacom.js', data, onGetPort);
}
checkService();
this.getVersion = function (_onGetVersion) {
const data = {
GetVersion: 1,
session: sigsdkptr.session,
};
function callback(server_data) {
_onGetVersion(
/*thisptr,*/ server_data.version, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
function checkVar(input) {
return 'undefined' == typeof input || null == input ? '' : input;
}
this.Hash = function (_onHash) {
const thisptr = this;
this.handle = null;
this.type = sigsdkptr.VariantType.VARIANT_HASH;
const data = {
Hash: 'Constructor',
session: sigsdkptr.session,
};
function callback(server_data) {
thisptr.handle = server_data.handle;
_onHash(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
// hData is a sigsdkptr.Variant
this.Add = function (hData, _onAdd) {
const data = {
Hash: 'Add',
session: sigsdkptr.session,
handle: thisptr.handle,
};
hData.Stringify(data, 'hData');
function callback(server_data) {
_onAdd(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.Clear = function (_onClear) {
const data = {
Hash: 'Clear',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
_onClear(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.GetType = function (_onGetType) {
const data = {
Hash: 'GetType',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
// server_data.type type is sigsdkptr.HashType
_onGetType(thisptr, parseInt(server_data.hashType), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// type is sigsdkptr.HashType
this.PutType = function (type, _onPutType) {
const data = {
Hash: 'PutType',
session: sigsdkptr.session,
handle: thisptr.handle,
type: checkVar(type),
};
function callback(server_data) {
_onPutType(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
};
this.Key = function (_onKey) {
const thisptr = this;
this.handle = null;
this.type = sigsdkptr.VariantType.VARIANT_KEY;
const data = {
Key: 'Constructor',
session: sigsdkptr.session,
};
function callback(server_data) {
thisptr.handle = server_data.handle;
_onKey(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
this.GetType = function (_onGetType) {
const data = {
Key: 'GetType',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
// server_data.type type is sigsdkptr.KeyType
_onGetType(thisptr, parseInt(server_data.type), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// type is sigsdkptr.KeyType
// value is sigsdkptr.Variant
this.Set = function (type, value, _onSet) {
const data = {
Key: 'Set',
session: sigsdkptr.session,
handle: thisptr.handle,
type: checkVar(type),
};
value.Stringify(data, 'value');
function callback(server_data) {
_onSet(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
};
this.Bitmap = function () {
const thisptr = this;
this.handle = null;
this.isBase64 = false;
this.mime_type = null;
this.image = new Image();
};
this.SigObj = function () {
const thisptr = this;
this.handle = null;
this.type = sigsdkptr.VariantType.VARIANT_SIGOBJ;
// key is sigsdkptr.Key
this.CheckIntegrity = function (key, _onCheckIntegrity) {
const data = {
SigObj: 'CheckIntegrity',
session: sigsdkptr.session,
handle: thisptr.handle,
};
const vKey = new sigsdkptr.Variant();
vKey.Set(key);
vKey.Stringify(data, 'key');
function callback(server_data) {
//server_data.status type is sigsdkptr.IntegrityStatus
_onCheckIntegrity(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// hash type is sigsdkptr.Hash
this.CheckSignedData = function (hash, _onCheckSignedData) {
const data = {
SigObj: 'CheckSignedData',
session: sigsdkptr.session,
handle: thisptr.handle,
HashHandle: checkVar(hash.handle),
};
function callback(server_data) {
//server_data.status type is sigsdkptr.SignedData
_onCheckSignedData(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.Clear = function (_onClear) {
const data = {
SigObj: 'Clear',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
_onClear(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// captData type is sigsdkptr.CaptData
this.GetAdditionalData = function (captData, _onGetAdditionalData) {
const data = {
SigObj: 'GetAdditionalData',
session: sigsdkptr.session,
handle: thisptr.handle,
captData: checkVar(captData),
};
function callback(server_data) {
//server_data.additionalData is a string
_onGetAdditionalData(thisptr, server_data.additionalData, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.GetCrossedOut = function (_onGetCrossedOut) {
const data = {
SigObj: 'GetCrossedOut',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
//server_data.crossedOut is a bool
_onGetCrossedOut(thisptr, Boolean(1 == parseInt(server_data.crossedOut)), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// key is a string
this.GetExtraData = function (key, _onGetExtraData) {
const data = {
SigObj: 'GetExtraData',
session: sigsdkptr.session,
handle: thisptr.handle,
key: checkVar(key),
};
function callback(server_data) {
//server_data.extraData is a string
_onGetExtraData(thisptr, server_data.extraData, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.GetHeight = function (_onGetHeight) {
const data = {
SigObj: 'GetHeight',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
//server_data.height is a number
_onGetHeight(thisptr, parseInt(server_data.height), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.GetInk = function (_onGetInk) {
const data = {
SigObj: 'GetInk',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
//server_data.ink is a string
_onGetInk(thisptr, server_data.ink, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.GetIsCaptured = function (_onGetIsCaptured) {
const data = {
SigObj: 'GetIsCaptured',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
//server_data.isCaptured is a bool
_onGetIsCaptured(thisptr, Boolean(1 == parseInt(server_data.isCaptured)), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// key is a string
this.GetProperty = function (key, _onGetProperty) {
const data = {
SigObj: 'GetProperty',
session: sigsdkptr.session,
handle: thisptr.handle,
key: checkVar(key),
};
function callback(server_data) {
const property = new sigsdkptr.Variant();
property.Parse(server_data, 'property');
_onGetProperty(thisptr, property, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.GetSigData = function (_onGetSigData) {
const data = {
SigObj: 'GetSigData',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
//server_data.sigData is a sigsdkptr.Variant (if it's a VARIANT_TEXT, it's Base64 encoded)
const sigData = new sigsdkptr.Variant();
sigData.Parse(server_data, 'sigData');
_onGetSigData(thisptr, sigData, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.GetSigText = function (_onGetSigText) {
const data = {
SigObj: 'GetSigText',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
//server_data.sigText is a string
_onGetSigText(thisptr, server_data.sigText, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
//timeZone is a sigsdkptr.TimeZone
this.GetWhen = function (timeZone, _onGetWhen) {
const data = {
SigObj: 'GetWhen',
session: sigsdkptr.session,
handle: thisptr.handle,
timeZone: checkVar(timeZone),
};
function callback(server_data) {
//server_data.when is a date
const date = new Date(parseFloat(server_data.year), parseFloat(server_data.month) - 1, parseFloat(server_data.day), parseFloat(server_data.hour), parseFloat(server_data.minute), parseFloat(server_data.second));
date.dayOfWeek = parseFloat(server_data.dayOfWeek);
_onGetWhen(thisptr, date, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.GetWho = function (_onGetWho) {
const data = {
SigObj: 'GetWho',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
//server_data.who is a string
_onGetWho(thisptr, server_data.who, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.GetWhy = function (_onGetWhy) {
const data = {
SigObj: 'GetWhy',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
//server_data.why is a string
_onGetWhy(thisptr, server_data.why, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.GetWidth = function (_onGetWidth) {
const data = {
SigObj: 'GetWidth',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
//server_data.width is a number
_onGetWidth(thisptr, parseInt(server_data.width), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// key is a string
// value is a string
this.PutExtraData = function (key, value, _onPutExtraData) {
const data = {
SigObj: 'PutExtraData',
session: sigsdkptr.session,
handle: thisptr.handle,
key: checkVar(key),
value: checkVar(value),
};
function callback(server_data) {
_onPutExtraData(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// ink is a string
this.PutInk = function (ink, _onPutInk) {
const data = {
SigObj: 'PutInk',
session: sigsdkptr.session,
handle: thisptr.handle,
ink: checkVar(ink),
};
function callback(server_data) {
_onPutInk(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// sigData type is sigsdkptr.Variant
this.PutSigData = function (sigData, _onPutSigData) {
const data = {
SigObj: 'PutSigData',
session: sigsdkptr.session,
handle: thisptr.handle,
};
sigData.Stringify(data, 'sigData');
function callback(server_data) {
_onPutSigData(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// sigText is a string
this.PutSigText = function (sigText, _onPutSigText) {
const data = {
SigObj: 'PutSigText',
session: sigsdkptr.session,
handle: thisptr.handle,
sigText: checkVar(sigText),
};
function callback(server_data) {
_onPutSigText(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// bitmapURL type is a url
this.ReadEncodedBitmap = function (bitmapURL, _onReadEncodedBitmap) {
const data = {
SigObj: 'ReadEncodedBitmap',
session: sigsdkptr.session,
handle: thisptr.handle,
};
const vBmpUrl = new sigsdkptr.Variant();
vBmpUrl.type = sigsdkptr.VariantType.VARIANT_IMGURL;
vBmpUrl.url = bitmapURL;
vBmpUrl.Stringify(data, 'bitmapURL');
function callback(server_data) {
_onReadEncodedBitmap(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// mime_type type is a string
// width is an integer
// height is an integer
// ink_width is a real
// ink_color is an OLE_COLOR number
// background_color is an OLE_COLOR number
// flags is a sigsdkptr.RBFlags
// paddingX is a real
// paddingY is a real
this.RenderBitmap = function (mime_type, width, height, ink_width, ink_color, background_color, flags, paddingX, paddingY, _onRenderBitmap) {
const data = {
SigObj: 'RenderBitmap',
session: sigsdkptr.session,
handle: thisptr.handle,
mimetype: checkVar(mime_type),
width: checkVar(width),
height: checkVar(height),
ink_width: checkVar(ink_width),
ink_color: checkVar(ink_color),
bg_color: checkVar(background_color),
flags: checkVar(flags),
paddingX: checkVar(paddingX),
paddingY: checkVar(paddingY),
};
function callback(server_data) {
// eslint-disable-next-line no-debugger
const status = parseInt(server_data.status);
if (status == 0) {
if (flags & sigsdkptr.RBFlags.RenderOutputPicture) {
const s = sigsdkptr;
const bmp = new s.Bitmap();
bmp.handle = server_data.bitmapHandle;
bmp.isBase64 = 1 == server_data.isBase64 ? true : false;
bmp.image.onload = function () {
_onRenderBitmap(thisptr, bmp, status);
};
if (bmp.isBase64) {
bmp.image.src =
'data:image/' + mime_type + ';base64,' + server_data.base64;
}
else {
bmp.image.src =
server_url +
server_data.bitmapHandle +
'?session=' +
sigsdkptr.session;
}
}
else if (1 == server_data.isBase64) {
_onRenderBitmap(thisptr, server_data.base64, status);
}
}
else {
_onRenderBitmap(thisptr, null, status);
}
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// key is a string
// value is a sigsdkptr.Variant
this.SetProperty = function (key, value, _onSetProperty) {
const data = {
SigObj: 'SetProperty',
session: sigsdkptr.session,
handle: thisptr.handle,
key: checkVar(key),
};
value.Stringify(data, 'value');
function callback(server_data) {
_onSetProperty(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
};
this.DynamicCapture = function (_onConstructor) {
const thisptr = this;
this.handle = null;
const data = {
DynamicCapture: 'Constructor',
session: sigsdkptr.session,
};
function callback(server_data) {
thisptr.handle = server_data.handle;
_onConstructor(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
// sigCtl is a sigsdkptr.SigCtl
// who is a string
// why is a string
// what is a sigsdkptr.Hash
// key is a sigsdkptr.Key
this.Capture = function (sigCtl, who, why, what, key, _onCapture) {
const width = window.innerWidth ||
document.documentElement.clientWidth ||
document.body.clientWidth;
const height = window.innerHeight ||
document.documentElement.clientHeight ||
document.body.clientHeight;
const left = window.screenLeft ? window.screenLeft : window.screenX;
const top = window.screenTop ? window.screenTop : window.screenY;
const data = {
DynamicCapture: 'Capture',
session: sigsdkptr.session,
who: checkVar(who),
why: checkVar(why),
width: checkVar(width),
height: checkVar(height),
left: checkVar(left),
top: checkVar(top),
SigCtlHandle: checkVar(sigCtl.handle),
handle: thisptr.handle,
};
const vWhat = new sigsdkptr.Variant();
vWhat.Set(what);
vWhat.Stringify(data, 'what');
const vKey = new sigsdkptr.Variant();
vKey.Set(key);
vKey.Stringify(data, 'key');
function callback(server_data) {
const s = sigsdkptr;
const sigObj = new s.SigObj();
sigObj.handle = server_data.handle;
//server_data.status type is sigsdkptr.DynamicCaptureResult
_onCapture(thisptr, sigObj, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
this.GetLicence = function (_onGetLicence) {
const data = {
DynamicCapture: 'GetLicence',
session: sigsdkptr.session,
handle: thisptr.handle,
};
function callback(server_data) {
//server_data.licence type is string
_onGetLicence(thisptr, server_data.licence, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// key type is string
this.GetProperty = function (key, _onGetProperty) {
const data = {
DynamicCapture: 'GetProperty',
session: sigsdkptr.session,
handle: thisptr.handle,
key: checkVar(key),
};
function callback(server_data) {
const property = new sigsdkptr.Variant();
property.Parse(server_data, 'property');
_onGetProperty(thisptr, property, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// licence type is string
this.PutLicence = function (licence, _onPutLicence) {
const data = {
DynamicCapture: 'PutLicence',
session: sigsdkptr.session,
handle: thisptr.handle,
licence: checkVar(licence),
};
function callback(server_data) {
_onPutLicence(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
// key type is string
// value type is sigsdkptr.Variant
this.SetProperty = function (key, value, _onSetProperty) {
const data = {
DynamicCapture: 'SetProperty',
session: sigsdkptr.session,
handle: thisptr.handle,
key: checkVar(key),
};
value.Stringify(data, 'value');
function callback(server_data) {
_onSetProperty(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
};
this.SigCtl = function (_onConstructor) {
const thisptr = this;
this.handle = null;
this.type = sigsdkptr.VariantType.VARIANT_SIGCTL;
const data = {
SigCtl: 'Constructor',
session: sigsdkptr.session,
};
function callback(server_data) {
thisptr.handle = server_data.handle;
_onConstructor(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
this.AboutBox = function (_onAboutBox) {
const width = window.innerWidth ||
document.documentElement.clientWidth ||
document.body.clientWidth;
const height = window.innerHeight ||
document.documentElement.clientHeight ||
document.body.clientHeight;
const left = window.screenLeft ? window.screenLeft : window.screenX;
const top = window.screenTop ? window.screenTop : window.screenY;
const data = {
SigCtl: 'AboutBox',
session: sigsdkptr.session,
width: checkVar(width),
height: checkVar(height),
left: checkVar(left),
top: checkVar(top),
handle: thisptr.handle,
};
function callback(server_data) {
_onAboutBox(thisptr, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
//key is a string
this.GetAppData = function (key, _onGetAppData) {
const data = {
SigCtl: 'GetAppData',
session: sigsdkptr.session,
handle: thisptr.handle,
key: checkVar(key),
};
function callback(server_data) {
const appData = new sigsdkptr.Variant();
appData.Parse(server_data, 'appData');
_onGetAppData(thisptr, appData, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + 'wacom.js', data, callback);
};
/*
this.GetBackColor = function(_onGetBackColor)
{
var data = {
"SigCtl": "GetBackColor",
"session": sigsdkptr.session,
"handle": thisptr.handle
};
function callback(server_data)
{
//server_data.appData is an OLE_COLOR (number)
_onGetBackColor(thisptr, parseInt(server_data.backColor), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + "wacom.js", data, callback);
}
this.GetBackStyle = function(_onGetBackStyle)
{
var data = {
"SigCtl": "GetBackStyle",
"session": sigsdkptr.session,
"handle": thisptr.handle
};
function callback(server_data)
{
//server_data.backStyle is a number
_onGetBackStyle(thisptr, parseInt(server_data.backStyle), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + "wacom.js", data, callback);
}
this.GetBorderColor = function(_onGetBorderColor)
{
var data = {
"SigCtl": "GetBorderColor",
"session": sigsdkptr.session,
"handle": thisptr.handle
};
function callback(server_data)
{
//server_data.borderColor is an OLE_COLOR (number)
_onGetBorderColor(thisptr, parseInt(server_data.borderColor), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + "wacom.js", data, callback);
}
this.GetBorderStyle = function(_onGetBorderStyle)
{
var data = {
"SigCtl": "GetBorderStyle",
"session": sigsdkptr.session,
"handle": thisptr.handle
};
function callback(server_data)
{
//server_data.borderStyle is a number
_onGetBorderStyle(thisptr, parseInt(server_data.borderStyle), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + "wacom.js", data, callback);
}
this.GetBorderVisible = function(_onGetBorderVisible)
{
var data = {
"SigCtl": "GetBorderVisible",
"session": sigsdkptr.session,
"handle": thisptr.handle
};
function callback(server_data)
{
//server_data.borderVisible is a bool
_onGetBorderVisible(thisptr, Boolean(1 == parseInt(server_data.borderVisible)), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + "wacom.js", data, callback);
}
this.GetBorderWidth = function(_onGetBorderWidth)
{
var data = {
"SigCtl": "GetBorderWidth",
"session": sigsdkptr.session,
"handle": thisptr.handle
};
function callback(server_data)
{
//server_data.borderWidth is a number
_onGetBorderWidth(thisptr, parseInt(server_data.borderWidth), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + "wacom.js", data, callback);
}
this.GetCaption = function(_onGetCaption)
{
var data = {
"SigCtl": "GetCaption",
"session": sigsdkptr.session,
"handle": thisptr.handle
};
function callback(server_data)
{
//server_data.caption is a string
_onGetCaption(thisptr, server_data.caption, parseInt(server_data.status));
}
JSONreq.getJSON(server_url + "wacom.js", data, callback);
}
this.GetCtlPadding = function(_onGetCtlPadding)
{
var data = {
"SigCtl": "GetCtlPadding",
"session": sigsdkptr.session,
"handle": thisptr.handle
};
function callback(server_data)
{
//server_data.ctlPadding is a number
_onGetCtlPadding(thisptr, parseInt(server_data.ctlPadding), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + "wacom.js", data, callback);
}
this.GetDisplayMode = function(_onGetDisplayMode)
{
var data = {
"SigCtl": "GetDisplayMode",
"session": sigsdkptr.session,
"handle": thisptr.handle
};
function callback(server_data)
{
//server_data.displayMode is a sigsdkptr.DisplayMode
_onGetDisplayMode(thisptr, parseInt(server_data.displayMode), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + "wacom.js", data, callback);
}
this.GetEnabled = function(_onGetEnabled)
{
var data = {
"SigCtl": "GetEnabled",
"session": sigsdkptr.session,
"handle": thisptr.handle
};
function callback(server_data)
{
//server_data.enabled is a bool
_onGetEnabled(thisptr, Boolean(1 == parseInt(server_data.enabled)), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + "wacom.js", data, callback);
}
this.GetForeColor = function(_onGetForeColor)
{
var data = {
"SigCtl": "GetForeColor",
"session": sigsdkptr.session,
"handle": thisptr.handle
};
function callback(server_data)
{
//server_data.foreColor is an OLE_COLOR (number)
_onGetForeColor(thisptr, parseInt(server_data.foreColor), parseInt(server_data.status));
}
JSONreq.getJSON(server_url + "wacom.js", data, callback);
}
this.GetInkColor = function(_onGetInkColor)
{
var data = {
"SigCtl": "GetInkColor",
"session": sigsdkptr.session,
"handle": thisptr.handle