libey-ng-component-library 0.0.32 → 0.0.34

package/src/utils/SigWeb/SigWeb.ts

@@ -0,0 +1,1906 @@
+// SigWebTablet.ts
+export class SigWebTablet {
+  private static revokeBlobURL(url: string): void {
+    if (window.URL) {
+      URL.revokeObjectURL(url);
+    } else if (window.webkitURL) {
+      webkitURL.revokeObjectURL(url);
+    }
+  }
+  private static getBlobURL(blob: Blob): string {
+    if (window.URL) {
+      return URL.createObjectURL(blob);
+    } else if (window.webkitURL) {
+      return webkitURL.createObjectURL(blob);
+    }
+    return ''; // Retornar un string vacío en caso de error
+  }
+
+  private static baseUri: string = SigWebTablet.makeUri();
+  private static ctx;
+  private static Count: boolean = false;
+  private static EvStatus;
+  private static onSigPenDown;
+  private static onSigPenUp;
+  private static SigWebFontThreshold = 155;
+  private static NumPointsLastTime = 0;
+  private static SigImageB64;
+
+  private static makeUri(): string {
+    var prot = location.protocol;
+    if (prot == 'file:') {
+      prot = 'http:';
+    }
+
+    if (this.isIE()) {
+      if (prot == 'https:') {
+        return prot + '//tablet.sigwebtablet.com:47290/SigWeb/';
+      } else {
+        return prot + '//tablet.sigwebtablet.com:47289/SigWeb/';
+      }
+    }
+
+    if (this.isChrome()) {
+      if (prot == 'https:') {
+        return prot + '//tablet.sigwebtablet.com:47290/SigWeb/';
+      } else {
+        return prot + '//tablet.sigwebtablet.com:47289/SigWeb/';
+      }
+    } else {
+      //FIREFOX
+      if (prot == 'https:') {
+        return prot + '//tablet.sigwebtablet.com:47290/SigWeb/';
+      } else {
+        return prot + '//tablet.sigwebtablet.com:47289/SigWeb/';
+      }
+    }
+  }
+
+  private static generateUUID(): string {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(
+      /[xy]/g,
+      function (c) {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+      }
+    );
+  }
+
+  static isSigWebInstalled(): boolean {
+    const xhr = new XMLHttpRequest();
+    try {
+      xhr.open(
+        'GET',
+        `${this.baseUri}TabletState?noCache=${this.generateUUID()}`,
+        false
+      );
+      xhr.send();
+      return xhr.status !== 404 && xhr.status !== 0;
+    } catch (e) {
+      console.log('Error checking SigWeb installation', e);
+      return false;
+    }
+  }
+
+  static isIE(): boolean {
+    return (
+      navigator.appName === 'Microsoft Internet Explorer' ||
+      (navigator.appName === 'Netscape' &&
+        new RegExp('Trident/.*rv:([0-9]{1,}[.0-9]{0,})').exec(
+          navigator.userAgent
+        ) != null)
+    );
+  }
+
+  static isChrome(): boolean {
+    return navigator.userAgent.lastIndexOf('Chrome/') > 0;
+  }
+
+  static SigWebcreateXHR(): XMLHttpRequest | null {
+    const xhr = new XMLHttpRequest();
+    if (!xhr) {
+      throw new Error('No se pudo crear XMLHttpRequest');
+    }
+
+    return xhr;
+  }
+
+  static SigWebSetProperty(prop: string): string {
+    const xhr: XMLHttpRequest | null = this.SigWebcreateXHR();
+
+    if (xhr) {
+      xhr.open('POST', this.baseUri + prop, true);
+      xhr.send(null);
+      if (xhr.readyState === 4 && xhr.status === 200) {
+        return xhr.responseText;
+      }
+    }
+    return '';
+  }
+
+  static SigWebSetPropertySync(prop: string): string {
+    const xhr: XMLHttpRequest | null = this.SigWebcreateXHR();
+
+    if (xhr) {
+      xhr.open('POST', this.baseUri + prop, false);
+      xhr.send();
+      if (xhr.readyState === 4 && xhr.status === 200) {
+        return xhr.responseText;
+      }
+    }
+    return '';
+  }
+
+  static SigWebSetStreamProperty(prop: string, strm: any): string {
+    const xhr: XMLHttpRequest | null = this.SigWebcreateXHR();
+
+    if (xhr) {
+      xhr.open('POST', this.baseUri + prop);
+      xhr.setRequestHeader('Content-Type', 'text/plain');
+      xhr.send(strm);
+    }
+    return '';
+  }
+
+  static SigWebSyncSetStreamProperty(prop: string, strm: any): string {
+    const xhr: XMLHttpRequest | null = this.SigWebcreateXHR();
+
+    if (xhr) {
+      xhr.open('POST', this.baseUri + prop, false);
+      xhr.setRequestHeader('Content-Type', 'text/plain');
+      xhr.send(strm);
+      if (xhr.readyState === 4 && xhr.status === 200) {
+        return xhr.responseText;
+      }
+    }
+    return '';
+  }
+
+  static SigWebSetImageStreamProperty(prop: string, strm: any): string {
+    const xhr: XMLHttpRequest | null = this.SigWebcreateXHR();
+
+    if (xhr) {
+      xhr.open('POST', this.baseUri + prop, false);
+      xhr.setRequestHeader('Content-Type', 'image/png');
+      xhr.send(strm);
+      if (xhr.readyState === 4 && xhr.status === 200) {
+        return xhr.responseText;
+      }
+    }
+    return '';
+  }
+
+  static SigWebSetImageBlobProperty(prop, strm) {
+    var xhr = this.SigWebcreateXHR();
+    if (xhr) {
+      xhr.open('POST', this.baseUri + prop, false);
+      xhr.setRequestHeader('Content-Type', 'blob');
+      xhr.send(strm);
+      if (xhr.readyState == 4 && xhr.status == 200) {
+        return xhr.responseText;
+      }
+    }
+    return '';
+  }
+
+  static SigWebGetVersion(prop) {
+    try {
+      var xhr = this.SigWebcreateXHR();
+      if (xhr) {
+        xhr.open(
+          'GET',
+          this.baseUri + prop + '?noCache=' + this.generateUUID(),
+          false
+        );
+        xhr.send(null);
+        if (xhr.readyState == 4 && xhr.status == 200) {
+          return xhr.responseText;
+        }
+      }
+    } catch (error) {
+      console.error('Error en SigWebGetVersion:', error);
+      return null;
+    }
+    return null;
+  }
+
+  static SigWebGetProperty(prop) {
+    var xhr = this.SigWebcreateXHR();
+
+    if (xhr) {
+      xhr.open(
+        'GET',
+        this.baseUri + prop + '?noCache=' + this.generateUUID(),
+        false
+      );
+      xhr.send(null);
+      if (xhr.readyState == 4 && xhr.status == 200) {
+        return xhr.responseText;
+      }
+    }
+    return '';
+  }
+
+  static GetSigImageB64(callback) {
+    var cvs = document.createElement('canvas');
+    var width = this.GetImageXSize();
+    var height = this.GetImageYSize();
+    cvs.width = width == '' || width == null ? 0 : Number(width);
+    cvs.height = height == '' || height == null ? 0 : Number(height);
+
+    var xhr2 = new XMLHttpRequest();
+    xhr2.open(
+      'GET',
+      this.baseUri + 'SigImage/1' + '?noCache=' + this.generateUUID(),
+      true
+    );
+    xhr2.responseType = 'blob';
+    xhr2.send(null);
+    xhr2.onload = () => {
+      var cntx = cvs.getContext('2d');
+      var img = new Image();
+      img.src = this.getBlobURL(xhr2.response);
+      img.onload = () => {
+        cntx.drawImage(img, 0, 0);
+        var b64String = cvs.toDataURL('image/png');
+        var loc = b64String.search('base64,');
+        var retstring = b64String.slice(loc + 7, b64String.length);
+        if (callback) {
+          callback(retstring);
+        }
+      };
+    };
+  }
+
+  static SigWebWaitForPenDown(callback) {
+    var xhr = this.SigWebcreateXHR();
+
+    if (xhr) {
+      xhr.open(
+        'GET',
+        this.baseUri + 'WaitForPenDown' + '?noCache=' + this.generateUUID()
+      );
+      xhr.timeout = 10000;
+      xhr.onreadystatechange = () => {
+        if (xhr.readyState != 4) return;
+        if (xhr.status == 200) callback();
+      };
+      xhr.send(null);
+    }
+  }
+
+  static GetSigImage(ctx) {
+    var xhr2 = new XMLHttpRequest();
+    xhr2.open(
+      'GET',
+      this.baseUri + 'SigImage/1' + '?noCache=' + this.generateUUID(),
+      true
+    );
+    xhr2.responseType = 'blob';
+    xhr2.send(null);
+    xhr2.onload = () => {
+      var img = new Image();
+      img.src = this.getBlobURL(xhr2.response);
+      img.onload = () => {
+        ctx.drawImage(img, 0, 0);
+        this.revokeBlobURL(img.src);
+        img = null;
+      };
+    };
+  }
+
+  static SigWebSetDisplayTarget(obj) {
+    this.ctx = obj;
+  }
+
+  static SigWebRefresh() {
+    var NumPoints = Number(this.NumberOfTabletPoints());
+    if (NumPoints == this.NumPointsLastTime) {
+      return;
+    }
+    this.NumPointsLastTime = NumPoints;
+
+    var xhr2 = new XMLHttpRequest();
+    xhr2.open(
+      'GET',
+      this.baseUri + 'SigImage/0' + '?noCache=' + this.generateUUID(),
+      true
+    );
+    xhr2.responseType = 'blob';
+    xhr2.onload = () => {
+      var img = new Image();
+      img.src = this.getBlobURL(xhr2.response);
+      //				img.src = window.URL.createObjectURL(xhr2.response);
+      img.onload = () => {
+        this.ctx.drawImage(img, 0, 0);
+        this.revokeBlobURL(img.src);
+        img = null;
+      };
+    };
+    xhr2.send(null);
+  }
+
+  static SigWebEvent() {
+    var OldEvStatus = this.EvStatus;
+
+    var xhr = this.SigWebcreateXHR();
+
+    if (xhr) {
+      xhr.open(
+        'GET',
+        this.baseUri + 'EventStatus' + '?noCache=' + this.generateUUID(),
+        true
+      );
+      xhr.onload = () => {
+        this.EvStatus = xhr.responseText;
+        if (OldEvStatus & 0x01 && this.EvStatus & 0x02) {
+          if (this.onSigPenDown) {
+            this.onSigPenDown();
+          }
+        }
+
+        if (OldEvStatus & 0x02 && this.EvStatus & 0x01) {
+          if (this.onSigPenUp) {
+            this.onSigPenUp();
+          }
+        }
+      };
+      xhr.send(null);
+    }
+  }
+
+  static setSigWebFontThreshold(v) {
+    this.SigWebFontThreshold = v;
+  }
+
+  static createLcdBitmapFromCanvas(ourCanvas, xp, yp, width, height) {
+    var canvasCtx = ourCanvas.getContext('2d');
+    var imgData = canvasCtx.getImageData(0, 0, width, height);
+    var j = 0;
+    var sVal = 0;
+    var outData = '';
+    var outIdx = 0;
+    var data = imgData.data;
+
+    for (var y = 0; y < height; y++)
+      for (var x = 0; x < width; x++) {
+        var tmp1 = data[j];
+        var tmp2 = data[j + 1];
+        var tmp3 = data[j + 2];
+        var tmp4 = data[j + 3];
+
+        //					sVal = tmp1 + (tmp2 << 8 ) + ( tmp3 << 16 ) + (tmp4 << 24 );
+        j = j + 4;
+        if (tmp1 < this.SigWebFontThreshold) {
+          outData += 'B';
+        } else {
+          outData += 'W';
+        }
+      }
+
+    return outData;
+  }
+
+  static toHex(NibVal) {
+    switch (NibVal) {
+      case 0:
+        return '0';
+      case 1:
+        return '1';
+      case 2:
+        return '2';
+      case 3:
+        return '3';
+      case 4:
+        return '4';
+      case 5:
+        return '5';
+      case 6:
+        return '6';
+      case 7:
+        return '7';
+      case 8:
+        return '8';
+      case 9:
+        return '9';
+      case 10:
+        return 'A';
+      case 11:
+        return 'B';
+      case 12:
+        return 'C';
+      case 13:
+        return 'D';
+      case 14:
+        return 'E';
+      case 15:
+        return 'F';
+      default:
+        return '';
+    }
+  }
+  static ToHexString(ByteVal) {
+    var Str = '';
+    Str += this.toHex((ByteVal >> 4) & 0x0f);
+    Str += this.toHex(ByteVal & 0x0f);
+    return Str;
+  }
+
+  static textToTablet(x, y, height, str, fnt) {
+    var c = document.createElement('canvas');
+    var cntx = c.getContext('2d');
+    cntx.font = fnt;
+    var txt = str;
+    var xs = Math.round(cntx.measureText(txt).width);
+    var ys = height;
+    c.width = xs;
+    c.height = ys;
+
+    cntx.font = fnt;
+    cntx.fillStyle = '#FFFFFF';
+    cntx.rect(0, 0, xs, ys);
+    cntx.fill();
+
+    cntx.fillStyle = '#000000';
+    cntx.textBaseline = 'top';
+    cntx.fillText(txt, 0, 0);
+
+    cntx.drawImage(cntx.canvas, 0, 0, xs, ys);
+
+    var Gstr = this.createLcdBitmapFromCanvas(c, 0, 0, xs, ys);
+
+    this.LcdWriteImageStream(0, 2, x, y, xs, ys, Gstr);
+  }
+
+  static LcdWriteImage(Dst, Mode, Xp, Yp, Url) {
+    var Prop = 'LcdWriteImage/';
+    var NewUrl = Url.replace(/\//g, '_');
+
+    Prop = Prop + Dst + ',' + Mode + ',' + Xp + ',' + Yp + ',' + NewUrl;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static LcdWriteLocalImage(Dst, Mode, Xp, Yp, Url) {
+    var Prop = 'LcdWriteImage/';
+
+    Prop = Prop + Dst + ',' + Mode + ',' + Xp + ',' + Yp + ',' + Url;
+    this.SigWebSetProperty(Prop);
+  }
+
+  static LcdWriteImageStream(Dst, Mode, Xp, Yp, Xs, Ys, Url) {
+    var Prop1 =
+      'LcdWriteImageStreamParams/' +
+      Dst +
+      ',' +
+      Mode +
+      ',' +
+      Xp +
+      ',' +
+      Yp +
+      ',' +
+      Xs +
+      ',' +
+      Ys;
+    var Prop2 = 'LcdWriteImageStream/';
+
+    this.SigWebSetPropertySync(Prop1);
+    this.SigWebSetImageStreamProperty(Prop2, Url);
+  }
+
+  static LcdWriteImageBlob(Dst, Mode, Xp, Yp, Xs, Ys, Url) {
+    var Prop = 'LcdWriteImageStream/';
+
+    Prop = Prop + Dst + ',' + Mode + ',' + Xp + ',' + Yp + ',' + Xs + ',' + Ys;
+    this.SigWebSetImageBlobProperty(Prop, Url);
+  }
+
+  static measureText(pText, pFontSize, pStyle) {
+    var lDiv = document.createElement('lDiv');
+
+    document.body.appendChild(lDiv);
+
+    if (pStyle != null) {
+      lDiv.setAttribute('style', pStyle);
+    }
+    lDiv.style.fontSize = '' + pFontSize + 'px';
+    lDiv.style.position = 'absolute';
+    lDiv.style.left = '-1000';
+    lDiv.style.top = '-1000';
+
+    lDiv.innerHTML = pText;
+
+    var lResult = {
+      width: lDiv.clientWidth,
+      height: lDiv.clientHeight,
+    };
+
+    document.body.removeChild(lDiv);
+    lDiv = null;
+
+    return lResult;
+  }
+  static GetVersionString() {
+    var Prop = 'Version';
+
+    Prop = Prop;
+    var Str = this.SigWebGetVersion(Prop);
+    if(Str == null)
+      return Str;
+
+    var trimStr = Str.slice(1, Str.length - 2);
+    return trimStr;
+  }
+
+  static IsPenDown() {
+    return this.EvStatus & 0x01;
+  }
+
+  //
+  //			SigPlusNETSig.cs
+  //
+  static ClearTablet() {
+    var Prop = 'ClearSignature';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static NumberOfTabletPoints() {
+    var Prop = 'TotalPoints';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetSigString(sigStr, ctx) {
+    var Prop = 'SigString';
+
+    Prop = Prop;
+    var xhr = this.SigWebcreateXHR();
+
+    if (xhr) {
+      xhr.open('POST', this.baseUri + Prop);
+      xhr.setRequestHeader('Content-Type', 'text/plain');
+      xhr.send(sigStr);
+      xhr.onload = () => {
+        if (ctx) {
+          var can = ctx.canvas;
+          this.SetImageXSize(can.width);
+          this.SetImageYSize(can.height);
+          this.GetSigImage(ctx);
+        }
+      };
+    }
+    return '';
+  }
+
+  static GetSigString() {
+    var Prop = 'SigString';
+
+    Prop = Prop;
+    var Str = this.SigWebGetProperty(Prop);
+
+    return Str.slice(1, Str.length - 1);
+  }
+
+  static SetSigCompressionMode(v) {
+    var Prop = 'CompressionMode/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetSigCompressionMode() {
+    var Prop = 'CompressionMode';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetEncryptionMode(v) {
+    var Prop = 'EncryptionMode/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetEncryptionMode() {
+    var Prop = 'EncryptionMode';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetKeyString(keyString) {
+    var Prop = 'KeyString';
+
+    Prop = Prop;
+    this.SigWebSetStreamProperty(Prop, keyString);
+  }
+
+  static GetKeyString() {
+    var Prop = 'KeyString';
+
+    Prop = Prop;
+    var Str = this.SigWebGetProperty(Prop);
+
+    return Str.slice(1, Str.length - 1);
+  }
+
+  static AutoKeyStart() {
+    var Prop = 'AutoKeyStart';
+
+    Prop = Prop;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static AutoKeyFinish() {
+    var Prop = 'AutoKeyFinish';
+
+    Prop = Prop;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static SetAutoKeyData(keyData) {
+    var Prop = 'SetAutoKeyData';
+
+    Prop = Prop;
+    this.SigWebSetStreamProperty(Prop, keyData);
+  }
+
+  static AutoKeyAddData(keyData) {
+    var Prop = 'AutoKeyAddData';
+
+    Prop = Prop;
+    this.SigWebSetStreamProperty(Prop, keyData);
+    return this.GetKeyString();
+  }
+
+  //		function  GetKeyReceipt( ) {}
+
+  static GetKeyReceiptAscii() {
+    var Prop = 'KeyReceiptAscii';
+
+    Prop = Prop;
+    var Str = this.SigWebGetProperty(Prop);
+
+    return Str.slice(1, Str.length - 1);
+  }
+
+  //		function  GetSigReceipt( ) {}
+
+  static GetSigReceiptAscii() {
+    var Prop = 'SigReceiptAscii';
+
+    Prop = Prop;
+    var Str = this.SigWebGetProperty(Prop);
+
+    return Str.slice(1, Str.length - 1);
+  }
+
+  static SetTimeStamp(timeStamp) {
+    var Prop = 'TimeStamp';
+
+    Prop = Prop;
+    this.SigWebSetStreamProperty(Prop, timeStamp);
+  }
+
+  static GetTimeStamp() {
+    var Prop = 'TimeStamp';
+
+    Prop = Prop;
+    var Str = this.SigWebGetProperty(Prop);
+
+    return Str.slice(1, Str.length - 1);
+  }
+
+  static SetAnnotate(annotate) {
+    var Prop = 'Annotate';
+
+    Prop = Prop;
+    this.SigWebSetStreamProperty(Prop, annotate);
+  }
+
+  static GetAnnotate() {
+    var Prop = 'Annotate';
+
+    Prop = Prop;
+    var Str = this.SigWebGetProperty(Prop);
+
+    return Str.slice(1, Str.length - 1);
+  }
+
+  static SetSaveSigInfo(v) {
+    var Prop = 'SaveSigInfo/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetSaveSigInfo() {
+    var Prop = 'SaveSigInfo';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetSavePressureData(v) {
+    var Prop = 'SavePressureData/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetSavePressureData() {
+    var Prop = 'SavePressureData';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetSaveTimeData(v) {
+    var Prop = 'SaveTimeData/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetSaveTimeData() {
+    var Prop = 'SaveTimeData';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetAntiAliasSpotSize(v) {
+    var Prop = 'AntiAliasSpotSize/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetAntiAliasSpotSize() {
+    var Prop = 'AntiAliasSpotSize';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetAntiAliasLineScale(v) {
+    var Prop = 'AntiAliasLineScale/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetAntiAliasLineScale() {
+    var Prop = 'AntiAliasLineScale';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static GetNumberOfStrokes() {
+    var Prop = 'NumberOfStrokes';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static GetNumPointsForStroke(v) {
+    var Prop = 'NumberOfPointsInStroke/';
+
+    Prop = Prop + v;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static GetPointXValue(v1, v2) {
+    var Prop = 'PointXValue/';
+
+    Prop = Prop + v1 + '/' + v2;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static GetPointYValue(v1, v2) {
+    var Prop = 'PointYValue/';
+
+    Prop = Prop + v1 + '/' + v2;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetAntiAliasEnable(v) {
+    var Prop = 'AntiAliasEnable/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetAntiAliasEnable() {
+    var Prop = 'AntiAliasEnable';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetUseAmbientColors(v) {
+    var Prop = 'UseAmbientColors/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  //
+  //		SigPlusNETDisplay.cs
+  //
+  static SetDisplayXSize(v) {
+    var Prop = 'DisplayXSize/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetDisplayXSize() {
+    var Prop = 'DisplayXSize';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetDisplayYSize(v) {
+    var Prop = 'DisplayYSize/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetDisplayYSize() {
+    var Prop = 'DisplayYSize';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetDisplayPenWidth(v) {
+    var Prop = 'DisplayPenWidth/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetDisplayPenWidth() {
+    var Prop = 'DisplayPenWidth';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetDisplayTimeStamp(v) {
+    var Prop = 'DisplayTimeStamp/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetDisplayTimeStamp() {
+    var Prop = 'DisplayTimeStamp';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetDisplayTimeStampPosX(v) {
+    var Prop = 'DisplayTimeStampPosX/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetDisplayTimeStampPosX() {
+    var Prop = 'DisplayTimeStampPosX';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetDisplayTimeStampPosY(v) {
+    var Prop = 'DisplayTimeStampPosY/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetDisplayTimeStampPosY() {
+    var Prop = 'DisplayTimeStampPosY';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetDisplayTimeStampSize(v) {
+    var Prop = 'DisplayTimeStampSize/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetDisplayTimeStampSize() {
+    var Prop = 'DisplayTimeStampSize';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetDisplayAnnotate(v) {
+    var Prop = 'DisplayAnnotate/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetDisplayAnnotate() {
+    var Prop = 'DisplayAnnotate';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetDisplayAnnotatePosX(v) {
+    var Prop = 'DisplayAnnotatePosX/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetDisplayAnnotatePosX() {
+    var Prop = 'DisplayAnnotatePosX';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetDisplayAnnotatePosY(v) {
+    var Prop = 'DisplayAnnotatePosY/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetDisplayAnnotatePosY() {
+    var Prop = 'DisplayAnnotatePosY';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetDisplayAnnotateSize(v) {
+    var Prop = 'DisplayAnnotateSize/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetDisplayAnnotateSize() {
+    var Prop = 'DisplayAnnotateSize';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  //
+  //		SigPlusNETImage.cs
+  //
+  //		function  GetSigImageB64( )
+  //			{
+  //			var xhr2 = new XMLHttpRequest();
+  //			xhr2.open("GET", baseUri + "SigImage/1", false );
+  //			xhr2.responseType = "blob"
+  //			xhr2.send(null);
+  //			if (xhr2.readyState == 4 && xhr.status == 200)
+  //				{
+  //				return window.URL.createObjectURL(xhr2.response);
+  //				}
+  //			return null;
+  //			}
+
+  static SetImageXSize(v) {
+    var Prop = 'ImageXSize/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetImageXSize() {
+    var Prop = 'ImageXSize';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetImageYSize(v) {
+    var Prop = 'ImageYSize/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetImageYSize() {
+    var Prop = 'ImageYSize';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetImagePenWidth(v) {
+    var Prop = 'ImagePenWidth/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetImagePenWidth() {
+    var Prop = 'ImagePenWidth';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetImageTimeStamp(v) {
+    var Prop = 'ImageTimeStamp/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetImageTimeStamp() {
+    var Prop = 'ImageTimeStamp';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetImageTimeStampPosX(v) {
+    var Prop = 'ImageTimeStampPosX/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetImageTimeStampPosX() {
+    var Prop = 'ImageTimeStampPosX';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetImageTimeStampPosY(v) {
+    var Prop = 'ImageTimeStampPosY/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetImageTimeStampPosY() {
+    var Prop = 'ImageTimeStampPosY';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetImageTimeStampSize(v) {
+    var Prop = 'ImageTimeStampSize/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetImageTimeStampSize() {
+    var Prop = 'ImageTimeStampSize';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetImageAnnotate(v) {
+    var Prop = 'ImageAnnotate/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetImageAnnotate() {
+    var Prop = 'ImageAnnotate';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetImageAnnotatePosX(v) {
+    var Prop = 'ImageAnnotatePosX/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetImageAnnotatePosX() {
+    var Prop = 'ImageAnnotatePosX';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetImageAnnotatePosY(v) {
+    var Prop = 'ImageAnnotatePosY/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetImageAnnotatePosY() {
+    var Prop = 'ImageAnnotatePosY';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetImageAnnotateSize(v) {
+    var Prop = 'ImageAnnotateSize/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetImageAnnotateSize() {
+    var Prop = 'ImageAnnotateSize';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetJustifyX(v) {
+    var Prop = 'JustifyX/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetJustifyX() {
+    var Prop = 'JustifyX';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetJustifyY(v) {
+    var Prop = 'JustifyY/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetJustifyY() {
+    var Prop = 'JustifyY';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetJustifyMode(v) {
+    var Prop = 'JustifyMode/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetJustifyMode() {
+    var Prop = 'JustifyMode';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  //
+  //		SigPlusNETKeyPad.cs
+  //
+  static KeyPadAddHotSpot(key, coord, xp, yp, xs, ys) {
+    var Prop = 'KeyPadAddHotSpot/';
+    Prop = Prop + key + ',' + coord + ',' + xp + ',' + yp + ',' + xs + ',' + ys;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static KeyPadMarkHotSpot(key, coord, xp, yp, xs, ys) {
+    this.LCDWriteString(0, 2, xp, yp, '16pt sans-serif', 32, '+');
+    this.LCDWriteString(0, 2, xp + xs, yp, '16pt sans-serif', 32, '+');
+    this.LCDWriteString(0, 2, xp, yp + ys, '16pt sans-serif', 32, '+');
+    this.LCDWriteString(0, 2, xp + xs, yp + ys, '16pt sans-serif', 32, '+');
+  }
+
+  static KeyPadQueryHotSpot(key) {
+    var Prop = 'KeyPadQueryHotSpot/';
+    Prop = Prop + key;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static KeyPadClearHotSpotList() {
+    var Prop = 'KeyPadClearHotSpotList';
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static SetSigWindow(coords, xp, yp, xs, ys) {
+    var Prop = 'SigWindow/';
+    Prop = Prop + coords + ',' + xp + ',' + yp + ',' + xs + ',' + ys;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static ClearSigWindow(inside) {
+    var Prop = 'ClearSigWindow/';
+    Prop = Prop + inside;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  //
+  //		SigPlusNETLCD.cs
+  //
+  static SetLCDCaptureMode(v) {
+    var Prop = 'CaptureMode/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetLCDCaptureMode() {
+    var Prop = 'CaptureMode';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static LCDSetWindow(xP, yP, xS, yS) {
+    var Prop = 'LCDSetWindow/';
+    Prop = Prop + xP + ',' + yP + ',' + xS + ',' + yS;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static LCDWriteString(dest, mode, x, y, fnt, size, str) {
+    var c = document.createElement('canvas');
+    var cntx = c.getContext('2d');
+    cntx.font = fnt;
+    var txt = str;
+    var xs = Math.round(cntx.measureText(txt).width);
+    var ys = size;
+    c.width = xs;
+    c.height = ys;
+
+    if (xs == 0) {
+      return;
+    }
+
+    cntx.font = fnt;
+    cntx.fillStyle = '#FFFFFF';
+    cntx.rect(0, 0, xs, ys);
+    cntx.fill();
+
+    cntx.fillStyle = '#000000';
+    cntx.textBaseline = 'top';
+    cntx.fillText(txt, 0, 0);
+
+    cntx.drawImage(cntx.canvas, 0, 0, xs, ys);
+
+    var Gstr = this.createLcdBitmapFromCanvas(c, x, y, xs, ys);
+
+    this.LcdWriteImageStream(dest, mode, x, y, xs, ys, Gstr);
+  }
+
+  static LCDDrawRectangle(dest, mode, x, y, xs, ys, fill) {
+    var c = document.createElement('canvas');
+    var cntx = c.getContext('2d');
+
+    c.width = xs;
+    c.height = ys;
+
+    cntx.fillStyle = fill;
+    cntx.rect(0, 0, xs, ys);
+    cntx.fill();
+
+    cntx.drawImage(cntx.canvas, 0, 0, xs, ys);
+    var Gstr = this.createLcdBitmapFromCanvas(c, x, y, xs, ys);
+    this.LcdWriteImageBlob(dest, mode, x, y, xs, ys, Gstr);
+  }
+
+  static LCDDrawButton(dest, mode, x, y, xs, ys, strys, fill, fnt, str) {
+    var c = document.createElement('canvas');
+    var cntx = c.getContext('2d');
+    cntx.font = fnt;
+    var txt = str;
+    var sxs = Math.round(cntx.measureText(txt).width);
+    var sys = strys;
+    c.width = xs;
+    c.height = ys;
+
+    cntx.font = fnt;
+    cntx.fillStyle = fill;
+    cntx.rect(0, 0, xs, ys);
+    cntx.fill();
+
+    cntx.fillStyle = '#FFFFFF';
+    cntx.textBaseline = 'top';
+    cntx.fillText(txt, (xs - sxs) / 2, (ys - sys) / 2);
+
+    cntx.drawImage(cntx.canvas, 0, 0, xs, ys);
+
+    var Gstr = this.createLcdBitmapFromCanvas(c, x, y, xs, ys);
+
+    this.LcdWriteImageBlob(dest, mode, x, y, xs, ys, Gstr);
+  }
+
+  static LCDWriteStringWindow(dest, mode, x, y, fnt, xsize, ysize, str) {
+    var c = document.createElement('canvas');
+    var cntx = c.getContext('2d');
+    cntx.font = fnt;
+    var txt = str;
+    var xs = xsize;
+    var ys = ysize;
+    c.width = xs;
+    c.height = ys;
+
+    cntx.font = fnt;
+    cntx.fillStyle = '#FFFFFF';
+    cntx.rect(0, 0, xs, ys);
+    cntx.fill();
+
+    cntx.fillStyle = '#000000';
+    cntx.textBaseline = 'top';
+    cntx.fillText(txt, 0, 0);
+
+    cntx.drawImage(cntx.canvas, 0, 0, xs, ys);
+
+    var Gstr = this.createLcdBitmapFromCanvas(c, x, y, xs, ys);
+
+    this.LcdWriteImageBlob(dest, mode, x, y, xs, ys, Gstr);
+  }
+
+  static LCDStringWidth(fnt, str) {
+    var c = document.createElement('canvas');
+    var cntx = c.getContext('2d');
+    cntx.font = fnt;
+    var txt = str;
+    var xs = Math.round(cntx.measureText(txt).width);
+
+    return xs;
+  }
+
+  static LCDStringHeight(fnt, str) {
+    return 16;
+  }
+
+  static LcdRefresh(Mode, Xp, Yp, Xs, Ys) {
+    var Prop = 'LcdRefresh/';
+
+    Prop = Prop + Mode + ',' + Xp + ',' + Yp + ',' + Xs + ',' + Ys;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static LCDSendCmdString(CmdStr, ReturnCount, Result, TimeOut) {
+    var Prop = 'LcdSendCmdString/';
+
+    Prop = Prop + ReturnCount + ',' + TimeOut;
+    Result = this.SigWebSetStreamProperty(Prop, CmdStr);
+  }
+
+  static LCDSendCmdData(CmdStr, ReturnCount, Result, TimeOut) {
+    var Prop = 'LcdSendCmdData/';
+
+    Prop = Prop + ReturnCount + ',' + TimeOut;
+    Result = this.SigWebSetStreamProperty(Prop, CmdStr);
+  }
+
+  //		function  LCDSendWindowedGraphicCanvas(  dest, mode,  x,  y, canvas )
+  //			 {
+  //			 }
+
+  //		function  LCDSendWindowedGraphicCanvas(  dest, mode,  x,  y,  xs,  ys, canvas )
+  //			{
+  //			var Gstr = this.createLcdBitmapFromCanvas( canvas, 0, 0, xs, ys)
+  //			LcdWriteImageStream( dest, mode, x, y, xs, ys, Gstr );
+  //			}
+
+  static LCDSendWindowedGraphicCanvas(dest, mode, x, y, xs, ys, c, xps, yps) {
+    var canvas = document.createElement('canvas');
+    var Gstr = this.createLcdBitmapFromCanvas(canvas, xps, yps, xs, ys);
+    this.LcdWriteImageStream(dest, mode, x, y, xs, ys, Gstr);
+  }
+
+  static LCDSendGraphicUrl(dest, mode, x, y, url) {
+    this.LcdWriteImage(dest, mode, x, y, url);
+  }
+
+  //		function  LCDSendGraphic(  Dest,  Mode,  XPos,  YPos,  ImageFileName ) {}
+  //		function  LCDSendGraphicURL(  Dest,  Mode,  XPos,  YPos,  URL ) {}
+
+  static LCDClear() {
+    var Prop = 'LcdClear';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static LCDSetTabletMap(
+    LCDType,
+    LCDXSize,
+    LCDYSize,
+    LCDXStart,
+    LCDYStart,
+    LCDXStop,
+    LCDYStop
+  ) {}
+
+  static LCDSetPixelDepth(v) {
+    var Prop = 'LcdSetPixelDepth/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static LCDGetLCDSize() {
+    var Prop = 'LcdGetLcdSize';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+  static LCDGetCompressionMode() {
+    var Prop = 'LcdCompressionMode';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static LCDGetZCompressionMode() {
+    var Prop = 'LcdZCompressionMode';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  //
+  //		SigPlusNETLCD.cs
+  //
+
+  static SetRealTabletState(v) {
+    var Prop = 'TabletState/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletState() {
+    var Prop = 'TabletState';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletLogicalXSize(v) {
+    var Prop = 'TabletLogicalXSize/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletLogicalXSize() {
+    var Prop = 'TabletLogicalXSize';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static GetTabletLogicalYSize() {
+    var Prop = 'TabletLogicalYSize';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletLogicalYSize(v) {
+    var Prop = 'TabletLogicalYSize/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static SetTabletXStart(v) {
+    var Prop = 'TabletXStart/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletXStart() {
+    var Prop = 'TabletXStart';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletYStart(v) {
+    var Prop = 'TabletYStart/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletYStart() {
+    var Prop = 'TabletYStart';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletXStop(v) {
+    var Prop = 'TabletXStop/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletXStop() {
+    var Prop = 'TabletXStop';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletYStop(v) {
+    var Prop = 'TabletYStop/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletYStop() {
+    var Prop = 'TabletYStop';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletFilterPoints(v) {
+    var Prop = 'TabletFilterPoints/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletFilterPoints() {
+    var Prop = 'TabletFilterPoints';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletTimingAdvance(v) {
+    var Prop = 'TabletTimingAdvance/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletTimingAdvance() {
+    var Prop = 'TabletTimingAdvance';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletComPort(v) {
+    var Prop = 'TabletComPort/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletComPort() {
+    var Prop = 'TabletComPort';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletBaudRate(v) {
+    var Prop = 'TabletBaudRate/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletBaudRate() {
+    var Prop = 'TabletBaudRate';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletRotation(v) {
+    var Prop = 'TabletRotation/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletRotation() {
+    var Prop = 'TabletRotation';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletType(v) {
+    var Prop = 'TabletType/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletType() {
+    var Prop = 'TabletType';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetServerTabletType(v) {
+    var Prop = 'ServerTabletType/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetServerTabletType() {
+    var Prop = 'ServerTabletType';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletComTest(v) {
+    var Prop = 'TabletComTest/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletComTest() {
+    var Prop = 'TabletComTest';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletResolution(v) {
+    var Prop = 'TabletResolution/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetTabletResolution() {
+    var Prop = 'TabletResolution';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static TabletConnectQuery() {
+    var Prop = 'TabletConnectQuery';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static TabletModelNumber() {
+    var Prop = 'TabletModelNumber';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static TabletSerialNumber() {
+    var Prop = 'TabletSerialNumber';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletPortPath(v) {
+    var Prop = 'TabletPortPath/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static SetTabletLocalIniFilePath(v) {
+    var Prop = 'TabletLocalIniFilePath/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static SetTabletModel(v) {
+    var Prop = 'TabletModel/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static SetSerialPortCloseDelay(v) {
+    var Prop = 'SerialPortCloseDelay/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetSerialPortCloseDelay() {
+    var Prop = 'SerialPortCloseDelay';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static EnableTabletEncryption() {
+    var Prop = 'EnableTabletEncryption';
+
+    Prop = Prop;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static SetTabletEncryptionMode(hmode, tmode) {
+    var Prop = 'TabletEncryptionMode/';
+
+    Prop = Prop + hmode + ',' + tmode;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static SetMaxLogFileSize(v) {
+    var Prop = 'MaxLogFileSize/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetSigSockServerPath() {
+    var Prop = 'SigSockServerPath';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static GetSigSockClientName() {
+    var Prop = 'SigSockClientName';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static GetSigSockPortNumber() {
+    var Prop = 'SigSockPortNumber';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetSigSockServerPath(v) {
+    var Prop = 'SigSockServerPath/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static SetSigSockClientName(v) {
+    var Prop = 'SigSockClientName/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static SetPortNumber(v) {
+    var Prop = 'PortNumber/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static SetSigSockPortNumber(v) {
+    var Prop = 'SigSockPortNumber/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static GetFirmwareRevision() {
+    var Prop = 'FirmwareRevision';
+
+    Prop = Prop;
+    return this.SigWebGetProperty(Prop);
+  }
+
+  static SetTabletData(sigStr) {
+    var Prop = 'TabletData';
+
+    Prop = Prop;
+    this.SigWebSetStreamProperty(Prop, sigStr);
+  }
+
+  static GetTabletData() {
+    var Prop = 'TabletData';
+
+    Prop = Prop;
+    var Str = this.SigWebGetProperty(Prop);
+
+    return Str.slice(1, Str.length - 1);
+  }
+
+  static OpenTablet(v) {
+    var Prop = 'OpenTablet/';
+
+    Prop = Prop + v;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static CloseTablet() {
+    var Prop = 'CloseTablet';
+
+    Prop = Prop;
+    this.SigWebSetProperty(Prop);
+  }
+
+  static ResetParameters() {
+    var Prop = 'ResetParameters';
+
+    Prop = Prop;
+    this.SigWebSetPropertySync(Prop);
+  }
+
+  static testRawData() {
+    this.OpenTablet(1);
+    var Str1 = this.GetTabletData();
+    this.CloseTablet();
+  }
+
+  static SetTabletState(v, ctx, tv) {
+    var delay;
+
+    if (tv) {
+      delay = tv;
+    } else {
+      delay = 100;
+    }
+
+    if (this.GetTabletState() != v) {
+      if (v == 1) {
+        if (ctx) {
+          var can = ctx.canvas;
+          this.SetDisplayXSize(can.width);
+          this.SetDisplayYSize(can.height);
+          this.SigWebSetDisplayTarget(ctx);
+        }
+        this.SetRealTabletState(v);
+        var data = this.GetTabletState();
+        var dataResult = data == '' || data == null ? 0 : Number(data);
+        var tmr = null;
+        if (ctx && dataResult != 0) {
+          tmr = setInterval(() => this.SigWebRefresh(), delay);
+        } else {
+          tmr = null;
+        }
+
+        return tmr;
+      } else {
+        if (ctx) {
+          clearInterval(ctx);
+        }
+        this.SigWebSetDisplayTarget(null);
+        this.SetRealTabletState(v);
+      }
+    }
+    return null;
+  }
+}