hist/RPavePainter.mjs

  1. import { settings } from '../core.mjs';
  2. import { makeTranslate } from '../base/BasePainter.mjs';
  3. import { RObjectPainter } from '../base/RObjectPainter.mjs';
  4. import { ensureRCanvas } from '../gpad/RCanvasPainter.mjs';
  5. import { addDragHandler } from '../gpad/TFramePainter.mjs';
  8. const ECorner = { kTopLeft: 1, kTopRight: 2, kBottomLeft: 3, kBottomRight: 4 };
  10. /**
  11.  * @summary Painter for RPave class
  12.  *
  13.  * @private
  14.  */
  16. class RPavePainter extends RObjectPainter {
  18.    /** @summary Draw pave content
  19.      * @desc assigned depending on pave class */
  20.    async drawContent() { return this; }
  22.    /** @summary Draw pave */
  23.    async drawPave() {
  24.       const rect = this.getPadPainter().getPadRect(),
  25.             fp = this.getFramePainter();
  27.       this.onFrame = fp && this.v7EvalAttr('onFrame', true);
  28.       this.corner = this.v7EvalAttr('corner', ECorner.kTopRight);
  30.       const visible = this.v7EvalAttr('visible', true),
  31.             offsetx = this.v7EvalLength('offsetX', rect.width, 0.02),
  32.             offsety = this.v7EvalLength('offsetY', rect.height, 0.02),
  33.             pave_width = this.v7EvalLength('width', rect.width, 0.3),
  34.             pave_height = this.v7EvalLength('height', rect.height, 0.3);
  36.       this.createG();
  38.       this.draw_g.classed('most_upper_primitives', true); // this primitive will remain on top of list
  40.       if (!visible)
  41.          return this;
  43.       this.createv7AttLine('border_');
  45.       this.createv7AttFill();
  47.       const fr = this.onFrame ? fp.getFrameRect() : rect;
  48.       let pave_x = 0, pave_y = 0;
  49.       switch (this.corner) {
  50.          case ECorner.kTopLeft:
  51.             pave_x = fr.x + offsetx;
  52.             pave_y = fr.y + offsety;
  53.             break;
  54.          case ECorner.kBottomLeft:
  55.             pave_x = fr.x + offsetx;
  56.             pave_y = fr.y + fr.height - offsety - pave_height;
  57.             break;
  58.          case ECorner.kBottomRight:
  59.             pave_x = fr.x + fr.width - offsetx - pave_width;
  60.             pave_y = fr.y + fr.height - offsety - pave_height;
  61.             break;
  62.          case ECorner.kTopRight:
  63.          default:
  64.             pave_x = fr.x + fr.width - offsetx - pave_width;
  65.             pave_y = fr.y + offsety;
  66.       }
  68.       makeTranslate(this.draw_g, pave_x, pave_y);
  70.       this.draw_g.append('svg:rect')
  71.                  .attr('x', 0)
  72.                  .attr('width', pave_width)
  73.                  .attr('y', 0)
  74.                  .attr('height', pave_height)
  75.                  .call(this.lineatt.func)
  76.                  .call(this.fillatt.func);
  78.       this.pave_width = pave_width;
  79.       this.pave_height = pave_height;
  81.       // here should be fill and draw of text
  83.       return this.drawContent().then(() => {
  84.          if (!this.isBatchMode()) {
  85.             // TODO: provide pave context menu as in v6
  86.             if (settings.ContextMenu && this.paveContextMenu)
  87.                this.draw_g.on('contextmenu', evnt => this.paveContextMenu(evnt));
  89.             addDragHandler(this, { x: pave_x, y: pave_y, width: pave_width, height: pave_height,
  90.                                    minwidth: 20, minheight: 20, redraw: d => this.sizeChanged(d) });
  91.          }
  93.          return this;
  94.       });
  95.    }
  97.    /** @summary Process interactive moving of the stats box */
  98.    sizeChanged(drag) {
  99.       this.pave_width = drag.width;
  100.       this.pave_height = drag.height;
  102.       const pave_x = drag.x,
  103.             pave_y = drag.y,
  104.             rect = this.getPadPainter().getPadRect(),
  105.             fr = this.onFrame ? this.getFramePainter().getFrameRect() : rect,
  106.             changes = {};
  107.       let offsetx, offsety;
  109.       switch (this.corner) {
  110.          case ECorner.kTopLeft:
  111.             offsetx = pave_x - fr.x;
  112.             offsety = pave_y - fr.y;
  113.             break;
  114.          case ECorner.kBottomLeft:
  115.             offsetx = pave_x - fr.x;
  116.             offsety = fr.y + fr.height - pave_y - this.pave_height;
  117.             break;
  118.          case ECorner.kBottomRight:
  119.             offsetx = fr.x + fr.width - pave_x - this.pave_width;
  120.             offsety = fr.y + fr.height - pave_y - this.pave_height;
  121.             break;
  122.          case ECorner.kTopRight:
  123.          default:
  124.             offsetx = fr.x + fr.width - pave_x - this.pave_width;
  125.             offsety = pave_y - fr.y;
  126.       }
  128.       this.v7AttrChange(changes, 'offsetX', offsetx / rect.width);
  129.       this.v7AttrChange(changes, 'offsetY', offsety / rect.height);
  130.       this.v7AttrChange(changes, 'width', this.pave_width / rect.width);
  131.       this.v7AttrChange(changes, 'height', this.pave_height / rect.height);
  132.       this.v7SendAttrChanges(changes, false); // do not invoke canvas update on the server
  134.       this.draw_g.selectChild('rect')
  135.                  .attr('width', this.pave_width)
  136.                  .attr('height', this.pave_height);
  138.       this.drawContent();
  139.    }
  141.    /** @summary Redraw RPave object */
  142.    async redraw(/* reason */) {
  143.       return this.drawPave();
  144.    }
  146.    /** @summary draw RPave object */
  147.    static async draw(dom, pave, opt) {
  148.       const painter = new RPavePainter(dom, pave, opt, 'pave');
  149.       return ensureRCanvas(painter, false).then(() => painter.drawPave());
  150.    }
  152. }
  155. /**
  156.  * @summary Painter for RLegend class
  157.  *
  158.  * @private
  159.  */
  161. class RLegendPainter extends RPavePainter {
  163.    /** @summary draw RLegend content */
  164.    async drawContent() {
  165.       const legend = this.getObject(),
  166.             textFont = this.v7EvalFont('text', { size: 12, color: 'black', align: 22 }),
  167.             width = this.pave_width,
  168.             height = this.pave_height,
  169.             pp = this.getPadPainter();
  171.       let nlines = legend.fEntries.length;
  172.       if (legend.fTitle) nlines++;
  174.       if (!nlines || !pp) return this;
  176.       const stepy = height / nlines, margin_x = 0.02 * width;
  178.       textFont.setSize(height/(nlines * 1.2));
  179.       return this.startTextDrawingAsync(textFont, 'font').then(() => {
  180.          let posy = 0;
  182.          if (legend.fTitle) {
  183.             this.drawText({ latex: 1, width: width - 2*margin_x, height: stepy, x: margin_x, y: posy, text: legend.fTitle });
  184.             posy += stepy;
  185.          }
  187.          for (let i = 0; i < legend.fEntries.length; ++i) {
  188.             const entry = legend.fEntries[i], w4 = Math.round(width/4);
  189.             let objp = null;
  191.             this.drawText({ latex: 1, width: 0.75*width - 3*margin_x, height: stepy, x: 2*margin_x + w4, y: posy, text: entry.fLabel });
  193.             if (entry.fDrawableId !== 'custom')
  194.                objp = pp.findSnap(entry.fDrawableId, true);
  195.             else if (entry.fDrawable.fIO) {
  196.                objp = new RObjectPainter(this.getPadPainter(), entry.fDrawable.fIO);
  197.                if (entry.fLine) objp.createv7AttLine();
  198.                if (entry.fFill) objp.createv7AttFill();
  199.                if (entry.fMarker) objp.createv7AttMarker();
  200.             }
  202.             if (entry.fFill && objp?.fillatt) {
  203.                this.draw_g
  204.                   .append('svg:path')
  205.                   .attr('d', `M${Math.round(margin_x)},${Math.round(posy + stepy*0.1)}h${w4}v${Math.round(stepy*0.8)}h${-w4}z`)
  206.                   .call(objp.fillatt.func);
  207.             }
  209.             if (entry.fLine && objp?.lineatt) {
  210.                this.draw_g
  211.                   .append('svg:path')
  212.                   .attr('d', `M${Math.round(margin_x)},${Math.round(posy + stepy/2)}h${w4}`)
  213.                   .call(objp.lineatt.func);
  214.             }
  216.             if (entry.fError && objp?.lineatt) {
  217.                this.draw_g
  218.                   .append('svg:path')
  219.                   .attr('d', `M${Math.round(margin_x + width/8)},${Math.round(posy + stepy*0.2)}v${Math.round(stepy*0.6)}`)
  220.                   .call(objp.lineatt.func);
  221.             }
  223.             if (entry.fMarker && objp?.markeratt) {
  224.                this.draw_g.append('svg:path')
  225.                   .attr('d', objp.markeratt.create(margin_x + width/8, posy + stepy/2))
  226.                   .call(objp.markeratt.func);
  227.             }
  229.             posy += stepy;
  230.          }
  232.          return this.finishTextDrawing();
  233.       });
  234.    }
  236.    /** @summary draw RLegend object */
  237.    static async draw(dom, legend, opt) {
  238.       const painter = new RLegendPainter(dom, legend, opt, 'legend');
  239.       return ensureRCanvas(painter, false).then(() => painter.drawPave());
  240.    }
  242. } // class RLegendPainter
  245. /**
  246.  * @summary Painter for RPaveText class
  247.  *
  248.  * @private
  249.  */
  251. class RPaveTextPainter extends RPavePainter {
  253.    /** @summary draw RPaveText content */
  254.    async drawContent() {
  255.       const pavetext = this.getObject(),
  256.             textFont = this.v7EvalFont('text', { size: 12, color: 'black', align: 22 }),
  257.             width = this.pave_width,
  258.             height = this.pave_height,
  259.             nlines = pavetext.fText.length;
  261.       if (!nlines) return;
  263.       const stepy = height / nlines, margin_x = 0.02 * width;
  265.       textFont.setSize(height/(nlines * 1.2));
  267.       return this.startTextDrawingAsync(textFont, 'font').then(() => {
  268.          for (let i = 0, posy = 0; i < pavetext.fText.length; ++i, posy += stepy)
  269.             this.drawText({ latex: 1, width: width - 2*margin_x, height: stepy, x: margin_x, y: posy, text: pavetext.fText[i] });
  271.          return this.finishTextDrawing(undefined, true);
  272.       });
  273.    }
  275.    /** @summary draw RPaveText object */
  276.    static async draw(dom, pave, opt) {
  277.       const painter = new RPaveTextPainter(dom, pave, opt, 'pavetext');
  278.       return ensureRCanvas(painter, false).then(() => painter.drawPave());
  279.    }
  281. } // class RPaveTextPainter
  283. export { RPavePainter, RLegendPainter, RPaveTextPainter };