html/src/MLight.js - master - SoRusV/src_xendil

html/src/MLight.js
859 строк34 KB
ruslan
Initial commit
29 окт 2024, 11:18
29 окт 2024, 11:185c4dcf5
//alert("a")
//    document.getElementById('idSvgCBar').height=300;
/// Svg svg
//function StartL$ight()
//{

document.body.addEventListener('mousemove', function(e){
    e.preventDefault();
}, false)

    let P = document.getElementById('idSvgCBar');
    SetNode(P, {width: document.body.clientWidth - 140, height: (document.body.clientHeight - 70) / 2});
    P = document.getElementById('idSvgCTime');
    SetNode(P, {width: document.body.clientWidth - 140, height: (document.body.clientHeight - 50) / 2});//    document.getElementById('idSvgCBar').width=700;

    let SvgCBar = document.getElementById('idSvgCBar');
    // SvgCBar.addEventListener('touchstart', LockEvent, false);
    // SvgCBar.addEventListener('touchmove', LockEvent, false);
    // SvgCBar.addEventListener('touchstart', LockEvent, false);
    let SvgCTime = document.getElementById('idSvgCTime');
    // SvgCTime.addEventListener('touchstart', LockEvent, false);
    // SvgCTime.addEventListener('touchmove', LockEvent, false);
    // SvgCTime.addEventListener('touchstart', LockEvent, false);

    let CallRefresh0 = true;
    // MakeMenuNet(document.getElementById('MenuNet'), "TabLight");
    MakeMenuNet(document.getElementById('MenuNet'), undefined, function(){setTimeout(FRefresh, 1)}, []);

//WaitHide();
    let svgB = document.getElementById('idSvgCBar');
    let svgT = document.getElementById('idSvgCTime');
    JParam = {SvgB: svgB, SvgT: svgT, onSelect: OnSelect};
    var Light;
    var JLightAll;
    var JTemperTime;
    function FRefresh() {
        JTemperTime={};
//        let JP=[{"LPWMChanelLED":{"All":0}}, {"LTemperature":{"All":0}},{"LLight":{"Data":{"All":{"GPIO_PWM":0, "LP":0}}}}];
        let JP=[{"LPWMChanelLED":{"Group":1,"All":0}, "LTemperature":{"All":0}, "Time":{"TimeCurrent":0}, "LLight":{"kLightErr":0, "PMax":0, "Data":{"All":{"GPIO_PWM":0, "LP":0}}}}];
      //  JP[1]=GetElementsFromFaceByKey("S");
        let JP1=GetElementsFromFace();
        JsonAdd(JP[0], JP1);
        // JP[1]=GetElementsFromFaceByKey("S");
        // JP[2]=GetElementsFromFaceAuto();
        //  console.log(JSON.stringify(JP));
        // let J = JP;
        JNetUdpDShow.Data[0].FuncRet = FRefresh2;
        // function(d, JFrom){
        //     JLightAll=JFrom;
        //     setTimeout(FRefresh2, 1);
        // };
        //WokerSend(JP, JNetUdpDShow, undefined,"GET");

        // LockWokerSend=false;
        WaitClose(false);

        WokerSend(JP, JNetUdpDShow, function(){
            setTimeout(function(){
                let JP=[{"LTemperature":{"Data":{"All":{"Ch":0, "LT":0}}}}];
                JNetUdpDShow.Data[0].FuncRet = function(d, J){
                    JTemperTime=UnpackTemper(J);
                    LockWokerSend=false;
                 //   JSendPWM=undefined;
                };
                LockWokerSend=false;
                WokerSend(JP, JNetUdpDShow, undefined, "GET");
                LockWokerSend=true;
            }, 1);
        }, "GET");
        // LockWokerSend=true;
    }

    function FRefresh2(d, JFrom) {
        LockWokerSend=true;
        // let JP=[{"LTemperature":{"Data":{"All":{"Ch":0, "LT":0}}}}];
        // JNetUdpDShow.Data[0].FuncRet = function(d, J){
        //     JTemperTime=UnpackTemper(J);
        //     LockWokerSend=false;
        // };
        // WokerSend(JP, JNetUdpDShow, undefined, "GET");
        ElementsFromJson(document, JFrom);
        TimeCurrent=Str2Time(JFrom["Time"]["TimeCurrent"]);
        if(JFrom["LLight"]["kLightErr"]!=1)
            alert("Error temperature! kLightErr="+JFrom["LLight"]["kLightErr"]);
        JLightAll=JFrom;
        if(Light) {
            Light.Free();
            delete Light;
        }
        Light = new MLight(JParam);
        bLoaded = false;
        if (Light.APWMParam.length > 1) /// 0-main canel)
        {
            OnChangeChanelEdit(document.getElementById('@R{@LLight@:{@ChanelEdit@:0}}').value);
            OnChangeLightEdit(document.getElementById('@R{@LLight@:{@LightEdit@:0}}').checked);
            Light.CTime.SetSliderCurrentTime();
        }
        WaitHide();
    }
//};

    function LockEvent(event){
        if(LockTouchMove && event.changedTouches.length==1)
            event.preventDefault(); // prevent default click behavior
//        else
//            alert(1)
    };




    //    addEventListener('touchmove', OnTouchMove, false);
//    function OnTouchMove(event){
//        event.preventDefault();
//        event.stopPropagation();
//        return false;
//    }
//    LoadFile("SCORD.js");
//    LoadFile("ChartBar.js");
//    LoadFile("ChartTime.js");

   // document.getElementById('wrap').style.display = "none";

//    function LoadFile(file){
//        var ext = file.match(/[^.]+$/); // ���������� �����, ����� �����
//        if(ext == 'css'){
//            var link = document.createElement("link");
//            link.setAttribute("rel", "stylesheet");
//            link.setAttribute("type", "text/css");
//            link.setAttribute("href", file);
//        }
//        if(ext == 'js'){
//            var link = document.createElement("script");
//            link.setAttribute("type","text/javascript");
//            link.setAttribute("src", file);
//        }
//        document.getElementsByTagName("head")[0].appendChild(link)
//    }


    // function FRefreshBtn(b) {
    //     if(CallRefresh0){
    //         CallRefresh0=false;
    //         return;
    //     }
    //     console.log('Refresh()');
    //     bLoaded=false;
    //     JParam.SliderSec=Light.CTime.SliderSec;
    //     if(Light) {
    //         Light.Free();
    //         delete Light;
    //     }
    //     Light=new MLight(JParam);
    //     bLoaded=true;
    //     // if(!b)
    //         WaitHide();
    //        // document.getElementById('wrap').style.display = "none";
    // };

function FuncRet(){
    FRefresh();
};

//function FSend(b) {
//        SendElementsToServer();
//        let J={};
//        Light.CTime.GetCTimeToJson(J, false, false);
//        let s="Json={\"LLight\":"+JSON.stringify(J)+"}";
//        console.log(s);
//       // post_rest("Json={\"LPWMChanel\":"+JSON.stringify(J)+"}", _ip);
//        post_rest(s, _ip);
//      //+  SendPWMValue(J);
//      //  post_rest("Json={\"Light\":"+JSON.stringify(J)+"}", _ip);
//        FRefreshBtn(b);
//    }

function FSend(b, bSaveConfig) {
    /// return !err
    if (!Light.TestPowerMax())
    {
        alert("Error: Power more than power max. Data not save");
        WaitHide();
        return;
    }
    let J=[];
    J[0]=GetElementsToServer();
    //   let J1={};
    let i0=0;
    for(let i=0; i<100; i++) {
        if(i>0) {
            J[i] = {};
            J[i].LLight = {};
        }
        //J[i].LLight.Group=1;
        let i1=Light.CTime.GetCTimeToJson(J[i].LLight, false, false, i0, JSON.stringify(J[i]).length);
        if(i1<0)
            break;
        if(i0==i1) { /// not include any elements
            alert("Error Json string is very long");
        }
        i0=i1+1;
        // JsonAdd(J[0], {LLight:J1});
    }
    if(bSaveConfig)
        J[J.length]={Main:{SaveLight:0}};
    WokerSend(J, JNetUdpDSelect, FuncRet, "POST");
    return true;
};

function FSave(b) {
    FSend(0, true);
};

    //function FSave(b) {
//        FSend(1);
//        post_rest("Json={\"Main\":{\"SaveLight\":0}}", _ip);
//        if(!b)
//            document.getElementById('wrap').style.display = "none";
//    }

function OnSelect(SecMin){
      //  console.log(SecMin);
//        EH = document.getElementById("idMoveH");
//        EM = document.getElementById("idMoveM");
        E = document.getElementById("idMove");
        if(SecMin>DaySec)//{
            E.value="00:00";
//            EM.value="00";
//        }
        else{
            let T=Sec2Time(SecMin);
            E.value=pad(T.H,2)+":"+pad(T.M,2);
//            EH.value=pad(T.H,2);
//            EM.value=pad(T.M,2);
        }
    }
function OnChangeLightEdit(checked){
      //  console.log('OnChangeRegime()');
        bLightEdit=checked;
        Light.CTime.SetSliderSec();
        if(!checked) {
            J[0] = {LLight: {LightEdit: 0}};
            WokerSend(J, JNetUdpDSelect, undefined, "POST");
        }
        else
            Light.OnSliderMove();
    }
function OnChangeChanelEdit(Value){
      //  console.log('OnChangeChanelEdit()');
     //   console.log(Value);
        Light.CTime.SetRegimeEdit(Value);
        Light.CBar.SetRegimeEdit(Value);
    }
//    function GetAPWMSelect(){
//        let APWMSelect=[];
//        for(let iB=1; iB<Light.CBar.ABar.length; iB++)
//            if(Light.CBar.ABar[iB].Regime=='Edit')
//                APWMSelect.push(Light.CBar.ABar[iB].GPIO_PWM);
//        return APWMSelect;
//    }

    function SaveLoadCBar(state, Save){
        if(state=="block") {
            let JPWMValue={};
            Light.CBar.GetCBarValueToJson(JPWMValue, false, false);
           // let APWMSelect=GetAPWMSelect();

            let APWMSelect=[];
            for(let iB=1; iB<Light.CBar.ABar.length; iB++)
                if(Light.CBar.ABar[iB].Regime=='Edit' || Save)
                    APWMSelect.push(Light.CBar.ABar[iB].GPIO_PWM);

            if(APWMSelect.length>0) {
                let JACBarAdd={"Unit":Light.CBar.ABar[0].Unit, //PMax:JLightAll["LLight"]["PMax"],
                        "RegimeEdit":Light.CBar.GetRegimeEdit(), "Save":Save};
                RefreshCBar(APWMSelect, JPWMValue, JACBarAdd);// LoadCBarData();
            }
            else {
                alert("No selected points");
                return;
            }
        }
        else
            ClearCBar();
        document.getElementById('idFrameACBar').style.display = state; /// !!!bug here at state=="none" gradient-fill will del and ABar[0] will hide
       // document.getElementById('idDivWait').style.display = state;
        if(state=="block")
            WaitShow(false);
        else
            WaitHide();
        //   document.getElementById("linear-gradient").style.display="block";  /// !bug need refresh gradient-fill of ABar[0], else gradient fill is hide
       Light.CBar.ABar[0].Refresh(); /// !bug need refresh gradient-fill of ABar[0], else gradient fill is hide
    }
function SaveLoadCTime(state, Save){
//        document.getElementById('idFrameACTime').style.display = state;
//        document.getElementById('wrap').style.display = state;
        if(state=="block") {
          //  let APWMSelect=GetAPWMSelect();
            let APWMSelect=[];
            for(let iS=1; iS<Light.CTime.ASL.length; iS++)
                if(Light.CTime.ASL[iS].Active)
                    APWMSelect.push(Light.CTime.ASL[iS].JParam.GPIO_PWM);
            let JCTime={};
         //   if(Save)
                Light.CTime.GetCTimeToJson(JCTime, false, false);
            let JACTimeAdd={"Unit":Light.CBar.ABar[0].Unit, //PMax:JLightAll["LLight"]["PMax"],
                    "RegimeEdit":Light.CTime.GetRegimeEdit(), "Save":Save};
            //FrameACTime.
            RefreshCTime(APWMSelect, JCTime, JACTimeAdd);
        }
        document.getElementById('idFrameACTime').style.display = state;
    //    document.getElementById('idDivWait').style.display = state;
        if(state=="block")
            WaitShow(false);
        else
            WaitHide();
    }
function HideFrame() {
        SaveLoadCBar('none');
        SaveLoadCTime('none');
    }
//    function SaveCBar(){
//        console.log('SaveSpecrum()')
//    };
//
//    function LoadChartTime(){
//        console.log('LoadChartTime()')
//    };
//
//    function SaveChartTime(){
//        console.log('SaveChartTime()')
//    };

    function MoveBlockX(){
        E = document.getElementById("idMove");
//        EM = document.getElementById("idMoveM");
//        let T=EH.value+":"+EM.value;
//            console.log(T);
        let S=Light.CTime.MoveSelectBlockX(E.value);
        if(S && S!="")
            alert(S);
    }
function MoveEveryX(){
        E = document.getElementById("idMove");
//        EH = document.getElementById("idMoveH");
//        EM = document.getElementById("idMoveM");
//        let T=EH.value+":"+EM.value;
//        console.log(T);
        let S=Light.CTime.MoveSelectEveryChanelX(E.value);
        if(S && S!="")
            alert(S);
    }
function MLight(JParam) {
        let th=this;
        let JPWMParam0;
        let JPWMTime0, JTmprParam0, JTmprTime0; /// from ESP
        let AAPWMTime, ATmprParam, AATmprTime; /// after reorder
        th.CBar, th.CTime; /// Charts

        function GetPWMTime() {
            return JLightAll["LLight"];
            // return GetJSONFromServer({"LLight":{"Data":{"All":{"GPIO_PWM":0, "LP":0}}}});
        }
        function LoadJPWM() {
            JPWMParam0 = GetJPWMParam();
            //   JSpectr0=GetSpectrum();
            JPWMTime0 = GetPWMTime();
            JPWMTime0 = JPWMTime0.Data;
            AAPWMTime = [[["00:00", 0.9]]];
            th.APWMParam = [{"Regime": "Auto", "Name": "Main", "Color": 0xffffff, "GPIO_PWM": "-", "Lm": 0, "Lm": 0, "Lux": 0, "W": 0}];
            let SumLux = 0;
            let SumLm = 0;
            let SumW = 0;
            let i = 0;
            for (v in JPWMParam0.Data) {
                i++;
//                if (JPWMParam0.Data[v].Type == "LED" && JPWMParam0.Data[v].GPIO_PWM >= 0) {
                if (JPWMParam0.Data[v]["GPIO_PWM"] != "-" && JPWMParam0.Data[v]["Regime"]=="Auto") {
                    let GPIO_PWM = JPWMParam0.Data[v]["GPIO_PWM"];
                    let J = JPWMParam0.Data[v];
                    J.IndexChanel = v;
                    th.APWMParam.push(J);
//                    th.APWMParam.push(JPWMParam0.Data[v]);
                    SumLux += JPWMParam0.Data[v].Lux;
                    SumLm += JPWMParam0.Data[v].Lm;
                    SumW += JPWMParam0.Data[v].W;


                    let bAdd = false;
//                    if (JPWMTime0[PWM]) {
//                        AAPWMTime.push(JPWMTime0[PWM]);
//                    }
                    for (vg in JPWMTime0) {
                        //    console.log("vg="+JSON.stringify(vg));
                        if (GetGPIO(JPWMTime0[vg].GPIO_PWM) ==GetGPIO(GPIO_PWM)) {
                            if (JPWMTime0[vg].LP.length > 0) {
                                AAPWMTime.push(JPWMTime0[vg].LP);
                                bAdd = true;
                            }
                            break;
                        }
                    }
                    if (!bAdd)
                        AAPWMTime.push([[i % 23 + 1 + ":00", ((i + 1) * 0.01) % 0.3]]);
                }
            }
            //     console.log("AAPWMTime="+JSON.stringify(AAPWMTime));
            th.APWMParam[0]['Lux'] = SumLux;
            th.APWMParam[0]['Lm'] = SumLm;
            th.APWMParam[0]['W'] = SumW;
        };
        function LoadJTmpr() {
            JTmprParam0 = JLightAll["LTemperature"];//GetTemperatureParam();
            JTmprTime0 = JTemperTime;//GetTemperatureTime();
            if(!JTmprTime0)
                return undefined;
            AATmprTime = [];
            ATmprParam = [];
            for (v in JTmprParam0.Data) {
                if (JTmprParam0.Data[v].Ch >= 0) {
                    let Ch = JTmprParam0.Data[v].Ch;
                    let bAdd=false;
//                    if (JTmprTime0[Ch]) {
//                        ATmprParam.push(JTmprParam0.Data[v]);
//                        AATmprTime.push(JTmprTime0[Ch]);
//                    }
                    for(vg in JTmprTime0) {
                     //   console.log("vg="+JSON.stringify(vg));
                        if (JTmprTime0[vg].Ch == Ch) {
                            ATmprParam.push(JTmprParam0.Data[v]);
                            AATmprTime.push(JTmprTime0[vg].LP);
                            bAdd = true;
                            break;
                        }
                    }
//                    if(!bAdd)
//                        AAPWMTime.push([["00:00", 0]]);
                }
            }
           // ATmprParam, AATmprTime
            return {Param:ATmprParam, Data:AATmprTime};
        };
        function OnBeforeDownBtnDown(Btn, bDown) { /// select/deselect
            let AS=th.CTime.ASL;
            if(!AS[Btn.Index].Active)
                return false;
            let iB=Btn.Index;
            let J={};
            if (bDown) {
                let iP =AS[Btn.Index].GetClosePoint(th.CTime.SliderSec);
                J[iB.toString()]=[iP];
                OnSelectPoint(J, true, false);
            }
            else {
                for (let iP = 0; iP < AS[Btn.Index].AP.length; iP++) {
                    if (AS[iB].AP[iP].Selected) {
                        if (!J[iB.toString()])
                            J[iB.toString()] = [];
                        J[iB.toString()].push(iP);
                    }
                }
                OnSelectPoint(J, false, false);
            }
            return true;
        };
        function OnBeforeDownBtnUp(Btn, bDown){
            // console.log('BtnUp');
            // console.log(Btn.Index);
            let AS= th.CTime.ASL;
            if(!AS[Btn.Index].Active)
                return;
            if(Btn.Value=='')
                return;
            let iB=Btn.Index;
            let Sec=th.CTime.SliderSec;
            if(iB!=0) {
                if (Btn.Value == 'add') {
                    AS[iB].AddPoint(Sec, th.CBar.ABar[iB].Value);
                }
                else if (Btn.Value == 'del') {
                    AS[iB].DelPointSelect();
//                    for (let iP = 0; iP < AS[iS].AP.length; iP++)
//                        if (AS[iB].AP[iP].Selected)
//                            AS[iB].DelPoint(iP);
                }
            }
            else { /// iB==0
                if (Btn.Value == 'add') {       /// will add points to all iS!=0
                    for (let iS = 0; iS < AS.length; iS++)
                        if(AS[iS].Active)
                            if(AS[iS].FindPoint(Sec)<0) /// not found this point in AS[iS], add this point to AS[iS]
                                AS[iS].AddPoint(Sec, AS[iS].GetValue(Sec));
                }
                else if (Btn.Value == 'del') {      /// will del points from all iS!=0
                    th.CTime.DelPointSelect();
//                    for (let iS = 0; iS < AS.length; iS++)
//                        if (AS[iS].Active)
//                            for (let iP = 0; iP < AS[iS].AP.length; iP++)
//                                if(AS[iS].AP[iP].Selected)
//                                    AS[iS].DelPoint(iP);
                }
            }
            AS[iB].Refresh();
            th.CTime.CalcSeries0(null);//, iB!=0);
            th.CBar.ABar[iB].BtnDown.Down(Btn.Value=='add');
            th.OnSliderMove(Sec);
            return false;
        }
        th.OnSliderMove=function(SliderSec) {
            if(SliderSec==undefined)
                SliderSec=th.CTime.SliderSec;
            let AS=th.CTime.ASL;
            for(let iS = AS.length-1; iS >=0 ; iS--) {
                let SCount = 0;
                if (AS[iS].Active) {
                    for (let iP = 0; iP < AS[iS].AP.length; iP++)
                        if (AS[iS].AP[iP].Selected) {
                            SCount++;
                        }
                }
                if (SCount > 0) {
                    if (AS[iS].AP.length > 1) /// not del last point
                        th.CBar.ABar[iS].BtnUp.Value = 'del';
                    else
                        th.CBar.ABar[iS].BtnUp.Value = '';
                }
                else {
                    if (AS[iS].FindPoint(th.CTime.SliderSec) < 0)
                        th.CBar.ABar[iS].BtnUp.Value = 'add';
                    else
                        th.CBar.ABar[iS].BtnUp.Value = '';
                }
                th.CBar.ABar[iS].BtnUp.Text.textContent = th.CBar.ABar[iS].BtnUp.Value;
            }

            let AV = th.CTime.GetValue(null, SliderSec);
            th.CBar.SetValue(AV);
            th.CBar.RefreshUnit();
        };

        let LockOnSelectPoint=false;
        function OnSelectPoint(J, bSelected, bClearOld) /// J={iS:[iP,..], ...}
        /// if(bClearOld) need clear old points and than add nw points
        {
            if(LockOnSelectPoint)
                return;
            let AS=th.CTime.ASL;

            let SCountOld=0;
            for(let iS = 0; iS < AS.length; iS++)
                if (AS[iS].Active)
                    for (let iP = 0; iP < AS[iS].AP.length; iP++)
                        if (AS[iS].AP[iP].Selected)
                            SCountOld++;
            ///+++ if(iS!=0 and exist iP) than must be point in iS=0 at same Sec
            let A0Add=[]; /// this array need add to J[0], will make A0Add
            if(bSelected) {
                for (iS in J) /// test. J consist iS==0?
                    if (iS != 0) { /// need add points from all series at same sec
                        for (let iiP1 = 0; iiP1 < J[iS].length; iiP1++) {
                            let Sec = AS[iS].AP[J[iS][iiP1]].Sec;
                            let iP0 = AS[0].FindPoint(Sec);
                            if ((!J[0] || J[0].indexOf(iP0) < 0) && A0Add.indexOf(iP0) < 0)
                                A0Add.push(iP0);
                        }
                    }
            }
            else /// !bSelected /// delete points from AS[0]
                for (let iP0 = 0; iP0 < AS[0].AP.length; iP0++)
                    if(AS[0].AP[iP0].Selected)
                    {
                        let Sec = AS[0].AP[iP0].Sec;
                        let bFind=false;
                        for(let iS = 1; iS < AS.length && !bFind; iS++)
                            if (AS[iS].Active){
                                let iP=AS[iS].FindPoint(Sec);
                                if(iP>=0)
                                    bFind=AS[iS].AP[iP].Selected && !(J[iS] && J[iS].indexOf(iP)>=0);
                            }
                        if (!bFind && (!J[0] || J[0].indexOf(iP0) < 0) && A0Add.indexOf(iP0) < 0)
                            A0Add.push(iP0);
                    }

            ///---- if(iS!=0 and exis ... made A0Add
            ///+++ will find iS==0. if(will find iS==0) than add to J, points from other series at the same sec.
            for(iS in J) /// test. J consist iS==0?
                if(iS==0){ /// need add points from all series at same sec
                    for(let iiP0=0; iiP0<J[iS].length; iiP0++) {
                        let Sec = AS[iS].AP[J[iS][iiP0]].Sec;
                        for (let iS1 = 1; iS1<AS.length; iS1++)
                            if (AS[iS].Active){
                                let iP1 = AS[iS1].FindPoint(Sec);
                                if(iP1>=0) {
                                    if(!J[iS1.toString()])
                                        J[iS1.toString()]=[];
                                    else if(J[iS1.toString()].indexOf(iP1)>=0)
                                        continue;
                                    J[iS1.toString()].push(iP1);
                                }
                            }
                    }
                    break;
                }
            ///--- added if(found iS==0) than add to J, points from other series
            /// will add A0Add to J
            if(!J['0'])
                J['0']=[];
            for(let i=0; i<A0Add.length; i++)
                J['0'].push(A0Add[i]);

            if(bClearOld)   /// will clear
                for(let iS = 0; iS < AS.length; iS++)
                    for(let iP = 0; iP < AS[iS].AP.length; iP++)
                        AS[iS].AP[iP].Selecte(false);

            for(iS in J)    /// will set bSelected
                if (AS[iS].Active)
                    for(let iiP=0; iiP<J[iS].length; iiP++)
                        AS[iS].AP[J[iS][iiP]].Selecte(bSelected);

            let SecMin=1E6;
            let Position0 = 0;
            for(let iS = AS.length-1; iS >=0 ; iS--) {
                let SCount = 0;
                let Position = 0;
                if (AS[iS].Active) {
                    for (let iP = 0; iP < AS[iS].AP.length; iP++)
                        if (AS[iS].AP[iP].Selected) {
                            SCount++;
                            Position = Math.max(Position, AS[iS].AP[iP].V);
                            SecMin=Math.min(SecMin, AS[iS].AP[iP].Sec);
                        }
                    if(iS==0){
                        if(th.CBar.ABar[0].Unit=='%')
                            Position=Position0;
                        else
                            Position=Position0/th.CBar.ABar[0].Data[th.CBar.ABar[0].Unit];
                    }

                }
                th.CBar.ABar[iS].Position = Position; //SetPosition(Value, false);
                if(SCount>0) {
                    th.CBar.ABar[iS].SetRegime('Edit');
                    if(th.CBar.ABar[0].Unit=='%')
                        Position0=Math.max(Position0, Position);
                    else
                        Position0+=Position*th.CBar.ABar[iS].Data[th.CBar.ABar[iS].Unit];
                }
                else if(th.CBar.ABar[iS].Regime=="Edit"){//} && th.CBar.ABar[iS].Regime!="Disable"){
                    th.CBar.ABar[iS].SetRegime('Line');
                }
            }
            if(SCountOld==0 && SecMin<1E6)
                th.CTime.SetSliderSec(SecMin);
            else
                th.CTime.SetSliderSec();

            PointSelectCount=0;
            for(let iB=1; iB<th.CBar.ABar.length; iB++)
                if(th.CBar.ABar[iB].Regime=='Edit')
                    PointSelectCount++;
            if(onSelect)
                OnSelect(SecMin);
            //     B = document.getElementById('BtnLoadCBar');
            // //    SetNode(B, {fill:'#aa0000'});
            //     B.textContent=PointSelectCount;
            //     // if(PointSelectCount>0)
            //     //     B.textContent=PointSelectCount;// style.fill='#000000';
            //     // else {
            //     //     B.style.fill='#aa0000';
            //     // }
            th.OnSliderMove();
            LockOnSelectPoint=false;
        };
        function OnAfterBarDown (){//Bar_, bShiftKey) {
          //  console.log('OnAfterBarDown');
            for(let iB=0; iB<th.CBar.ABar.length; iB++) {
                if (th.CBar.ABar[iB].Regime == 'Hide' && th.CTime.ASL[iB].Active)
                    th.CTime.ASL[iB].SetActive(false);
                else if (th.CBar.ABar[iB].Regime != 'Hide' && !th.CTime.ASL[iB].Active)
                    th.CTime.ASL[iB].SetActive(true);
            }

            let CountActive=0;
            for(let iB=1; iB<th.CBar.ABar.length; iB++)
                if(th.CTime.ASL[iB].Active)
                    CountActive++;
      //      th.CTime.ASL[0].SetActive(CountActive!=1);
            th.CTime.CalcSeries0();
            th.CTime.SetSliderSec();
        };
        function OnChangeBarPosition(CBar, IndexBar, Value) {
            /// !!! Here position of bar !=0, else point of ChartTime will be frezee in y=0
            /// else selecte points of ChartTime will be deformate in equal value in y=0
        //    if(Value==0)
          //      Value=Value;
            let iB=IndexBar;
            let V0=th.CBar.ABar[iB].Position;
            if(V0==0)
                V0=1E-6;
            /// else point of ChartTime will be frezee in y=0
            /// else selecte points of ChartTime will be deformate in equal value in y=0
            let VMax = -1;
            for (let iP = 0; iP < th.CTime.ASL[iB].AP.length; iP++)
                if (th.CTime.ASL[iB].AP[iP].Selected) {
                    if (th.CTime.ASL[iB].AP[iP].V > VMax)
                        VMax = th.CTime.ASL[iB].AP[iP].V;
                }
            if (VMax == 0) /// else point of ChartTime will be frezee in y=0
                VMax = 1E-6;
            if (VMax > 0){// && VMin > 1E6) { /// VMin>1E6 - else selecte points of ChartTime will be deformate in equal value in y=0
                let k = V0 / VMax;
                for (let iP = 0; iP < th.CTime.ASL[iB].AP.length; iP++)
                    if (th.CTime.ASL[iB].AP[iP].Selected) {
                        if(th.CTime.ASL[iB].AP[iP].V==0)
                            th.CTime.ASL[iB].AP[iP].V=1E-6*k;
                        else
                            th.CTime.ASL[iB].AP[iP].V *= k;
                    }
                th.CTime.Refresh(th.CTime.ASL);
            }
            if(th.CBar.ABar[iB].Position!=V0) { /// can bar.position=0, but points of chaettime can !=0, refresh bar.position
                let J={};
                J[iB.toString()]=[];
                OnSelectPoint(J, true, false);
            }
            th.CTime.CalcSeries0();
            th.CTime.SetSliderSec(th.CTime.SliderSec); /// refresh bar value
        };
        function OnChangeK(K) {
            th.CTime.SetK(K);
            th.OnSliderMove();
        };
        function OnChangeUnit(Unit) {
            th.CTime.SetUnit(Unit);
            th.CBar.OnBeforeChangePositionBar(th.CBar.ABar[1], th.CBar.ABar[1].Position); /// recalc ABar[0]

            th.OnSliderMove();
        };
        function CreateChartBar() {
            //- let svg = document.getElementById('idSVGSpectr');
            let H = Number(JParam.SvgB.getAttributeNS(null, 'height'));
            let W = Number(JParam.SvgB.getAttributeNS(null, 'width'));
            let B = 0;
            let JCBarGraph = {svg: JParam.SvgB, //onChange: OnChangeBarPosition,
                x0: B, x1: W - 2 * B,
                y0: B, y1: H - 2 * B, bView: 0, onAfterBarDown:OnAfterBarDown,
                PMax:JLightAll["LLight"]["PMax"],
                onChangeBarPosition: OnChangeBarPosition,
                onBeforeDownBtnDown: OnBeforeDownBtnDown, onBeforeDownBtnUp: OnBeforeDownBtnUp}; /// not svg
            th.CBar = new MChartBar(JCBarGraph, th.APWMParam);//, JSpectr);
        };
        function CreateChartTime() {
            let svg = document.getElementById('idSVGTime');
            let H = Number(JParam.SvgT.getAttributeNS(null, 'height'));
            let W = Number(JParam.SvgT.getAttributeNS(null, 'width'));
            let B = 0;
            let JCTimeGraph = {svg: JParam.SvgT, x0: B, x1: W - 2 * B, y0: B, y1: H - 2 * B, K: 1, onSliderMove: th.OnSliderMove,
                onSelectPoint:OnSelectPoint, LoadJTmpr:LoadJTmpr, PMax:JLightAll["LLight"]["PMax"]}; /// not svg
            th.CTime = new MChartTime(JCTimeGraph, th.APWMParam, AAPWMTime, ATmprParam, AATmprTime);
        };
        th.SetCBar=function (JPWMValue){
          //  return;
         //   console.log("SetCBar(JPWMValue) :: "+JSON.stringify(JPWMValue));
            for(p in JPWMValue.Data){
                for(let iB=1; iB<th.CBar.ABar.length; iB++)
                    if(th.CBar.ABar[iB].Regime=="Edit" && GetGPIO(th.CBar.ABar[iB].GPIO_PWM)==GetGPIO(JPWMValue.Data[p].GPIO_PWM)){
                        for(let iP=0; iP<th.CTime.ASL[iB].AP.length; iP++)
                            if(th.CTime.ASL[iB].AP[iP].Selected)
                                th.CTime.ASL[iB].AP[iP].V=JPWMValue.Data[p].V;
                        th.CBar.ABar[iB].SetPosition(JPWMValue.Data[p].V);
                        break;
//                    th.CTime.ASL[iB].Refresh();
                    }
            }
        };

        th.SetCTime=function (JCTime){
            //console.log("SetCTime(JCTime) :: "+JSON.stringify(JCTime));
            for(p in JCTime.Data){
                for(let iS=1; iS<th.CTime.ASL.length; iS++)
                    if(th.CTime.ASL[iS].Active && GetGPIO(th.CTime.ASL[iS].JParam.GPIO_PWM)==GetGPIO(JCTime.Data[p].GPIO_PWM))
                        th.CTime.ASL[iS].Data2Series(JCTime.Data[p].LP);
            }
            th.CTime.CalcSeries0();
            OnSelectPoint({}, false, true);
            th.CTime.BuildNet();
            //Show(th.ASL, true);
            th.CTime.Refresh(th.CTime.ASL);
            th.CTime.SetSliderSec();
        };

        th.TestPowerMax=function()
        {
            if(JLightAll["LLight"]["PMax"]==undefined)
                return true;
            //for(let iS0=1; iS0<th.CTime.ASL.length; iS0++){
            let iS0=0;
            for(let iP0=0; iP0<th.CTime.ASL[iS0].AP.length; iP0++){
                let SumW=0;
                let s=th.CTime.ASL[iS0].AP[iP0].Sec;
                for(let iS1=1; iS1<th.CTime.ASL.length; iS1++) {
                    let v=th.CTime.ASL[iS1].GetValue(s);
                    let p=th.CTime.ASL[iS1].JParam["W"];
                    SumW += th.CTime.ASL[iS1].GetValue(s) * th.CTime.ASL[iS1].JParam["W"];
                }
                if(SumW>JLightAll["LLight"]["PMax"])
                    return false;
            }

            // for (v in JPWMParam0.Data) {
            //     if (JPWMParam0.Data[v]["GPIO_PWM"] != "-" && JPWMParam0.Data[v]["Regime"] == "Auto") {
            //         SumW += JPWMParam0.Data[v].W;
            //     }
            // }
            //return SumW>JLightAll["PMax"];
            return true;
        }

//        th.SetSliderCurrentTime=function (){
//            let a = new Date();
//            let Sec=3600*a.getHours()+60*a.getMinutes()+a.getSeconds();
//            delete a;
//            th.CTime.SetSliderSec(Sec);
//        };

        th.Free=function(){
            if(th.CTime){
                th.CTime.Free();
                delete th.CTime;
            }
            if(th.CBar){
                th.CBar.Free();
                delete th.CBar;
            }
        };

        let onSelect=JParam.onSelect;
        LoadJPWM();
        if(th.APWMParam.length<2) /// 0-main canel
            return;
       //-- // LoadJTmpr();
        CreateChartBar();
        th.CBar.onChangeK=OnChangeK;
        th.CBar.onChangeUnit=OnChangeUnit;

        CreateChartTime();
        th.CTime.SliderShow();

        th.CBar.ABK[0].Down(true);
        th.CBar.JBU['%'].Down(true);
        th.CBar.ABar[0].Refresh();
        OnSelectPoint({}, false, false);
        th.CTime.SetSliderSec(JParam.SliderSec);

        //-- th.CBar.Refresh();
    }

ClickItem("Light");