@shijiu/jsview 1.9.719

package/dom/jsview-dom/src/engine-js/browser/latex_parse.js

@@ -0,0 +1,336 @@
+/* eslint-disable no-unused-vars */
+
+const WordType = {
+  STRING: Symbol("STRING"),
+  FUNCTION: Symbol("FUNCTION"),
+  LINE_FEED: Symbol("LINE_FEED"),
+  LEFT_BRACE: Symbol("LEFT_BRACE"),
+  RIGHT_BRACE: Symbol("RIGHT_BRACE"),
+};
+
+function lexicalAnalyze(arr) {
+  const result = [];
+  let i = 0;
+  while (i < arr.length) {
+    if (arr[i] === '\\') {
+      if (i < arr.length - 1) {
+        if (arr[i + 1] === '\\' || arr[i + 1] === '{' || arr[i + 1] === '}') {
+          // 普通字符
+          const pair = [i + 1, i + 2];
+          const word = {
+            type: WordType.STRING,
+            indexPair: pair,
+          };
+          result.push(word);
+          i += 2;
+        } else {
+          // 函数
+          ++i;
+          const start_i = i;
+          let end_i = i;
+          let has_char = false; // 函数名后有空字符的处理
+          while (i < arr.length && arr[i] !== '{' && arr[i] !== '}') {
+            if (arr[i] !== ' ') {
+              has_char = true;
+            }
+            if (!(arr[i] === ' ' && has_char)) {
+              // 字符串后的空字符不计入
+              end_i = ++i;
+            } else {
+              ++i;
+            }
+          }
+          const pair = [start_i, end_i];
+          const word = {
+            type: WordType.FUNCTION,
+            indexPair: pair,
+          };
+          result.push(word);
+        }
+      } else {
+        console.error("backslash at end.");
+      }
+    } else if (arr[i] === '{') {
+      const word = {
+        type: WordType.LEFT_BRACE,
+        indexPair: null,
+      };
+      result.push(word);
+      ++i;
+    } else if (arr[i] === '}') {
+      const word = {
+        type: WordType.RIGHT_BRACE,
+        indexPair: null,
+      };
+      result.push(word);
+      ++i;
+    } else if (arr[i] === '\n') {
+      const word = {
+        type: WordType.LINE_FEED,
+        indexPair: null,
+      };
+      result.push(word);
+      ++i;
+    } else {
+      // 普通字符
+      const start = i;
+      let end = i;
+      while (i < arr.length) {
+        if (arr[i] === '\\' || arr[i] === '{' || arr[i] === '}' || arr[i] === '\n') {
+          break;
+        } else {
+          ++i;
+          end = i;
+        }
+      }
+      const pair = [start, end];
+      const word = {
+        type: WordType.STRING,
+        indexPair: pair,
+      };
+      result.push(word);
+    }
+  }
+  // 清理
+  for (let index = result.length - 1; index >= 0; index--) {
+    const info = result[index];
+    if (info.type === WordType.STRING) {
+      let all_blank = true;
+      for (let j = info.indexPair[0]; j < info.indexPair[1]; j++) {
+        if (arr[j] !== ' ') {
+          all_blank = false;
+          break;
+        }
+      }
+      // 纯空字符的片段
+      if (all_blank && index > 0 && index < result.length - 1 && (result[index - 1].type === WordType.LEFT_BRACE || result[index - 1].type === WordType.RIGHT_BRACE) && (result[index + 1].type === WordType.RIGHT_BRACE || result[index + 1].type === WordType.LEFT_BRACE)) {
+        // 参数中间的空字符串该删除
+        result.splice(index, 1);
+        // result.remove(index);
+      }
+    }
+  }
+  return result;
+}
+
+
+const LEFT_BRACE = {};
+// const RIGHT_BRACE = {};
+
+const Style = {
+  BASE: Symbol("BASE"),
+  COLOR: Symbol("COLOR"),
+  BOLD: Symbol("BOLD"),
+  ITALIC: Symbol("ITALIC"),
+  DECORATION: Symbol("DECORATION"),
+  SUPERSCRIPT: Symbol("SUPERSCRIPT"),
+  SUBSCRIPT: Symbol("SUBSCRIPT"),
+};
+
+class TextStyle {
+    constructor() {
+        this.style;
+
+        this.styleValue = "";
+    }
+}
+
+class BaseNode {
+    constructor() {
+        this.textStyle = new TextStyle();
+
+        this.childNodes = [];
+
+        this.parent;
+    }
+}
+
+class LeafNode extends BaseNode {
+    constructor() {
+        super();
+
+        this.styleList = [];
+
+        this.indexPair;
+
+        this.lineFeedNode = false;
+
+        this.testValue;
+    }
+}
+
+function parseLatex(text) {
+  if (text === null || text.length === 0) { return null; }
+  const word_list = lexicalAnalyze(text);
+  const stack = [];
+  const leaf_list = [];
+  let i = 0;
+  while (i < word_list.length) {
+    const word = word_list[i];
+    if (word.type === WordType.STRING) {
+      const node = new LeafNode();
+      leaf_list.push(node);
+      node.indexPair = word.indexPair;
+      node.textStyle.style = Style.BASE;
+      stack.push(node);
+    } else if (word.type === WordType.LINE_FEED) {
+      const node = new LeafNode();
+      leaf_list.push(node);
+      node.lineFeedNode = true;
+    } else if (word.type === WordType.LEFT_BRACE) {
+      stack.push(LEFT_BRACE);
+    } else if (word.type === WordType.RIGHT_BRACE) {
+      if (stack.length > 0) {
+        const tmp_stack = [];
+        let node = stack.pop();
+        while (node !== LEFT_BRACE) {
+          tmp_stack.push(node);
+          if (stack.length > 0) {
+            node = stack.pop();
+          } else {
+            break;
+          }
+        }
+        if (stack.length > 0) {
+          const func_node = stack[stack.length - 1];
+          if (func_node.textStyle.style === Style.BASE) {
+            console.error("lack of function");
+          } else {
+            while (tmp_stack.length > 0) {
+              const n = tmp_stack.pop();
+              func_node.childNodes.push(n);
+              n.parent = func_node;
+            }
+          }
+        } else {
+          console.error("lack of function");
+        }
+      } else {
+        console.error("extra }");
+      }
+    } else if (word.type === WordType.FUNCTION) {
+      const func_name = text.substring(word.indexPair[0], word.indexPair[1]);
+
+      const node = new BaseNode();
+      switch (func_name) {
+        case "textcolor":
+          if (i < word_list.length - 3) {
+            node.textStyle.style = Style.COLOR;
+            const l_b = word_list[i + 1];
+            const setting = word_list[i + 2];
+            const r_b = word_list[i + 3];
+            if (l_b.type === WordType.LEFT_BRACE && setting.type === WordType.STRING && r_b.type === WordType.RIGHT_BRACE) {
+              node.textStyle.styleValue = text.substring(setting.indexPair[0], setting.indexPair[1]);
+              i += 3;
+            } else {
+              console.error("textcolor param format error.");
+            }
+          } else {
+            console.error("textcolor param format error.");
+          }
+          break;
+        case "textb":
+          node.textStyle.style = Style.BOLD;
+          break;
+        case "texti":
+          node.textStyle.style = Style.ITALIC;
+          break;
+        case "textdecoration":
+          if (i < word_list.length - 3) {
+            node.textStyle.style = Style.DECORATION;
+            const l_b = word_list[i + 1];
+            const setting = word_list[i + 2];
+            const r_b = word_list[i + 3];
+            if (l_b.type === WordType.LEFT_BRACE && setting.type === WordType.STRING && r_b.type === WordType.RIGHT_BRACE) {
+              node.textStyle.styleValue = text.substring(setting.indexPair[0], setting.indexPair[1]);
+              i += 3;
+            } else {
+              console.error("textdecoration param format error.");
+            }
+          } else {
+            console.error("textdecoration param format error.");
+          }
+          break;
+        case "textsup":
+          node.textStyle.style = Style.SUPERSCRIPT;
+          break;
+        case "textsub":
+          node.textStyle.style = Style.SUBSCRIPT;
+          break;
+        default:
+          console.error(`undefined style type: ${func_name}`);
+          break;
+      }
+      stack.push(node);
+    }
+    ++i;
+  }
+
+  leaf_list.forEach((n, index, arr) => {
+    let node = n.parent;
+    while (node) {
+      n.styleList.push(node.textStyle);
+      node = node.parent;
+    }
+  });
+
+  // 将语法树转为描画列表
+  return {
+    nodeList: leaf_list,
+    text
+  };
+}
+
+function toHtml(root, node_info) {
+  const origin_str = node_info.text;
+  for (const node of node_info.nodeList) {
+    if (node.lineFeedNode) {
+      root.appendChild(window.originDocument.createElement("br"));
+      continue;
+    }
+    const str = origin_str.substring(node.indexPair[0], node.indexPair[1]);
+    const span = window.originDocument.createElement("span");
+    let ele = span;
+    let tmp_ele;
+    for (const style of node.styleList) {
+      switch (style.style) {
+        case Style.BASE:
+          break;
+        case Style.BOLD:
+          tmp_ele = window.originDocument.createElement("b");
+          ele.appendChild(tmp_ele);
+          ele = tmp_ele;
+          break;
+        case Style.ITALIC:
+          tmp_ele = window.originDocument.createElement("i");
+          ele.appendChild(tmp_ele);
+          ele = tmp_ele;
+          break;
+        case Style.COLOR:
+          span.style.color = style.styleValue;
+          break;
+        case Style.DECORATION:
+          span.style.textDecoration = style.styleValue;
+          break;
+        case Style.SUPERSCRIPT:
+          tmp_ele = window.originDocument.createElement("sup");
+          ele.appendChild(tmp_ele);
+          ele = tmp_ele;
+          break;
+        case Style.SUBSCRIPT:
+          tmp_ele = window.originDocument.createElement("sub");
+          ele.appendChild(tmp_ele);
+          ele = tmp_ele;
+          break;
+        default:
+          break;
+      }
+    }
+    ele.textContent = str;
+    root.appendChild(span);
+  }
+}
+export {
+  parseLatex,
+  toHtml
+};

package/dom/jsview-dom/src/engine-js/browser/layout_params.js

@@ -0,0 +1,113 @@
+import Forge from "../ForgeDefine";
+
+class LayoutParamsBase {
+  constructor() {
+    this.Width = 0;
+    this.Height = 0;
+    this.MarginTop = 0;
+    this.MarginLeft = 0;
+    this.MarginRight = 0;
+    this.MarginBottom = 0;
+    this.Z = 0;
+    this.SizeAdjust = false;
+  }
+
+  SetPosition(x, y, z) {
+    this.MarginTop = y;
+    this.MarginLeft = x;
+    if (z) {
+      this.Z = z;
+    }
+  }
+
+  SetSize(w, h) {
+    this.Width = w;
+    this.Height = h;
+  }
+
+  Clone() {
+    const new_layout_params = new LayoutParamsBase(null);
+    new_layout_params.Width = this.Width;
+    new_layout_params.Height = this.Height;
+    new_layout_params.MarginTop = this.MarginTop;
+    new_layout_params.MarginLeft = this.MarginLeft;
+    new_layout_params.MarginRight = this.MarginRight;
+    new_layout_params.MarginBottom = this.MarginBottom;
+    new_layout_params.Z = this.Z;
+    new_layout_params.SizeAdjust = this.SizeAdjust;
+    return new_layout_params;
+  }
+
+  Equals(other_layout_params) {
+    return (other_layout_params.Width === this.Width
+        && other_layout_params.Height === this.Height
+        && other_layout_params.MarginTop === this.MarginTop
+        && other_layout_params.MarginLeft === this.MarginLeft
+        && other_layout_params.MarginRight === this.MarginRight
+        && other_layout_params.MarginBottom === this.MarginBottom
+        && other_layout_params.Z === this.Z);
+  }
+}
+Forge.LayoutParamsBase = LayoutParamsBase;
+
+class LayoutParams extends Forge.LayoutParamsBase {
+  constructor(settings) {
+    super();
+
+    if (settings instanceof Forge.RectArea) { settings = { x: settings.x, y: settings.y, width: settings.width, height: settings.height }; }
+
+    if (settings) {
+      // Reset marginLeft
+      if (settings.x) {
+        this.MarginLeft = settings.x;
+      } else if (settings.marginLeft) {
+        this.MarginLeft = settings.marginLeft;
+      }
+
+      // Reset marginTop
+      if (settings.y) {
+        this.MarginTop = settings.y;
+      } else if (settings.marginTop) {
+        this.MarginTop = settings.marginTop;
+      }
+      if (settings.z) {
+        this.Z = settings.z;
+      }
+
+      // Reset width
+      if (settings.width) {
+        this.Width = settings.width;
+      }
+
+      // Reset height
+      if (settings.height) {
+        this.Height = settings.height;
+      }
+      // 参数检查
+      if (isNaN(this.MarginTop)) {
+        Forge.LogE("isNaN(this.MarginTop)!");
+        this.MarginTop = 0;
+      }
+      if (isNaN(this.MarginLeft)) {
+        Forge.LogE("isNaN(this.MarginLeft)!");
+        this.MarginLeft = 0;
+      }
+      if (this.Width !== "MatchParent") {
+        if (isNaN(this.Width)) {
+          Forge.LogE("isNaN(this.Width)!");
+        }
+      } else {
+        this.SizeAdjust = true;
+      }
+      if (this.Height !== "MatchParent") {
+        if (isNaN(this.Height)) {
+          Forge.LogE("isNaN(this.Height)!");
+        }
+      } else {
+        this.SizeAdjust = true;
+      }
+    }
+  }
+}
+Forge.LayoutParams = LayoutParams;
+window.LayoutParams = Forge.LayoutParams; // export class