git.kianting.info Git - clo/blob - src/libclo/breakLines.js

   1 "use strict";
   2 Object.defineProperty(exports, "__esModule", { value: true });
   3 exports.BreakLineAlgorithm = void 0;
   4 /**
   5  * Algorithms in LATEX-like language
   6  */
   7 class BreakLineAlgorithm {
   8     constructor() {
   9         this.prevNodes = [];
  10         this.totalCostAuxStorage = [];
  11         this.lineCostStorage = [[]];
  12     }
  13     /**check if a boeitem is BreakPoint Type */
  14     isBreakPoint(item) {
  15         return item.newLined !== undefined;
  16     }
  17     /**check if a boeitem is HGlue Type */
  18     isHGlue(item) {
  19         return item.stretchFactor !== undefined;
  20     }
  21     /** measuring original advance width */
  22     origWidth(item) {
  23         if (this.isBreakPoint(item)) {
  24             return this.origWidth(item.original);
  25         }
  26         else if (Array.isArray(item)) {
  27             return item.map((x) => this.origWidth(x))
  28                 .reduce((acc, current) => acc + current, 0.0);
  29         }
  30         else if (this.isHGlue(item)) {
  31             return 0.0;
  32         }
  33         else {
  34             return item.width;
  35         }
  36     }
  37     segmentedNodes(items, lineWidth) {
  38         this.totalCost(items, lineWidth);
  39         let nodeList = this.generateBreakLineNodeList();
  40         console.log("~~~", nodeList);
  41         let res = [];
  42         let low = -1;
  43         let up = nodeList[0];
  44         for (var i = 0; i < nodeList.length; i++) {
  45             res.push(items.slice(low + 1, up + 1));
  46             low = nodeList[i];
  47             up = nodeList[i + 1];
  48         }
  49         return res;
  50     }
  51     /**genrate the list of point of breaking line. it returns a correct list ascending*/
  52     generateBreakLineNodeList() {
  53         let res = [];
  54         var pointer = this.prevNodes.length - 1;
  55         while (this.prevNodes[pointer] !== undefined) {
  56             res.push(pointer);
  57             pointer = this.prevNodes[pointer];
  58         }
  59         return res.reverse();
  60     }
  61     /** measuring new-line triggered advance width */
  62     newLineWidth(item) {
  63         if (this.isBreakPoint(item)) {
  64             return this.origWidth(item.newLined);
  65         }
  66         else {
  67             // impossible to make a new line
  68             return Infinity;
  69         }
  70     }
  71     /**
  72      * check all the total cost of paragraphes of the segnemt
  73      */
  74     totalCost(items, lineWidth) {
  75         let itemsLength = items.length;
  76         this.lineCostStorage = Array(itemsLength);
  77         this.prevNodes = Array(itemsLength).fill(null);
  78         for (var i = 0; i < itemsLength; i++) {
  79             this.lineCostStorage[i] = Array(itemsLength).fill(undefined);
  80         }
  81         this.totalCostAuxStorage = Array(itemsLength).fill(undefined);
  82         console.log("===", itemsLength);
  83         let a = this.totalCostAux(items, itemsLength - 1, lineWidth);
  84         console.log(this.lineCostStorage);
  85         return a;
  86     }
  87     /**
  88      * check the total cost item[0..j].
  89      * @param items
  90      * @param i
  91      * @param lineWidth
  92      */
  93     totalCostAux(items, j, lineWidth) {
  94         if (this.totalCostAuxStorage[j] !== undefined) {
  95             return this.totalCostAuxStorage[j];
  96         }
  97         let rawLineCost = this.lineCost(items, 0, j, lineWidth);
  98         if (rawLineCost != Infinity) {
  99             this.totalCostAuxStorage[j] = rawLineCost;
 100             return rawLineCost;
 101         }
 102         else {
 103             var returnCost = Infinity;
 104             for (var k = 0; k < j; k++) {
 105                 let tmp = this.totalCostAux(items, k, lineWidth) + this.lineCost(items, k + 1, j, lineWidth);
 106                 if (returnCost > tmp) {
 107                     this.prevNodes[j] = k;
 108                     returnCost = tmp;
 109                 }
 110             }
 111             this.totalCostAuxStorage[j] = returnCost;
 112             return returnCost;
 113         }
 114         return returnCost;
 115     }
 116     /**
 117      * check the line cost of a line containing items[i..j]
 118      * @param items items of box
 119      * @param i beginning (excluded)
 120      * @param j end of the line
 121      * @param lineWidth line width
 122      */
 123     lineCost(items, i, j, lineWidth) {
 124         if (this.lineCostStorage[i] !== undefined && this.lineCostStorage[i][j] !== undefined) {
 125             return this.lineCostStorage[i][j];
 126         }
 127         if (!this.isBreakPoint(items[j])) {
 128             this.lineCostStorage[i][j] = Infinity;
 129             return Infinity;
 130         }
 131         else {
 132             var tmpItemWidth = 0;
 133             for (var k = i; k < j; k++) {
 134                 tmpItemWidth += this.origWidth(items[k]);
 135             }
 136             tmpItemWidth += this.newLineWidth(items[j]);
 137             if (tmpItemWidth > lineWidth) {
 138                 this.lineCostStorage[i][j] = Infinity;
 139                 return Infinity;
 140             }
 141             else {
 142                 let returnValue = (lineWidth - tmpItemWidth) ** 3.0;
 143                 this.lineCostStorage[i][j] = returnValue;
 144                 return returnValue;
 145             }
 146         }
 147     }
 148 }
 149 exports.BreakLineAlgorithm = BreakLineAlgorithm;