帆软js文档

已于 2024-07-08 16:57:30 修改
阅读量392 收藏 2
点赞数
分类专栏： 实用技巧 笔记 文章标签： javascript 前端 开发语言
于 2023-08-22 18:19:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lang_Ren_g/article/details/132433529
版权

js切换tab

_g().getWidgetByName(‘tabpane1_c’).showCardByIndex(0);

js打开对话框

FR.doHyperlinkByGet({
	//报表路径
	"url":"/webroot/decision/view/report?viewlet=***/****.cpt&op=write",    //参数
	"para":{
		"__pi__":true,    //是否显示参数面板

		"consumer_id":card_number
///		"sdept_id_budget_p":sdept_id_budget,
		//"smonth":smonth,
		//"sweek":sweek,
		//"enable":"0"
		},
	"target":"_dialog",    //对话框方式打开
	"feature":{
		"width":1400,
		"height":700,
		"isCenter":true,     //是否居中显示
		"title":"详情"
		}

	})
			$(".fr-core-panel-header.fr-core-panel-style-blue.fr-core-window-header").css("background-color","#496897")

js刷新

var zhi = _g().getWidgetByName('report0_c').getCellValue("B1"); if (zhi == 1111) { zhi = ""; _g().getWidgetByName('report0_c').setCellValue("B1", zhi + 1); _g().getWidgetByName('report0_c').setCellValue("C1", id); //para1 = id; _g().getWidgetByName('textEditor3').setValue(id); _g().getWidgetByName('rHIframe0_c').reload(); //rHIframe1为父模板需要刷新的网页框控件名 }; if (zhi == 111) { _g().getWidgetByName('report0_c').setCellValue("B1", zhi + 1); _g().getWidgetByName('report0_c').setCellValue("D1", id); //para1 = id; _g().getWidgetByName('textEditor2').setValue(id); _g().getWidgetByName('rHIframe0_c_c').reload(); //rHIframe1为父模板需要刷新的网页框控件名 }; if (zhi == 11) { _g().getWidgetByName('report0_c').setCellValue("B1", zhi + 1); _g().getWidgetByName('report0_c').setCellValue("E1", id); // para1=id; _g().getWidgetByName('textEditor1').setValue(id); _g().getWidgetByName('rHIframe0_c_c_c').reload(); //rHIframe1为父模板需要刷新的网页框控件名 }; if (zhi == 1) { _g().getWidgetByName('report0_c').setCellValue("B1", zhi + 1); _g().getWidgetByName('report0_c').setCellValue("F1", id); _g().getWidgetByName('textEditor0').setValue(id); // para1=id; _g().getWidgetByName('rHIframe0_c_c_c_c').reload(); //rHIframe1为父模板需要刷新的网页框控件名 };

js切换tab页

_g().getWidgetByName('tabpane1_c').showCardByIndex(1);

决策报表表格跑马灯

setTimeout(function(){
     _g().getWidgetByName('XXXXXXX').startMarquee({
		offset: 2,
		interval: 0.3
		//stopOnHover: false
		//to: 'left'
	});
}, 9500);

帆软集成echarts制作3d饼图

var TABLE_DATA = getData('data1'); // 获取数据
// 处理数据
const a = TABLE_DATA.splice(0,1); // 删除数组第一个元素
// 将带过来的嵌套数组转化成常规数组
const data = TABLE_DATA.map(item => ({
   name: item[0], 
   ID: item[1] 
}));
// 将数据根据ID进行排序
const pieData = data.sort((a,b)=> a.ID - b.ID);
// console.log(pieData)
// const TABLE_DATA = [
//   {
//     转让方客户类型: '民营资产交易',
//     ID: 52
//     // itemStyle: {
//     //   // color: '#1c74f8cc',
//     //   color: '#1C74F8',
//     // },
//   },
//   {
//     转让方客户类型: '行政事业性国有资产交易',
//     ID: 614
//   },
//   {
//     转让方客户类型: '企业国有资产交易',
//     ID: 585
//   },
//   {
//     转让方客户类型: '金融企业国有资产交易',
//     ID: 84
//   },
//   {
//     转让方客户类型: '金融机构资产交易',
//     ID: 147
//   },
//   {
//     转让方客户类型: '罚没资产交易',
//     ID: 377
//   },
//   {
//     转让方客户类型: '其他交易',
//     ID: 1
//   }
// ];
const colorList = [
  '#042DC7',
  '#1955CF',
  '#3C7ED4',
  '#619DD9',
  '#86BBDD',
  '#A7CDE2',
  '#B6D8E9'
];
option = {};

function init() {
  const paramsList = pieData.map((item, index) => {
    return {
      ...item,
      shading: 'realistic',
      itemStyle: {
        color: colorList[index]
      }
    };
  });
  // 构建3d饼状图

  // 传入数据生成 option

  option = getPie3D(paramsList, 0.8);

  console.log(option);
  // 是否需要label指引线，如果要就添加一个透明的2d饼状图并调整角度使得labelLine和3d的饼状图对齐，并再次setOption
  option.series.push({
    name: 'pie2d',
    // type: 'pie',
    // labelLine: {
    //   length: 10,
    //   length2: 10
    // },
    startAngle: -30, // 起始角度，支持范围[0, 360]。
    clockwise: false, // 饼图的扇区是否是顺时针排布。上述这两项配置主要是为了对齐3d的样式
    radius: ['20%', '50%'],
    center: ['50%', '50%'],
    data: pieData,
    itemStyle: {
      opacity: 0
    }
  });
  myChart.setOption(option);
  bindListen();
}
// 生成模拟 3D 饼图的配置项
function getPie3D(pieData, internalDiameterRatio) {
  let that = this;
  let series = [];
  let sumValue = 0;
  let startValue = 0;
  let endValue = 0;
  let legendData = [];
  let legendBfb = [];
  let k = 1 - internalDiameterRatio;
  // 为每一个饼图数据，生成一个 series-surface 配置
  for (let i = 0; i < pieData.length; i++) {
    sumValue += pieData[i].ID;
    let seriesItem = {
      name:
        typeof pieData[i].name === 'undefined' ? `series${i}` : pieData[i].name,
      type: 'surface',
      parametric: true,
      wireframe: {
        show: false
      },
      pieData: pieData[i],
      pieStatus: {
        selected: false,
        hovered: false,
        k: k
      },
      center: ['10%', '50%']
    };

    if (typeof pieData[i].itemStyle != 'undefined') {
      let itemStyle = {};
      if (typeof pieData[i].itemStyle.color != 'undefined') {
        itemStyle.color = pieData[i].itemStyle.color;
      }
      if (typeof pieData[i].itemStyle.opacity != 'undefined') {
        itemStyle.opacity = pieData[i].itemStyle.opacity;
      }
      seriesItem.itemStyle = itemStyle;
    }
    series.push(seriesItem);
  }
  // 使用上一次遍历时，计算出的数据和 sumValue，调用 getParametricEquation 函数，
  // 向每个 series-surface 传入不同的参数方程 series-surface.parametricEquation，也就是实现每一个扇形。
  legendData = [];
  legendBfb = [];
  for (let i = 0; i < series.length; i++) {
    endValue = startValue + series[i].pieData.ID;
    series[i].pieData.startRatio = startValue / sumValue;
    series[i].pieData.endRatio = endValue / sumValue;
    series[i].parametricEquation = getParametricEquation(
      series[i].pieData.startRatio,
      series[i].pieData.endRatio,
      false,
      false,
      k,
      series[i].pieData.ID
    );
    startValue = endValue;
    // legendData.push(series[i].name);
    // let bfb = that.fomatFloat(series[i].pieData.value / sumValue, 4);
    legendData.push({
      name: series[i].name,
      // value: bfb
    });
    legendBfb.push({
      name: series[i].name,
      // value: bfb
    });
  }
  let boxHeight = getHeight3D(series, 26);
  // 补充一个透明的圆环，用于支撑高亮功能的近似实现。
  // series.push({
  //   name: 'mouseoutSeries',
  //   type: 'surface',
  //   parametric: true,
  //   wireframe: {
  //     show: false
  //   },
  //   itemStyle: {
  //     opacity: 0
  //   },
  //   parametricEquation: {
  //     u: {
  //       min: 0,
  //       max: Math.PI * 2,
  //       step: Math.PI / 20
  //     },
  //     v: {
  //       min: 0,
  //       max: Math.PI,
  //       step: Math.PI / 20
  //     },
  //     x: function (u, v) {
  //       return Math.sin(v) * Math.sin(u) + Math.sin(u);
  //     },
  //     y: function (u, v) {
  //       return Math.sin(v) * Math.cos(u) + Math.cos(u);
  //     },
  //     z: function (u, v) {
  //       return Math.cos(v) > 0 ? 0.1 : -0.1;
  //     }
  //   }
  // });
  // 准备待返回的配置项，把准备好的 legendData、series 传入。
  const option = {
    legend: {
      data: legendData,
      orient: 'horizontal',
      // left: 10,
      // top: 10,
      bottom:'1%',
      width:450,
      itemGap: 10,
      // textStyle: {
      //   fontSize:'16px',
      //   color: '#A1E2FF'
      // },
      show: true,
      icon: 'circle',
      // formatter: function (param) {
      //   let item = legendBfb.filter((item) => item.name == param)[0];
      //   // let bfs = that.fomatFloat(item.value * 100, 2) + '%';
      //   return `${item.name}`;
      // },
      formatter: ['{a|{name}}'].join('\n'),
      textStyle: {
        rich: {
          a: {
            width: 120, // 每个图例的宽度，具体根据字数调整
            lineHeight: 10,
            fontSize:'16px',
            color:'#A1E2FF',
          },
        }
      }
    },
    labelLine: {
      show: true,
      lineStyle: {
        color: '#7BC0CB'
      }
    },
    label: {
      show: true,
      position: 'outside',
      rich: {
        b: {
          color: '#7BC0CB',
          fontSize: 12,
          lineHeight: 20
        },
        c: {
          fontSize: 16
        }
      },
      formatter: '{b|{b} \n}{c|{c}}{b|  亩}'
    },
    tooltip: {
      formatter: (params) => {
        if (
          params.seriesName !== 'mouseoutSeries' &&
          params.seriesName !== 'pie2d'
        ) {
          let bfb = (
            (option.series[params.seriesIndex].pieData.endRatio -
              option.series[params.seriesIndex].pieData.startRatio) *
            100
          ).toFixed(2);
          return (
            `${params.seriesName}<br/>` +
            `<span style="display:inline-block;margin-right:5px;border-radius:10px;width:10px;height:10px;background-color:${params.color};"></span>` +
            `${bfb}%`
          );
        }
      }
    },
    xAxis3D: {
      min: -1,
      max: 1
    },
    yAxis3D: {
      min: -1,
      max: 1
    },
    zAxis3D: {
      min: -1,
      max: 1
    },
    grid3D: {
      show: false,
      boxHeight: boxHeight, //圆环的高度
      top: '-10%',
      left: '-6%',
      viewControl: {
        //3d效果可以放大、旋转等，请自己去查看官方配置
        alpha: 40, //角度
        distance: 180, //调整视角到主体的距离，类似调整zoom
        rotateSensitivity: 1, //设置为0无法旋转
        zoomSensitivity: 1, //设置为0无法缩放
        panSensitivity: 1, //设置为0无法平移
        autoRotate: true //自动旋转
      }
    },
    series: series
  };
  return option;
}
// 获取3d丙图的最高扇区的高度
function getHeight3D(series, height) {
  series.sort((a, b) => b.pieData.ID - a.pieData.ID);
  return (height * 15) / series[0].pieData.ID;
}

// 生成扇形的曲面参数方程，用于 series-surface.parametricEquation
function getParametricEquation(
  startRatio,
  endRatio,
  isSelected,
  isHovered,
  k,
  h
) {
  // 计算
  let midRatio = (startRatio + endRatio) / 2;

  let startRadian = startRatio * Math.PI * 2;
  let endRadian = endRatio * Math.PI * 2;
  let midRadian = midRatio * Math.PI * 2;

  // 如果只有一个扇形，则不实现选中效果。
  if (startRatio === 0 && endRatio === 1) {
    isSelected = false;
  }
  // 通过扇形内径/外径的值，换算出辅助参数 k（默认值 1/3）
  k = typeof k !== 'undefined' ? k : 1 / 3;

  // 计算选中效果分别在 x 轴、y 轴方向上的位移（位移均为 0）
  // 计算选中效果分别在 x 轴、y 轴方向上的位移（未选中，则位移均为 0）
  let offsetX = isSelected ? Math.cos(midRadian) * 0.1 : 0;
  let offsetY = isSelected ? Math.sin(midRadian) * 0.1 : 0;
  // 计算选中效果在 z 轴方向上的位移（未选中，位移均为 0）
  let offsetZ = isSelected ? 0.15 : 0;
  // 计算高亮效果的放大比例（未高亮，则比例为 1）
  let hoverRate = isHovered ? 1.05 : 1;

  // let tmp = 0;

  // 返回曲面参数方程
  return {
    u: {
      min: -Math.PI,
      max: Math.PI * 3,
      step: Math.PI / 32
    },

    v: {
      min: 0,
      max: Math.PI * 2,
      step: Math.PI / 20
    },

    x: function (u, v) {
      if (u < startRadian) {
        return (
          offsetX + Math.cos(startRadian) * (1 + Math.cos(v) * k) * hoverRate
        );
      }
      if (u > endRadian) {
        return (
          offsetX + Math.cos(endRadian) * (1 + Math.cos(v) * k) * hoverRate
        );
      }
      return offsetX + Math.cos(u) * (1 + Math.cos(v) * k) * hoverRate;
    },
    y: function (u, v) {
      if (u < startRadian) {
        return (
          offsetY + Math.sin(startRadian) * (1 + Math.cos(v) * k) * hoverRate
        );
      }
      if (u > endRadian) {
        return (
          offsetY + Math.sin(endRadian) * (1 + Math.cos(v) * k) * hoverRate
        );
      }
      return offsetY + Math.sin(u) * (1 + Math.cos(v) * k) * hoverRate;
    },
    z: function (u, v) {
      if (u < -Math.PI * 0.5) {
        return Math.sin(u);
      }
      if (u > Math.PI * 2.5) {
        return Math.sin(u) * h * 0.1;
      }
      return Math.sin(v) > 0 ? 1 * h * 0.1 : -1;
    }
  };
}

// function fomatFloat(num, n) {
//   let f = parseFloat(num);
//   // eslint-disable-next-line no-restricted-globals
//   if (isNaN(f)) {
//     return false;
//   }
//   // eslint-disable-next-line no-restricted-properties
//   f = Math.round(num * Math.pow(10, n)) / Math.pow(10, n); // n 幂
//   let s = f.toString();
//   let rs = s.indexOf('.');
//   // 判定如果是整数，增加小数点再补0
//   if (rs < 0) {
//     rs = s.length;
//     s += '.';
//   }
//   while (s.length <= rs + n) {
//     s += '0';
//   }
//   return s;
// }

function bindListen() {
  // 监听鼠标事件，实现饼图选中效果（单选），近似实现高亮（放大）效果。
  const that = this;
  let selectedIndex = '';
  let hoveredIndex = '';
  // 监听点击事件，实现选中效果（单选）
  myChart.on('click', (params) => {
    // 从 option.series 中读取重新渲染扇形所需的参数，将是否选中取反。
    const isSelected =
      !that.option.series[params.seriesIndex].pieStatus.selected;
    const isHovered = that.option.series[params.seriesIndex].pieStatus.hovered;
    const { k } = that.option.series[params.seriesIndex].pieStatus;
    const { startRatio } = that.option.series[params.seriesIndex].pieData;
    const { endRatio } = that.option.series[params.seriesIndex].pieData;
    // 如果之前选中过其他扇形，将其取消选中（对 option 更新）
    if (selectedIndex !== '' && selectedIndex !== params.seriesIndex) {
      that.option.series[selectedIndex].parametricEquation =
        that.getParametricEquation(
          that.option.series[selectedIndex].pieData.startRatio,
          that.option.series[selectedIndex].pieData.endRatio,
          false,
          false,
          k,
          that.option.series[selectedIndex].pieData.value
        );
      that.option.series[selectedIndex].pieStatus.selected = false;
    }
    // 对当前点击的扇形，执行选中/取消选中操作（对 option 更新）
    that.option.series[params.seriesIndex].parametricEquation =
      that.getParametricEquation(
        startRatio,
        endRatio,
        isSelected,
        isHovered,
        k,
        80
      ); // 高亮时扇形的高度
    that.option.series[params.seriesIndex].pieStatus.selected = isSelected;
    // 如果本次是选中操作，记录上次选中的扇形对应的系列号 seriesIndex
    // eslint-disable-next-line no-unused-expressions
    isSelected ? (selectedIndex = params.seriesIndex) : null;
    // 使用更新后的 option，渲染图表
    myChart.setOption(that.option);
  });
  // 监听 mouseover，近似实现高亮（放大）效果
  myChart.on('mouseover', (params) => {
    // 准备重新渲染扇形所需的参数
    let isSelected;
    let isHovered;
    let startRatio;
    let endRatio;
    let k;
    // 如果触发 mouseover 的扇形当前已高亮，则不做操作
    if (hoveredIndex === params.seriesIndex) {
      // 否则进行高亮及必要的取消高亮操作
    } else {
      // 如果当前有高亮的扇形，取消其高亮状态（对 option 更新）
      if (hoveredIndex !== '') {
        // 从 option.series 中读取重新渲染扇形所需的参数，将是否高亮设置为 false。
        isSelected = that.option.series[hoveredIndex].pieStatus.selected;
        isHovered = false;
        // eslint-disable-next-line prefer-destructuring
        startRatio = that.option.series[hoveredIndex].pieData.startRatio;
        // eslint-disable-next-line prefer-destructuring
        endRatio = that.option.series[hoveredIndex].pieData.endRatio;
        // eslint-disable-next-line prefer-destructuring
        k = that.option.series[hoveredIndex].pieStatus.k;
        // 对当前点击的扇形，执行取消高亮操作（对 option 更新）
        that.option.series[hoveredIndex].parametricEquation =
          that.getParametricEquation(
            startRatio,
            endRatio,
            isSelected,
            isHovered,
            k,
            35
          ); // 35 为取消高亮时扇形的高度
        that.option.series[hoveredIndex].pieStatus.hovered = isHovered;
        // 将此前记录的上次选中的扇形对应的系列号 seriesIndex 清空
        hoveredIndex = '';
      }
      // 如果触发 mouseover 的扇形不是透明圆环，将其高亮（对 option 更新）
      if (
        params.seriesName !== 'mouseoutSeries' &&
        params.seriesName !== 'pie2d'
      ) {
        // 从 option.series 中读取重新渲染扇形所需的参数，将是否高亮设置为 true。
        isSelected = that.option.series[params.seriesIndex].pieStatus.selected;
        isHovered = true;
        // eslint-disable-next-line prefer-destructuring
        startRatio = that.option.series[params.seriesIndex].pieData.startRatio;
        // eslint-disable-next-line prefer-destructuring
        endRatio = that.option.series[params.seriesIndex].pieData.endRatio;
        // eslint-disable-next-line prefer-destructuring
        k = that.option.series[params.seriesIndex].pieStatus.k;
        // 对当前点击的扇形，执行高亮操作（对 option 更新）
        that.option.series[params.seriesIndex].parametricEquation =
          that.getParametricEquation(
            startRatio,
            endRatio,
            isSelected,
            isHovered,
            k,
            80
          ); // 高亮时扇形的高度
        that.option.series[params.seriesIndex].pieStatus.hovered = isHovered;
        // 记录上次高亮的扇形对应的系列号 seriesIndex
        hoveredIndex = params.seriesIndex;
      }
      // 使用更新后的 option，渲染图表
      myChart.setOption(that.option);
    }
  });
  // 修正取消高亮失败的 bug
  myChart.on('globalout', () => {
    // 准备重新渲染扇形所需的参数
    let isSelected;
    let isHovered;
    let startRatio;
    let endRatio;
    let k;
    if (hoveredIndex !== '') {
      // 从 option.series 中读取重新渲染扇形所需的参数，将是否高亮设置为 true。
      isSelected = that.option.series[hoveredIndex].pieStatus.selected;
      isHovered = false;
      // eslint-disable-next-line prefer-destructuring
      k = that.option.series[hoveredIndex].pieStatus.k;
      // eslint-disable-next-line prefer-destructuring
      startRatio = that.option.series[hoveredIndex].pieData.startRatio;
      // eslint-disable-next-line prefer-destructuring
      endRatio = that.option.series[hoveredIndex].pieData.endRatio;
      // 对当前点击的扇形，执行取消高亮操作（对 option 更新）
      that.option.series[hoveredIndex].parametricEquation =
        that.getParametricEquation(
          startRatio,
          endRatio,
          isSelected,
          isHovered,
          k,
          35
        ); // 取消高亮时扇形的高度
      that.option.series[hoveredIndex].pieStatus.hovered = isHovered;
      // 将此前记录的上次选中的扇形对应的系列号 seriesIndex 清空
      hoveredIndex = '';
    }
    // 使用更新后的 option，渲染图表
    myChart.setOption(that.option);
  });
}

init();


// const TABLE_DATA = getData('data1');
// const a = TABLE_DATA.splice(0,1);
// const optionData =  TABLE_DATA.map(item => ({ name: item[0], value: item[1] }));
const optionData = [
  {
    name: '法院',
    value: 280
    // itemStyle: {
    //   // color: '#1c74f8cc',
    //   color: '#1C74F8',
    // },
  },
  {
    name: '国有企业',
    value: 2059
  },
  {
    name: '行政事业单位',
    value: 6733
  },
  {
    name: '集体企业',
    value: 170
  },
  {
    name: '民营企业',
    value: 630
  },
  {
    name: '金融机构',
    value: 2683
  },
  {
    name: '其他机构',
    value: 230
  }
];
const colorList = ['#3553EA', '#29CAE5', '#14CE95', '#2196A8','#3D568B','#AFDAFE','#4369F1'];
option = {};

function init() {
  const paramsList = optionData.map((item, index) => {
    return {
      ...item,
      shading: 'realistic',
      itemStyle: {
        color: colorList[index]
      }
    };
  });
  // 构建3d饼状图

  // 传入数据生成 option

  option = getPie3D(paramsList);

  console.log(option);
  // 是否需要label指引线，如果要就添加一个透明的2d饼状图并调整角度使得labelLine和3d的饼状图对齐，并再次setOption
  option.series.push({
    name: 'pie2d',
    // type: 'pie',
    labelLine: {
      length: 10,
      length2: 10
    },
    startAngle: -30, // 起始角度，支持范围[0, 360]。
    clockwise: false, // 饼图的扇区是否是顺时针排布。上述这两项配置主要是为了对齐3d的样式
    radius: ['20%', '50%'],
    center: ['50%', '50%'],
    data: optionData,
    itemStyle: {
      opacity: 0
    }
  });
  myChart.setOption(option);
  bindListen();
}
// 生成模拟 3D 饼图的配置项
function getPie3D(pieData) {
  let series = [];
  let sumValue = 0;
  let startValue = 0;
  let endValue = 0;
  let legendData = [];
  // 为每一个饼图数据，生成一个 series-surface 配置
  for (let i = 0; i < pieData.length; i++) {
    sumValue += pieData[i].value;
    let seriesItem = {
      name:
        typeof pieData[i].name === 'undefined' ? `series${i}` : pieData[i].name,
      type: 'surface',
      parametric: true,
      wireframe: {
        show: false
      },
      pieData: pieData[i],
      pieStatus: {
        selected: false,
        hovered: false
      }
    };

    if (typeof pieData[i].itemStyle != 'undefined') {
      let itemStyle = {};
      if (typeof pieData[i].itemStyle.color != 'undefined') {
        itemStyle.color = pieData[i].itemStyle.color;
      }
      if (typeof pieData[i].itemStyle.opacity != 'undefined') {
        itemStyle.opacity = pieData[i].itemStyle.opacity;
      }
      seriesItem.itemStyle = itemStyle;
    }
    series.push(seriesItem);
  }
  // 使用上一次遍历时，计算出的数据和 sumValue，调用 getParametricEquation 函数，
  // 向每个 series-surface 传入不同的参数方程 series-surface.parametricEquation，也就是实现每一个扇形。
  for (let i = 0; i < series.length; i++) {
    endValue = startValue + series[i].pieData.value;
    series[i].pieData.startRatio = startValue / sumValue;
    series[i].pieData.endRatio = endValue / sumValue;
    series[i].parametricEquation = getParametricEquation(
      series[i].pieData.startRatio,
      series[i].pieData.endRatio,
      false,
      false
    );
    startValue = endValue;
    legendData.push(series[i].name);
  }
  // 补充一个透明的圆环，用于支撑高亮功能的近似实现。
  series.push({
    name: 'mouseoutSeries',
    type: 'surface',
    parametric: true,
    wireframe: {
      show: false
    },
    itemStyle: {
      opacity: 0
    },
    parametricEquation: {
      u: {
        min: 0,
        max: Math.PI * 2,
        step: Math.PI / 20
      },
      v: {
        min: 0,
        max: Math.PI,
        step: Math.PI / 20
      },
      x: function (u, v) {
        return Math.sin(v) * Math.sin(u) + Math.sin(u);
      },
      y: function (u, v) {
        return Math.sin(v) * Math.cos(u) + Math.cos(u);
      },
      z: function (u, v) {
        return Math.cos(v) > 0 ? 0.1 : -0.1;
      }
    }
  });
  // 准备待返回的配置项，把准备好的 legendData、series 传入。
  const option = {
    animation: true,
    // legend: {
    //   orient: 'vertical',
    //   data: legendData,
    //   textStyle: {
    //     color: 'rgba(150,202,223)',
    //     fontSize: 12,
    //   },
    //   itemWidth: 10,
    //   itemHeight: 10,
    //   icon: 'roundRect',
    //   bottom: 'bottom',
    //   // top: '0%', // 居右显示
    // },
    legend: {
      // orient: 'vertical',
      data: legendData,
      // right:0,
      bottom:'-2%',
      width:450,
      formatter: ['{a|{name}}'].join('\n'),
      textStyle: {
        rich: {
          a: {
            width: 175, // 每个图例的宽度，具体根据字数调整
            lineHeight: 10,
            color:'#A1E2FF',
            fontSize:'16px',
          }
        }
      }
    },
    tooltip: {
      trigger: 'item',
      // backgroundColor: '#ffffff00',
      // borderColor: '#ffffff00',
      // position: ['37%', '25%'], // tooltip固定位置
      formatter: (params) => {
        if (params.seriesName !== 'mouseoutSeries') {
          return `<div>
              <p style="font-size:20px;color:#000;font-weight:bold;margin:0">${
                option.series[params.seriesIndex].pieData.value
              }</p>
                            <p style="color:#000;text-align:center;margin:0">${
                              params.seriesName
                            }</p></div>`;
        }
        return '';
      }
    },
    labelLine: {
      show: true,
      lineStyle: {
        color: '#7BC0CB'
      }
    },
    label: {
      show: true,
      position: 'outside',
      formatter: '{b} \n{c} {d}'
    },
    // backgroundColor: '#333',
    // x,y,z调整大小的
    xAxis3D: {
      min: -1,
      max: 1
    },
    yAxis3D: {
      min: -1,
      max: 1
    },
    zAxis3D: {
      min: -1,
      max: 1
    },
    grid3D: {
      show: false,
      boxHeight: 200, // 饼环的高度
      top: '-22%',
      left: '-6%',
      // boxWidth:120,
      viewControl: {
        // 3d效果可以放大、旋转等，请自己去查看官方配置
        alpha: 50, //z轴旋转角度
        beta: 60, //x轴旋转角度
        rotateSensitivity: 1, // 旋转
        zoomSensitivity: 1, // 缩放
        panSensitivity: 1, // 平移
        autoRotate: true, // 旋转
        distance: 150 // 整视角到主体的距离，类似调整zoom  饼图大小
      }
      // 后处理特效可以为画面添加高光、景深、环境光遮蔽（SSAO）、调色等效果。可以让整个画面更富有质感。
      // postEffect: {
      //   // 配置这项会出现锯齿，请自己去查看官方配置有办法解决
      //   enable: false,
      //   bloom: {
      //     enable: true,
      //     bloomIntensity: 0.1,
      //   },
      //   SSAO: {
      //     enable: true,
      //     quality: 'medium',
      //     radius: 1,
      //   },
      //   // temporalSuperSampling: {
      //   //   enable: true,
      //   // },
      // },
    },
    series
  };
  return option;
}
// 获取3d丙图的最高扇区的高度
function getHeight3D(series, height) {
  series.sort((a, b) => b.pieData.value - a.pieData.value);
  return (height * 25) / series[0].pieData.value;
}

// 生成扇形的曲面参数方程，用于 series-surface.parametricEquation
function getParametricEquation(startRatio, endRatio, isSelected, isHovered) {
  // 计算
  let midRatio = (startRatio + endRatio) / 2;

  let startRadian = startRatio * Math.PI * 2;
  let endRadian = endRatio * Math.PI * 2;
  let midRadian = midRatio * Math.PI * 2;

  // 如果只有一个扇形，则不实现选中效果。
  if (startRatio === 0 && endRatio === 1) {
    isSelected = false;
  }

  // 计算选中效果分别在 x 轴、y 轴方向上的位移（位移均为 0）
  let offsetX = 0;
  let offsetY = 0;
  // 计算选中效果在 z 轴方向上的位移（未选中，位移均为 0）
  let offsetZ = isSelected ? 0.15 : 0;
  // 计算高亮效果的放大比例（未高亮，则比例为 1）
  let hoverRate = isHovered ? 1.05 : 1;

  let tmp = 0;

  // 返回曲面参数方程
  return {
    u: {
      min: 0,
      max: Math.PI * 2,
      step: Math.PI / 100
    },

    v: {
      min: 0,
      max: Math.PI,
      step: Math.PI / 50
    },

    x: function (u, v) {
      if (midRatio - 0.5 < 0) {
        if (u < startRadian || u > midRadian + Math.PI) {
          tmp =
            u - Math.PI - midRadian < 0
              ? u + Math.PI - midRadian
              : u - Math.PI - midRadian;
          return (
            offsetX +
            ((Math.sin(startRadian) * tmp) /
              (Math.PI - midRadian + startRadian)) *
              hoverRate
          );
        }
        if (u > endRadian && u < midRadian + Math.PI) {
          tmp = midRadian + Math.PI - u;
          return (
            offsetX +
            ((Math.sin(endRadian) * tmp) /
              (Math.PI - midRadian + startRadian)) *
              hoverRate
          );
        }
      } else {
        if (u < startRadian && u > midRadian - Math.PI) {
          tmp = u + Math.PI - midRadian;
          return (
            offsetX +
            ((Math.sin(startRadian) * tmp) /
              (Math.PI - midRadian + startRadian)) *
              hoverRate
          );
        }
        if (u > endRadian || u < midRadian - Math.PI) {
          tmp =
            midRadian - Math.PI - u < 0
              ? midRadian + Math.PI - u
              : midRadian - Math.PI - u;
          return (
            offsetX +
            ((Math.sin(endRadian) * tmp) /
              (Math.PI - midRadian + startRadian)) *
              hoverRate
          );
        }
      }
      return offsetX + Math.sin(v) * Math.sin(u) * hoverRate;
    },

    y: function (u, v) {
      if (midRatio - 0.5 < 0) {
        if (u < startRadian || u > midRadian + Math.PI) {
          tmp =
            u - Math.PI - midRadian < 0
              ? u + Math.PI - midRadian
              : u - Math.PI - midRadian;
          return (
            offsetY +
            ((Math.cos(startRadian) * tmp) /
              (Math.PI - midRadian + startRadian)) *
              hoverRate
          );
        }
        if (u > endRadian && u < midRadian + Math.PI) {
          tmp = midRadian + Math.PI - u;
          return (
            offsetY +
            ((Math.cos(endRadian) * tmp) /
              (Math.PI - midRadian + startRadian)) *
              hoverRate
          );
        }
      } else {
        if (u < startRadian && u > midRadian - Math.PI) {
          tmp = u + Math.PI - midRadian;
          return (
            offsetY +
            ((Math.cos(startRadian) * tmp) /
              (Math.PI - midRadian + startRadian)) *
              hoverRate
          );
        }
        if (u > endRadian || u < midRadian - Math.PI) {
          tmp =
            midRadian - Math.PI - u < 0
              ? midRadian + Math.PI - u
              : midRadian - Math.PI - u;
          return (
            offsetY +
            ((Math.cos(endRadian) * tmp) /
              (Math.PI - midRadian + startRadian)) *
              hoverRate
          );
        }
      }
      return offsetY + Math.sin(v) * Math.cos(u) * hoverRate;
    },

    z: function (u, v) {
      return offsetZ + (Math.cos(v) > 0 ? 0.1 : -0.1);
    }
  };
}
// function getParametricEquation(startRatio, endRatio, isSelected, isHovered, k, h) {
//   // 计算
//   const midRatio = (startRatio + endRatio) / 2;
//   const startRadian = startRatio * Math.PI * 2;
//   const endRadian = endRatio * Math.PI * 2;
//   const midRadian = midRatio * Math.PI * 2;
//   // 如果只有一个扇形，则不实现选中效果。
//   if (startRatio === 0 && endRatio === 1) {
//     // eslint-disable-next-line no-param-reassign
//     isSelected = false;
//   }
//   // 通过扇形内径/外径的值，换算出辅助参数 k（默认值 1/3）
//   // eslint-disable-next-line no-param-reassign
//   k = typeof k !== 'undefined' ? k : 1 / 3;
//   // 计算选中效果分别在 x 轴、y 轴方向上的位移（未选中，则位移均为 0）
//   // const offsetX = isSelected ? 0 : Math.cos(midRadian) * 0.2 ;
//   // const offsetY = isSelected ? 0 : Math.sin(midRadian) * 0.2;
//   const offsetX = isHovered ? Math.cos(midRadian) * 0.2 : Math.cos(midRadian)*0.1;
//   const offsetY = isHovered ? Math.sin(midRadian) * 0.2: Math.sin(midRadian)*0.1;
//   // 计算高亮效果的放大比例（未高亮，则比例为 1）
//   const hoverRate = isHovered ? 1.01 : 1;
//   // 返回曲面参数方程
//   return {
//     u: {
//       min: -Math.PI,
//       max: Math.PI * 3,
//       step: Math.PI / 32,
//     },
//     v: {
//       min: 0,
//       max: Math.PI * 2,
//       step: Math.PI / 20,
//     },
//     x(u, v) {
//       if (u < startRadian) {
//         return offsetX + Math.cos(startRadian) * (1 + Math.cos(v) * k) * hoverRate;
//       }
//       if (u > endRadian) {
//         return offsetX + Math.cos(endRadian) * (1 + Math.cos(v) * k) * hoverRate;
//       }
//       return offsetX + Math.cos(u) * (1 + Math.cos(v) * k) * hoverRate;
//     },
//     y(u, v) {
//       if (u < startRadian) {
//         return offsetY + Math.sin(startRadian) * (1 + Math.cos(v) * k) * hoverRate;
//       }
//       if (u > endRadian) {
//         return offsetY + Math.sin(endRadian) * (1 + Math.cos(v) * k) * hoverRate;
//       }
//       return offsetY + Math.sin(u) * (1 + Math.cos(v) * k) * hoverRate;
//     },
//     z(u, v) {
//       if (u < -Math.PI * 0.5) {
//         return Math.sin(u);
//       }
//       if (u > Math.PI * 2.5) {
//         return Math.sin(u) * h * 0.1;
//       }
//       return Math.sin(v) > 0 ? 1 * h * 0.1 : -1;
//     },
//   };
// }

function fomatFloat(num, n) {
  let f = parseFloat(num);
  // eslint-disable-next-line no-restricted-globals
  if (isNaN(f)) {
    return false;
  }
  // eslint-disable-next-line no-restricted-properties
  f = Math.round(num * Math.pow(10, n)) / Math.pow(10, n); // n 幂
  let s = f.toString();
  let rs = s.indexOf('.');
  // 判定如果是整数，增加小数点再补0
  if (rs < 0) {
    rs = s.length;
    s += '.';
  }
  while (s.length <= rs + n) {
    s += '0';
  }
  return s;
}

function bindListen() {
  // 监听鼠标事件，实现饼图选中效果（单选），近似实现高亮（放大）效果。
  const that = this;
  let selectedIndex = '';
  let hoveredIndex = '';
  // 监听点击事件，实现选中效果（单选）
  myChart.on('click', (params) => {
    // 从 option.series 中读取重新渲染扇形所需的参数，将是否选中取反。
    const isSelected =
      !that.option.series[params.seriesIndex].pieStatus.selected;
    const isHovered = that.option.series[params.seriesIndex].pieStatus.hovered;
    const { k } = that.option.series[params.seriesIndex].pieStatus;
    const { startRatio } = that.option.series[params.seriesIndex].pieData;
    const { endRatio } = that.option.series[params.seriesIndex].pieData;
    // 如果之前选中过其他扇形，将其取消选中（对 option 更新）
    if (selectedIndex !== '' && selectedIndex !== params.seriesIndex) {
      that.option.series[selectedIndex].parametricEquation =
        that.getParametricEquation(
          that.option.series[selectedIndex].pieData.startRatio,
          that.option.series[selectedIndex].pieData.endRatio,
          false,
          false,
          k,
          that.option.series[selectedIndex].pieData.value
        );
      that.option.series[selectedIndex].pieStatus.selected = false;
    }
    // 对当前点击的扇形，执行选中/取消选中操作（对 option 更新）
    that.option.series[params.seriesIndex].parametricEquation =
      that.getParametricEquation(
        startRatio,
        endRatio,
        isSelected,
        isHovered,
        k,
        80
      ); // 高亮时扇形的高度
    that.option.series[params.seriesIndex].pieStatus.selected = isSelected;
    // 如果本次是选中操作，记录上次选中的扇形对应的系列号 seriesIndex
    // eslint-disable-next-line no-unused-expressions
    isSelected ? (selectedIndex = params.seriesIndex) : null;
    // 使用更新后的 option，渲染图表
    myChart.setOption(that.option);
  });
  // 监听 mouseover，近似实现高亮（放大）效果
  myChart.on('mouseover', (params) => {
    // 准备重新渲染扇形所需的参数
    let isSelected;
    let isHovered;
    let startRatio;
    let endRatio;
    let k;
    // 如果触发 mouseover 的扇形当前已高亮，则不做操作
    if (hoveredIndex === params.seriesIndex) {
      // 否则进行高亮及必要的取消高亮操作
    } else {
      // 如果当前有高亮的扇形，取消其高亮状态（对 option 更新）
      if (hoveredIndex !== '') {
        // 从 option.series 中读取重新渲染扇形所需的参数，将是否高亮设置为 false。
        isSelected = that.option.series[hoveredIndex].pieStatus.selected;
        isHovered = false;
        // eslint-disable-next-line prefer-destructuring
        startRatio = that.option.series[hoveredIndex].pieData.startRatio;
        // eslint-disable-next-line prefer-destructuring
        endRatio = that.option.series[hoveredIndex].pieData.endRatio;
        // eslint-disable-next-line prefer-destructuring
        k = that.option.series[hoveredIndex].pieStatus.k;
        // 对当前点击的扇形，执行取消高亮操作（对 option 更新）
        that.option.series[hoveredIndex].parametricEquation =
          that.getParametricEquation(
            startRatio,
            endRatio,
            isSelected,
            isHovered,
            k,
            35
          ); // 35 为取消高亮时扇形的高度
        that.option.series[hoveredIndex].pieStatus.hovered = isHovered;
        // 将此前记录的上次选中的扇形对应的系列号 seriesIndex 清空
        hoveredIndex = '';
      }
      // 如果触发 mouseover 的扇形不是透明圆环，将其高亮（对 option 更新）
      if (
        params.seriesName !== 'mouseoutSeries' &&
        params.seriesName !== 'pie2d'
      ) {
        // 从 option.series 中读取重新渲染扇形所需的参数，将是否高亮设置为 true。
        isSelected = that.option.series[params.seriesIndex].pieStatus.selected;
        isHovered = true;
        // eslint-disable-next-line prefer-destructuring
        startRatio = that.option.series[params.seriesIndex].pieData.startRatio;
        // eslint-disable-next-line prefer-destructuring
        endRatio = that.option.series[params.seriesIndex].pieData.endRatio;
        // eslint-disable-next-line prefer-destructuring
        k = that.option.series[params.seriesIndex].pieStatus.k;
        // 对当前点击的扇形，执行高亮操作（对 option 更新）
        that.option.series[params.seriesIndex].parametricEquation =
          that.getParametricEquation(
            startRatio,
            endRatio,
            isSelected,
            isHovered,
            k,
            80
          ); // 高亮时扇形的高度
        that.option.series[params.seriesIndex].pieStatus.hovered = isHovered;
        // 记录上次高亮的扇形对应的系列号 seriesIndex
        hoveredIndex = params.seriesIndex;
      }
      // 使用更新后的 option，渲染图表
      myChart.setOption(that.option);
    }
  });
  // 修正取消高亮失败的 bug
  myChart.on('globalout', () => {
    // 准备重新渲染扇形所需的参数
    let isSelected;
    let isHovered;
    let startRatio;
    let endRatio;
    let k;
    if (hoveredIndex !== '') {
      // 从 option.series 中读取重新渲染扇形所需的参数，将是否高亮设置为 true。
      isSelected = that.option.series[hoveredIndex].pieStatus.selected;
      isHovered = false;
      // eslint-disable-next-line prefer-destructuring
      k = that.option.series[hoveredIndex].pieStatus.k;
      // eslint-disable-next-line prefer-destructuring
      startRatio = that.option.series[hoveredIndex].pieData.startRatio;
      // eslint-disable-next-line prefer-destructuring
      endRatio = that.option.series[hoveredIndex].pieData.endRatio;
      // 对当前点击的扇形，执行取消高亮操作（对 option 更新）
      that.option.series[hoveredIndex].parametricEquation =
        that.getParametricEquation(
          startRatio,
          endRatio,
          isSelected,
          isHovered,
          k,
          35
        ); // 取消高亮时扇形的高度
      that.option.series[hoveredIndex].pieStatus.hovered = isHovered;
      // 将此前记录的上次选中的扇形对应的系列号 seriesIndex 清空
      hoveredIndex = '';
    }
    // 使用更新后的 option，渲染图表
    myChart.setOption(that.option);
  });
}

init();

单元格点击变色


```javascript
var $lasttd; //上一个单元格变是
var lastcolor; //上一次颜色变量
$('.x-table td').click(function() {if($lasttd){$lasttd.css('background', lastcolor);}//离开后原单元格恢复原色
lastcolor = $(this).css('background-color');if (!lastcolor)lastcolor =$(this).css('background'); 
//保存原始颜色
$(this).css('background','red');
//设置当前单元格为红色
$lasttd = $(this): //保存上一个单元格
丿烂人丶
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【帆软FR】js实现分类汇总
a973995286的博客
06-14 1538
一、场景描述 1、目前有层级结构的数据可以通过将数据集转换为树数据集，然后结合下拉树或者视图树控件来展示，但是控件本身功能有限，无法在展示层级结构的同时满足填报计算+提交的效果 2、此类场景问题可以通过获取相邻单元格层级然后循环计算上下格数据，达到一个实时计算的效果。从基本的二层联动逻辑上出发，可以逐渐实现多层级自动计算效果，具体效果如下：多级联动计算效果： 二、二级联动 1、计算思路 （1）获取当前单元格值和对应层级的值，并用设置参数jj，公式值为len(value("测试表",1))，也就是获
帆软常用 js语句整理
fanjianlei1的博客
08-31 6557
帆软 js 使用整理
帆软报表js代码
CsbLanca
04-27 1003
在制金属数量帆软js代码: var rowList =$.data; var table = []; var column = ["纵坐标","铸轧卷待开坯卷数","铸轧卷待开坯重量","待冷轧1卷数","待冷轧1重量","冷轧1中卷数","冷轧1中重量","待冷轧2卷数","待冷轧2重量","冷轧2中卷数","冷轧2中重量","待冷轧3卷数","待冷轧3重量","冷轧3中卷数","冷轧3中重量"...
帆软：1、实现查询功能的js；2、循环10次，并调用10次，查询功能的js
weixin_50235904的博客
05-16 897
1、实现查询功能的js。
帆软：像阿甘一样，奔跑在商业智能的赛道上！
科技星象
12-16 1823
故事开始于一片洁白的羽毛，从空中降落缓缓飘过房屋、街道、树梢，最终落在了主人公阿甘的脚旁，他没有过多思考就将羽毛轻轻收藏书中……这是电影《阿甘正传 》中的经典一幕。 熟知电影的人都知道阿甘一生充满着不幸，天生智商仅有75的他本属于残障人士，甚至连最普通的学校都拒绝录取他，并因为身体的缺陷只能依靠“铁架”才能正常行走；但不幸的阿甘又是幸运的，他凭借天赋和后期的不懈努力，不但跑进了橄榄球队与大学，还...
帆软Report开发的相关问题点记录文档
10-11
5. **按钮添加点击事件**：在报表中添加按钮并设置JavaScript事件，如`alert()`或获取下拉框值，可以使用`this.options.form.getWidgetByName("客户")`来获取控件对象，然后通过`value`属性获取值。 6. **图表与...
帆软报表Oracle存储过程解决storeParameter1参数试用插件
12-12
如果你在安装或使用过程中遇到问题，建议参考帆软官方文档或寻求技术支持。 此外，对于Oracle存储过程，理解其基本概念和使用方法也是必要的。存储过程是预编译的SQL语句集合，可以封装复杂的业务逻辑，提高数据...
帆软fcra帮助树形文档.pdf
07-14
【帆软FCRA帮助树形文档】是针对帆软报表工具——FineReport的详细使用手册，涵盖多个方面，包括快速入门、设计思路、报表设计、参数应用、图表、填报、操作指南、授权注册、报表美化、移动端、大屏数据可视化、数据...
帆软fcra帮助树形文档.docx
07-14
【帆软FCRA帮助树形文档】主要涵盖了帆软报表工具FineReport的多个核心知识点，以下将对这些关键内容进行详细解析： 1. **升级兼容说明**：在更新到10.0版本时，需要了解关于软件升级的兼容性问题，确保现有的功能...
帆软报表软件FineReport帮助文档
03-01
FineReport报表软件功能编辑 自推出市场以来，FineReport得到多方用户的认可，同时也在不断的改良与升级中变得更加易用，功能更 加强大，也将会给用户带来更新更好的体验。 FineReport报表工具提供了易用且高效率的报表设计方案，采用主流的数据双向扩展，真正无编码形式设计报表模板；拥有强大的报表展示功能，并且提供完善的报表权限管理，报表调度管理；具有完备的报表填报功能，支持多级汇总填报。 有了FineReport报表工具，在软件开发过程中，可以革命性的加快开发速度，提高软件的稳定性；在软件交付后，可以大大的降低维护难度，提高最终用户的满意度。开发出的软件可以做到随需应变。 FineReport报表软件功能描述编辑 支持多类型的报表部署 饼图 饼图 报表服务器支持多种类型的应用，能够以各种方式进行系统集成： 1.JAVA程序的无缝集成 2.非java程序的调用 3.C/S架构的应用
FineReport报表工具内置JS的使用
11-12
FineReport报表工具内置JS的使用
FineReport帆软实现父窗口通过JS脚本传参到弹出对话框，并将数据更新到数据库后，关闭对话，刷新父窗口
m0_37887512的博客
09-05 2124
viewlet=你的路径/离心机生产间隔异常原因.cpt&txt_id=” + txt_id);FR.remoteEvaluate(‘=SQL(“你的数据连接名称”,"’ + sql + ‘",1,1)’);//alert(‘ID为：’ + id + “原因为：” + resion);FR.Msg.alert(“提示”, “ID不能为空！FR.Msg.alert(“提示”, “原因不能为空！
我的帆软踩坑日记之②JavaScript文件引用
最新发布
黑人の乔丹鞋的博客
04-24 383
在帆软开发中，可以给参数面板与表格中的按钮添加事件处理。事件处理提供了多种方式，JavaScript就是其中之一。当出现大量的重复逻辑时，通常是将其封装成一个功能函数。在帆软中即体现为单独一个JavaScript文件。引用JavaScriptJQuery加载JavaScript文件，并执行。${$ . getScript(` http:// ${ 您的服务器路径 } /webroot/ ${ 您的 JS 文件地址 } .js ` , function() {// 加载成功后的回调函数 });
帆软报表开发-夯实基础
郭宝的博客
02-28 1194
数据连接是指建立 FineReport 产品与数据库的连接，让 FineReport 能获取到数据库中的数据。FineReport 数据连接的方式有如下两种：在 数据决策系统 中建立数据连接在FineReport 设计器中建立数据连接。在 数据决策系统 中建立数据连接选择 服务器 > 报表平台管理然后打开数据决策系统 > 建立数据连接点击 管理系统 > 数据连接 > 数据连接管理 > 新建数据连接，如下图所示：根据数据库类型选择对应的数据库进行连接，比如以 MySQL 为例。
【持续更新ing】帆软报表中常见的js代码
okakio的博客
06-25 1968
调用存储过程 setTimeout(function() { //这一步需要拼接起来 把需要传的参数拼接起来 var sql = "EXEC [dbo].[存储过程名称] "+pro+","+""+new_v+""+","+old_v +","+""+fine_username+""; var e =FR.remoteEvaluate('SQL("模式名","'+sql+'",1,1)'); //刷新 contentPane.refreshAllSheets(); }, 100); 关闭子页面，并
帆软超级链接使用（根据内容跳转不同页面、超级链接使用js并传参、超级链接参数传递）
热门推荐
DN_XIAOXIAO的博客
08-29 2万+
根据超级链接的内容跳转不同页面 转载至：根据(不同)内容超链接到不同网址-https://help.finereport.com/doc-view-1839.html 1、问题描述编辑 有时候同一个超链接节点下，经常会需要根据不同的需求自动判断并分别进行页面链接跳转。 例如：点击超链接A，当A的值>50时，跳转为http://www.baidu.com，当A的值<50时，跳转为...
FineReport10 决策报表常用javascript脚本
JiaShun.Li的博客
10-13 4607
一、帆软决策报表移动弹窗 需要传递当前界面的一些控件值时，如果是报表组件内的点击事件，一般获取不到外部组件的值，所以需要js进行获取。此方法也可以用于自定义传值，方便快捷。 //通过组件名称获取组件值 var scode = _g().getWidgetByName("scode").getValue(); //加载弹窗 FR.mobilePopup({ target: "template", //设置跟随弹窗 parameters: {}, setting: { temp...
帆软js实现图表汇总
08-02
帆软JS是一种强大的前端开发工具，提供了丰富的图表功能，可以用于实现图表的汇总展示。 首先，我们可以使用帆软JS中的Chart组件来创建各种类型的图表，如折线图、柱状图、饼图等。通过设置组件的属性，我们可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

丿烂人丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值