scripts/libs/classes/class_mapAnalog.ctl - master - Puzzman/setPointMap

scripts/libs/classes/class_mapAnalog.ctl
1 588 строк56 KB
Sergey
refactor
13 май 2025, 16:44
13 май 2025, 16:44e49876e
#uses "scadMsg_Messages"
#uses "SQL/sqlQueries"
#uses "classes/TabViewScad.ctl"
#uses "classes/TableViewScad.ctl"
#uses "classes/DataBase.ctl"
#uses "classes/Structures.ctl"
#uses "classes/class_printTable.ctl"
#uses "stdlib"

class EntityMapAnalog
{
  string CCCCCC;
  string WARNING;
  string PATH;

  defaultParametrsForsetPointMap paramSetPointMap;

  dyn_dyn_anytype listTab;
  mapping buf_write_to_para_;
  shape mode_btn_, archive_btn_, plc_btn_;
  dyn_int selected_rows_;
  dyn_int selected_columns_;

  public  shared_ptr<BaseTab>       TabView = nullptr;
  private shared_ptr<OperatingMode> Mode_   = nullptr;
  private shared_ptr<DataBase>      db      = nullptr;
  private shared_ptr<DataBase>      db_re   = nullptr;

  dyn_anytype Tab_;
  bool editingIsAllowed;



  //конструктор
  public EntityMapAnalog()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    CCCCCC  = paramSetPointMap.backColor;
    WARNING = paramSetPointMap.warningColor;
    PATH    = paramSetPointMap.pathToSave;

    editingIsAllowed = getUserPermission(6) || paramSetPointMap.PermissionOK;

    // подключаемся к базе данных
    db    = new DataBase();
    db_re = new DataBase(true);
    Mode_ = new OperatingMode;

    Mode_.setMode(true, false);

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public bool getPermission() {return editingIsAllowed;}

  public mapping getBufferToWriteToPara()
  {
    return buf_write_to_para_; //возвращаем массив уставок, которые нужно записать
  }
  public mapping getMode()
  {
    return Mode_.getMode(); //возвращаем текущий режим карты уставок ПЛК или Архив
  }

  public string setVersion()
  {
    return paramSetPointMap.__VERSION__;
  }

  //переключение режимов карты уставок
  public setMode(bool PLC, bool Arch)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    Mode_.setMode(PLC, Arch); //меняем режим карты уставок

    int idActiveTab;
    getValue("TAB1", "activeRegister", idActiveTab); //меняем режим карты уставок

    for (int i = 1; i <= dynlen(Tab_); i++)
    {
      setValue("TAB1", "registerIcon", Tab_[i].id, "");
      Tab_[i].haveBeenChanges = false;

      if (Arch)
      {
        fillTables(Tab_[i], false, Arch);
      }
      else
      {
        if (Tab_[i].id != idActiveTab) continue;

        updateValueFromPlc(Tab_[i]);  //обновляем данные из PLC только для активной вкладки
      }
    }

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " ------> END");
  }

  //функция записи данных в PARA
  public writeBufferToPara()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    dyn_string tmp_tab;
    dyn_string keys = mappingKeys(buf_write_to_para_); //получаем пути до dpPoint для записи уставок

    for (int i = 1; i <= dynlen(keys); i++)
    {
      createMessage(buf_write_to_para_[keys[i]], keys[i]);

      int err = dpSetWait(keys[i], buf_write_to_para_[keys[i]]["Current Value"]);

      if (err == 0)
      {
        string tagTab           = buf_write_to_para_[keys[i]]["Title Tab"];
        string tagTable         = buf_write_to_para_[keys[i]]["Title Table"];
        string currentRow       = buf_write_to_para_[keys[i]]["Selected Rows"];
        string tagCurrentColumn = buf_write_to_para_[keys[i]]["Title Column"];
        //убираем цвет измененной уставки
        setValue(tagTable, "cellBackColRC", currentRow, tagCurrentColumn, "_Transparent");

        //создаем массив вкладок по которым нужно обновить таблицы
        if (dynContains(tmp_tab, tagTab) == 0)
        {
          dynAppend(tmp_tab, tagTab);
        }
      }
    }

    //обновляем таблицы
    for (int i = 1; i <= dynlen(tmp_tab); i++)
    {
      shared_ptr<StateTab> tab = getCurrentTab(tmp_tab[i]);
      updateBuffPLC();
      fillTables(tab, false);
      setValue("TAB1", "registerIcon", tab.id, ""); //убираем иконку наличия изменных уставок
      tab.haveBeenChanges = false;
    }

    mappingClear(buf_write_to_para_);
  }

  private void choosingUpdateLocation(const string &key, const anytype &tmp_value, const int &err)
  {
    shared_ptr<StateTab> tab = getCurrentTab(buf_write_to_para_[key]["Title Tab"]);
    int col     = buf_write_to_para_[key]["Selected Columns"];
    int row     = buf_write_to_para_[key]["Selected Rows"] + 1;
    int r       = (tab.needToFlip) ? col - 3 : row;
    int tmp_col = (tab.needToFlip) ? row : col + 1;

    string value;
    sprintf(value, tab.tableData.format[r][tmp_col], tmp_value);
    strreplace(value, " ", "");

    if (patternMatch("*UstEnable", key))
    {
      if (err == 0) tab.tableData.UstEnable[r][3] = value;
    }
    else if (patternMatch("*UstMsg", key))
    {
      if (err == 0) tab.tableData.UstMsg[r][3] = value;
    }
    else if (patternMatch("*UstSound", key))
    {
      if (err == 0) tab.tableData.UstSound[r][3] = value;
    }
    else
    {
      if (err == 0)
      {
        if (tab.needToFlip)
        {
          tab.tableData.valuesPLC[col - 3][row] = value;
        }
        else
        {
          tab.tableData.valuesPLC[row][col - 3] = value;
        }

        tab.tableData.rowsWithDataPLC[row][col + 1] = value;
      }
    }
  }

  private updateBuffPLC()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    dyn_string keys = mappingKeys(buf_write_to_para_);

    for (int i = 1; i <= dynlen(keys); i++)
    {
      anytype tmp_value;
      int err = dpGet(keys[i], tmp_value);

      choosingUpdateLocation(keys[i], tmp_value, err);
    }
  }

  //получим текущий объект Tab по имени таблицы
  private shared_ptr<StateTab> getCurrentTable(const string &table_name)
  {
    for (int i = 1; i <= dynlen(Tab_); ++i)
    {
      if (Tab_[i].isCurrentTable(table_name))
      {
        return Tab_[i];
      }
    }
  }

  //получим текущий объект Tab по имени владки
  private shared_ptr<StateTab> getCurrentTab(const string &tab_name)
  {
    for (int i = 1; i <= dynlen(Tab_); ++i)
    {
      if (Tab_[i].isCurrentTab(tab_name))
      {
        return Tab_[i];
      }
    }
  }

  //Заполнение вкладками
  public initTab()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    dyn_string titleTab;
    int idCount = 0;                         //счетчик нужен, если вкладки идут не подряд

    listTab = db.getData(getNameTabsAnalog); //запрашиваем имена вкладок

    for (int i = 1;  i <= dynlen(listTab); ++i)
    {
      if ((bool)listTab[i][5])
      {
        shared_ptr<StateTab> tab_ = new StateTab(listTab[i], idCount, new dataTableAnalog);   // создаем структуру вкладок
        dynAppend(Tab_, tab_);
        idCount += 1;
      }
    }

    if (dynlen(Tab_) > 0)
    {
      TabView = new BaseTab(Tab_);    //создаем класс TAB
      TabView.setTabEnable(false);    //временное решение
      initTables();
    }
    else
    {
      DebugFTN("dbgmap", __LINE__, __FUNCTION__, "Не получено ни одной вкладки");
    }

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --->  END");
  }

  //функция снятия редактирования со всех ячеек кроме выбранной
  public functionOfRemovingEditingCellsExeptForSelectedOne(int row, int column, string tableName)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    int rowCount, columnCount, shift;
    string nameColumn, nameTab, aliasTab, color;

    getValue(tableName, "lineCount",   rowCount);
    getValue(tableName, "columnCount", columnCount);
    getValue("TAB1", "namedActiveRegister", nameTab);
    getValue("TAB1", "namedColumnHeader", nameTab, aliasTab);

    shared_ptr<StateTab> tab = getCurrentTab(nameTab);

    shift = (tab.needToFlip) ? 4 : 3;

    for (int i = 0; i < rowCount; i++)
    {
      for (int j = shift; j < columnCount; j++)
      {

        getValue(tableName, "columnToName", j, nameColumn);
        getValue(tableName, "cellBackColRC", i, nameColumn, color);

        if (row == i && column == j && color != CCCCCC)
        {
          setValue(tableName, "cellEditableRC", row, nameColumn, true);
        }
        else
        {
          setValue(tableName, "cellEditableRC", i, nameColumn, false);
        }
      }
    }

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --->  END");
  }

  // получелние выбранных строк и столбцов
  public selectionProcessing(dyn_int rows, dyn_int columns, string table_name, int cur_row, int cur_col, string value, string name_column)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START", cur_row, name_column, value);

    shared_ptr<StateTab> tab_ = getCurrentTable(table_name);

    if (cur_col == 0 && dynlen(rows) == 1)
    {
      setValue(table_name, "selectLineN", cur_row); //выделение всей строки при выборе первой колонки
    }

    if (name_column != "id" && name_column != "name" && name_column != "tag" && name_column != "unit")
    {
      dyn_int aTmp;
      aTmp = (tab_.needToFlip) ? columns : rows;
      changedValue(table_name, cur_row, aTmp, value, name_column);
    }

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public writeToFile()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

//     string nameTable, title;
//     string dir = PATH + formatTime("%Y-%m-%d_%H-%M-%S", getCurrentTime())+ "_Analog" + "/";
//
//     bool result = mkdir(dir,"777");  //создаем директорию
    //если все удачно
//     if (result)
//     {
//       for (int i = 1; i <= dynlen(Tab_); i++)
//       {
//         nameTable = Tab_[i].tagTable;
//         title = Tab_[i].title;
//         string command = "iconv -f UTF-8 -t CP1251//TRANSLIT $1 -o $2";                                    //команда на смену кодировки файла
        //string path = dir + title + "_" + formatTime("%Y-%m-%d_%H-%M-%S", getCurrentTime()) + ".csv";
//         string path = dir + nameTable + ".csv";                                                            //создаем файл без кириллицы
//         string tmp = dir + "out_a"+ i +".csv";                                                             //создаем временный файл
//         setValue(nameTable, "writeToFile", tmp, TABLE_WRITE_ALL_COLUMNS | TABLE_WRITE_COLUMN_HEADER, ";"); //выгружаем таблицы по одной
//         strreplace(command, "$1", tmp);                                                                    //реплейсим по шаблону
//         strreplace(command, "$2", path);                                                                   //тут тоже))
//         system(command);                                                                                   //вызываем консольную команду на смену кодировки
//         delay(0, 100);                                                                                     //отдыхаем
//         remove(tmp);                                                                                       //удаляем временный файл
//         string path1 = dir + "_" + title + ".csv";                                                         //создаем имя для файла в читабельном виде
//         moveFile(path, path1);                                                                             //команда move позволяет переименовать файл
//       }
//     }
//     else
//     {
//       DebugN("Директория " + dir + " не была создана");
//     }
//     string msg = "Карта уставок аналоговых параметров успешно экспортирована в директорию " + dir;
//     openInformationPanel(makeDynString("$sInformation:" + msg + "", "$iTimer:0", "$bCritical:false"), "-1", "-1");
//     CreateMultiInstanceMessage("Произведен экспорт карты уставок пользователем " + getUserName() + " в директорию " + dir , "", "armMessages_10", "armMessages_10", getHostname());
    ExportToXML(Tab_, "Карта аналоговых уставок");
  }

  public writeToParaFromArchive()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    for (int i = 1; i <= dynlen(Tab_); ++i)
    {
      dyn_dyn_string paths = Tab_[i].tableData.pathUst;

      for (int j = 1; j <= dynlen(paths); ++j)
      {
        int err = dpSetWait(paths[j], Tab_[i].tableData.valuesArch[j]);

        if (err != 0)
        {
          for (int k = 1; k <= dynlen(paths[j]); ++k)
          {
            DebugN("Не удалось записать уставку " + Tab_[i].tableData.nameObjects[j] + "(" + Tab_[i].tableData.nameUst[j][k] + ") со значением " + Tab_[i].tableData.valuesArch[j][k] + " в ПЛК");
          }

        }
      }

      for (int j = 1; j <= dynlen(Tab_[i].tableData.UstEnable); ++j)
      {
        int err1 = dpSetWait(Tab_[i].tableData.UstEnable[j][1], Tab_[i].tableData.UstEnable[j][2]);
        int err2 = dpSetWait(Tab_[i].tableData.UstMsg[j][1], Tab_[i].tableData.UstMsg[j][2]);
        int err3 = dpSetWait(Tab_[i].tableData.UstSound[j][1], Tab_[i].tableData.UstSound[j][2]);

        if (err1 == 0) Tab_[i].tableData.UstEnable[j][3] = Tab_[i].tableData.UstEnable[j][2];

        if (err2 == 0) Tab_[i].tableData.UstMsg[j][3] = Tab_[i].tableData.UstMsg[j][2];

        if (err3 == 0) Tab_[i].tableData.UstSound[j][3] = Tab_[i].tableData.UstSound[j][2];
      }

      Tab_[i].tableData.rowsWithDataPLC = Tab_[i].tableData.rowsWithDataArch;
      setValue("TAB1", "registerIcon", Tab_[i].id, "");
      Tab_[i].haveBeenChanges = false;
      fillTables(Tab_[i], false);
    }
  }

  public readFromArchive()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    updateValueFromArchive();
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public switchingTab(string name_tab, bool init = false)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    mapping mode = Mode_.getMode();

    for (int i = 1; i <= dynlen(Tab_); i++)
    {
      shape t = Tab_[i].classTable.get_table();
      setValue(t.name, "visible", (Tab_[i].tagTab == name_tab) ? true : false);

      if (t.visible() && mode["PLC"] && !Tab_[i].haveBeenChanges)
      {
        if (!init)
        {
          updateValueFromPlc(Tab_[i]);
          setValue("TAB1", "registerIcon", Tab_[i].id, "");
          Tab_[i].haveBeenChanges = false;
        }
      }
    }

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public readFromPLC()
  {
    for (int i = 1; i <= dynlen(Tab_); i++)
    {
      shape t = Tab_[i].classTable.get_table();

      if (t.visible() && mode["PLC"])
      {
        updateValueFromPlc(Tab_[i]);
        setValue("TAB1", "registerIcon", Tab_[i].id, "");
        Tab_[i].haveBeenChanges = false;
      }
    }
  }

  public updateValueFromPlc(anytype &tab)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    IndicatorLoad.start();

    dyn_dyn_string paths = tab.tableData.pathUst;
    dyn_anytype tmp_rez;
    int shift;

    for (int j = 1; j <= dynlen(paths); ++j)
    {
      int err = dpGet(paths[j], tmp_rez);

      if (err == 0)
      {
        tab.tableData.valuesPLC[j] = tmp_rez;
        shift = 4;

        //обновление массива таблицы
        for (int k = 1; k <= dynlen(tmp_rez); ++k)
        {
          if (!tab.needToFlip)
          {
            sprintf(tab.tableData.rowsWithDataPLC[j][shift + k], tab.tableData.format[j][k + shift], (float)tmp_rez[k]);
            strreplace(tab.tableData.rowsWithDataPLC[j][shift + k], " ", "");
          }
          else
          {
            sprintf(tab.tableData.rowsWithDataPLC[k][shift + j], tab.tableData.format[j][k], (float)tmp_rez[k]);
            strreplace(tab.tableData.rowsWithDataPLC[k][shift + j], " ", "");
          }
        }
      }
      else
      {
        DebugN(paths[j], "----> error reading" + paths[j]);
      }
    }

    for (int j = 1; j <= dynlen(tab.tableData.UstEnable); ++j)
    {
      int ustE, msgE, soundE;
      int err1 = dpGet(tab.tableData.UstEnable[j][1], ustE);
      int err2 = dpGet(tab.tableData.UstMsg[j][1],    msgE);
      int err3 = dpGet(tab.tableData.UstSound[j][1],  soundE);

      if (err1 == 0) tab.tableData.UstEnable[j][3] = ustE;

      if (err2 == 0) tab.tableData.UstMsg[j][3]    = msgE;

      if (err3 == 0) tab.tableData.UstSound[j][3]  = soundE;
    }

    fillTables(tab, false);

    IndicatorLoad.stop();
  }

  private updateRowsTable()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");


    for (int i = 1; i <= dynlen(Tab_); ++i)
    {
      for (int j = 1; j <= dynlen(Tab_[i].tableData.rowsWithDataArch); ++j)
      {
        getValue(Tab_[i].tagTable, "getLineN", j - 1, Tab_[i].tableData.rowsWithDataArch[j]);
      }

      if (Tab_[i].needToFlip)
      {
        int count_column;
        getValue(Tab_[i].tagTable, "columnCount", count_column);

        for (int j = 4; j < count_column - 1; ++j)
        {
          dyn_string tmp;
          getValue(Tab_[i].tagTable, "getColumnN", j, tmp);

          for (int k = 1; k <= dynlen(tmp); ++k)
          {
            if (tmp[k].isEmpty())
            {
              Tab_[i].tableData.valuesArch[j - 3][k] = 0;
            }
            else
            {
              Tab_[i].tableData.valuesArch[j - 3][k] = tmp[k];
            }
          }
        }
      }
      else
      {
        for (int j = 1; j <= dynlen(Tab_[i].tableData.rowsWithDataArch); ++j)
        {
          for (int k = 5; k <= dynlen(Tab_[i].tableData.rowsWithDataArch[j]) - 1; ++k)
          {
            if (Tab_[i].tableData.rowsWithDataArch[j][k] == "")
            {
              Tab_[i].tableData.valuesArch[j][k - 4] = 0;
            }
            else
            {
              Tab_[i].tableData.valuesArch[j][k - 4] = Tab_[i].tableData.rowsWithDataArch[j][k];
            }
          }
        }
      }

      dyn_string keys = mappingKeys(buf_write_to_para_);

      for (int k = 1; k <= dynlen(keys); k++)
      {
        int col;

        getValue(buf_write_to_para_[keys[k]]["Title Table"], "nameToColumn", buf_write_to_para_[keys[k]]["Title Column"], col);
        int row = buf_write_to_para_[keys[k]]["Selected Rows"] + 1;
        int r = (Tab_[i].needToFlip) ? col - 3 : row;

        if (Tab_[i].tagTab == buf_write_to_para_[keys[k]]["Title Tab"])
        {
          setValue(buf_write_to_para_[keys[k]]["Title Table"], "cellBackColRC", buf_write_to_para_[keys[k]]["Selected Rows"], buf_write_to_para_[keys[k]]["Title Column"], "_Transparent");

          if (patternMatch("*UstEnable", keys[k]))
          {
            Tab_[i].tableData.UstEnable[r][3] = buf_write_to_para_[keys[k]]["Current Value"];
          }
          else if (patternMatch("*UstMsg", keys[k]))
          {
            Tab_[i].tableData.UstMsg[r][3]    = buf_write_to_para_[keys[k]]["Current Value"];
          }
          else if (patternMatch("*UstSound", keys[k]))
          {
            Tab_[i].tableData.UstSound[r][3]  = buf_write_to_para_[keys[k]]["Current Value"];
          }
        }
      }

      setValue("TAB1", "registerIcon", Tab_[i].id, "");
      Tab_[i].haveBeenChanges = false;
    }

    mappingClear(buf_write_to_para_);
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public updateValueFromArchive()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    QueryToDataBase();
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  //сравнение архива и плк по уставкам (нужно доделать)
  public comparingArrays()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    int ust_changed, msg_changed, sound_changed;

    for (int i = 1; i <= dynlen(Tab_); ++i)
    {
      int shift = 5;

      for (int row = 1; row <= dynlen(Tab_[i].tableData.rowsWithDataPLC); ++row)
      {
        for (int col = shift; col <= dynlen(Tab_[i].tableData.rowsWithDataPLC[row]); ++col)
        {
          int r = (Tab_[i].needToFlip) ? col - 4 : row;
          //проверка колонок на измененные уставки
          langString header_row;
          getValue(Tab_[i].tagTable, "rowHeader", row - 1, header_row);
          string name_column;
          getValue(Tab_[i].tagTable, "columnToName", col - 1, name_column);
          string name = (Tab_[i].needToFlip) ? header_row : name_column;

          if (mappingHasKey(maskUst, name))
          {
            ust_changed     = (uint)Tab_[i].tableData.UstEnable[r][2] ^ (uint)Tab_[i].tableData.UstEnable[r][3];
            msg_changed     = (uint)Tab_[i].tableData.UstMsg[r][2]    ^ (uint)Tab_[i].tableData.UstMsg[r][3];
            sound_changed   = (uint)Tab_[i].tableData.UstSound[r][2]  ^ (uint)Tab_[i].tableData.UstSound[r][3];
            int mask = maskUst[name];

            if ((ust_changed & mask) > 0 || (msg_changed & mask) > 0 || (sound_changed & mask) > 0)
            {
              if (dynCount(Tab_[i].needWriteToDB, Tab_[i].tableData.tagObjects[r]) == 0) dynAppend(Tab_[i].needWriteToDB, Tab_[i].tableData.tagObjects[r]);

              setValue(Tab_[i].tagTable, "cellBackColRC", row - 1, name_column, WARNING);
              setValue("TAB1", "registerIcon", Tab_[i].id, "2.png");
              Tab_[i].haveBeenChanges = true;
            }
          }

          if (Tab_[i].tableData.rowsWithDataPLC[row][col] != Tab_[i].tableData.rowsWithDataArch[row][col])
          {
            string color, name_column;
            getValue(Tab_[i].tagTable, "columnToName", col - 1, name_column);
            getValue(Tab_[i].tagTable, "cellBackColRC", row - 1, name_column, color);

            if (color != CCCCCC)
            {
              if (dynCount(Tab_[i].needWriteToDB, Tab_[i].tableData.tagObjects[r]) == 0) dynAppend(Tab_[i].needWriteToDB, Tab_[i].tableData.tagObjects[r]);

              setValue(Tab_[i].tagTable, "cellBackColRC", row - 1, name_column, WARNING);
              setValue("TAB1", "registerIcon", Tab_[i].id, "2.png");
              Tab_[i].haveBeenChanges = true;
            }
          }
        }
      }
    }

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public void changedValue(const string &tableName, int curRow, dyn_int rowsColumns_, string curValue, string colName)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START", rowsColumns_);

    string key, color;
    string form;
    string value;
    dyn_anytype tmp;
    int curColumn;

    shared_ptr<StateTab> tab = getCurrentTable(tableName);

    getValue(tableName, "nameToColumn", colName, curColumn);
    getValue(tableName, "cellBackColRC", curRow, colName, color);

    int r = (tab.needToFlip) ? curColumn - 3 : curRow + 1;
    int c = (tab.needToFlip) ? curRow + 1 : curColumn + 1;

    string path = (tab.needToFlip) ? tab.tableData.pathUst[r][c] : tab.tableData.pathUst[r][c - 4];
    //string format = (tab.needToFlip) ? tab.tableData.format[r][c] : tab.tableData.format[r][c];
    string format = tab.tableData.format[r][c];

    //if (tab.tableData.isVibration && curValue.isEmpty())  curValue = 0;
    float v = curValue;
    sprintf(curValue, format, v);
    strreplace(curValue, " ", "");


    if (Mode_.getMode()["PLC"] == true)
    {
      anytype var;
      dpGet(path, var);

      //if (var==0) value = 0;
      sprintf(value, format, var);
      strreplace(value, " ", "");

    }
    else
    {
      value = tab.tableData.rowsWithDataArch[curRow + 1][curColumn + 1];
    }


    if (color == WARNING && mappinglen(buf_write_to_para_) > 0)
    {

      if (value == curValue)
      {
        if (dynlen(rowsColumns_) > 1)
        {
          for (int i = 1; i <= dynlen(rowsColumns_); i++)
          {
            if (!tab.needToFlip)
            {
              curRow = rowsColumns_[i];
              getValue(tableName, "cellBackColRC", rowsColumns_[i], colName, color);
            }
            else
            {
              curColumn = rowsColumns_[i];
              getValue(tableName, "columnToName", curColumn, colName);
              getValue(tableName, "cellBackColRC", curRow, colName, color);
            }

            if (color != CCCCCC)
            {
              tmp[1] = (curValue == "TRUE") ? true : (curValue == "FALSE") ? false : curValue;
              tmp[2] = "_Transparent";
              tmp[3] = "";
              setValue(tableName, "cellValueRC", curRow, colName, curValue);
              setValue(tableName, "cellBackColRC", curRow, colName, "_Transparent");
              string key = (Ttab.needToFlip) ? Tab_[idx].tableData.pathUst[r][c] : tab.tableData.pathUst[r][c - 4];
              mappingRemove(buf_write_to_para_, key);
            }
          }
        }
        else
        {
          if (color != CCCCCC)
          {
            tmp[1] = (curValue == "TRUE") ? true : (curValue == "FALSE") ? false : curValue;
            tmp[2] = "_Transparent";
            tmp[3] = "";
            setValue(tableName, "cellValueRC", curRow, colName, curValue);
            string key = (Ttab.needToFlip) ? Tab_[idx].tableData.pathUst[r][c] : tab.tableData.pathUst[r][c - 4];
            mappingRemove(buf_write_to_para_, key);
          }
        }
      }

      if (mappinglen(buf_write_to_para_) == 0)
      {
        setValue("TAB1", "registerIcon", tab.id, "");
        tab.haveBeenChanges = false;
      }
    }

//       DebugN(value, curValue);
    if (value != curValue && color != CCCCCC)
    {
      if (dynlen(rowsColumns_) > 1)
      {

        for (int i = 1; i <= dynlen(rowsColumns_); i++)
        {

          if (!tab.needToFlip)
          {
            getValue(tableName, "cellBackColRC", rowsColumns_[i], colName, color);
          }
          else
          {
            getValue(tableName, "columnToName", rowsColumns_[i], colName);
            getValue(tableName, "cellBackColRC", curRow, colName, color);
          }

          if (color != CCCCCC)
          {
            tmp[1] = (curValue == "TRUE") ? true : (curValue == "FALSE") ? false : curValue;
            tmp[2] = WARNING;
            tmp[3] = "";

            if (!tab.needToFlip)
            {
              curRow = rowsColumns_[i];
              setValue(tableName, "cellValueRC", curRow, colName, curValue);
              setValue(tableName, "cellBackColRC", curRow, colName, WARNING);
            }
            else
            {
              curColumn = rowsColumns_[i];
              setValue(tableName, "cellValueRC", curRow, colName, curValue);
              setValue(tableName, "cellBackColRC", curRow, colName, WARNING);
            }

            setValue("TAB1",    "registerIcon",  tab.id, "2.png");
            tab.haveBeenChanges = true;

            string key;

            if (curValue != "")
            {
              if (dynCount(tab.needWriteToDB, tab.tableData.tagObjects[i]) == 0)
              {
                DebugN("333", tab.tableData.tagObjects[i]);
                dynAppend(tab.needWriteToDB, tab.tableData.tagObjects[i]);
              }

              //временный костыль
              int r = (tab.needToFlip) ? curColumn - 3 : curRow + 1;
              int c = (tab.needToFlip) ? curRow + 1 : curColumn - 3;
              //вычитываем каждое значение отдельно, для корректности сообщений
              value = (Mode_.getMode()["PLC"] == true) ? tab.tableData.valuesPLC[r][c] : tab.tableData.valuesArch[r][c];
              //заполняем буфер на запись в PLC
              key = tab.tableData.pathUst[r][c];
              buf_write_to_para_[key] = makeMapping();
              buf_write_to_para_[key]["Current Value"]    = curValue;
              buf_write_to_para_[key]["Old Value"]        = value;
              buf_write_to_para_[key]["Title Table"]      = tableName;
              buf_write_to_para_[key]["Selected Rows"]    = curRow;
              buf_write_to_para_[key]["Selected Columns"] = curColumn;
              buf_write_to_para_[key]["Title Column"]     = colName;
              buf_write_to_para_[key]["Title Tab"]        = tab.tagTab;
            }
          }
        }
      }
      else
      {
        tmp[1] = (curValue == "TRUE") ? true : (curValue == "FALSE") ? false : curValue;
        tmp[2] = WARNING;
        tmp[3] = "";
        setValue(tableName, "cellValueRC", curRow, colName, tmp);
        setValue(tableName, "cellBackColRC", curRow, colName, WARNING);
        setValue("TAB1", "registerIcon", tab.id, "2.png");
        tab.haveBeenChanges = true;
        //тут будет вызываться функция для проверки корректности ввода уставок
        string key;

        if (curValue != "")
        {
          if (dynCount(tab.needWriteToDB, tab.tableData.tagObjects[r]) == 0) dynAppend(tab.needWriteToDB, tab.tableData.tagObjects[r]);

          key = (tab.needToFlip) ? Tab_[idx].tableData.pathUst[r][c] : tab.tableData.pathUst[r][c - 4];
          buf_write_to_para_[key] = makeMapping();
          buf_write_to_para_[key]["Current Value"]    = curValue;
          buf_write_to_para_[key]["Old Value"]        = value;
          buf_write_to_para_[key]["Title Table"]      = tableName;
          buf_write_to_para_[key]["Selected Rows"]    = curRow;
          buf_write_to_para_[key]["Selected Columns"] = curColumn;
          buf_write_to_para_[key]["Title Column"]     = colName;
          buf_write_to_para_[key]["Title Tab"]        = tab.tagTab;
        }
      }
    }
    else
    {
      if (color != CCCCCC)
      {
        tmp[1] = (curValue == "TRUE") ? true : (curValue == "FALSE") ? false : curValue;
        tmp[2] = "_Transparent";
        tmp[3] = "";
        setValue(tableName, "cellValueRC", curRow, colName, tmp);
      }
    }

//       DebugN(__FUNCTION__ , buf_write_to_para_);
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  private changingSizeTable(anytype tab)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    int size_total_cell, addNumber = 37;
    shape table = tab.classTable.get_table();
    int column_count;
    getValue(table, "columnCount", column_count);
    bool lineBreak;
    string columnHeader;

    for (int i = 0; i < column_count; ++i)
    {
      getValue(table, "columnHeader", i, columnHeader);

      if (columnHeader.contains("\n"))
      {
        addNumber = 53;
        break;
      }
    }


    for (int i = 1; i <= column_count; i++)
    {
      int size;
      getValue(table, "columnWidth", i - 1, size);
      size_total_cell += size;
    }

    int r, c;
    getValue(table, "minimumSize", r, c);

    size_total_cell += 17;

    if (size_total_cell < r)
    {
      table.size(size_total_cell, c + addNumber);
      table.minimumSize(size_total_cell, c + addNumber);
      table.maximumSize(size_total_cell, c + addNumber);
    }
    else
    {
      size_total_cell = r;
    }

    if ((table.rowHeight() * table.lineCount()) < SIZE_Y)
    {
      table.size(size_total_cell, (table.rowHeight() * table.lineCount()) + addNumber);
      table.minimumSize(size_total_cell, (table.rowHeight() * table.lineCount()) + addNumber);
      table.maximumSize(size_total_cell, (table.rowHeight() * table.lineCount()) + addNumber);
    }
  }

  public cellRightClick(int row, string col, string name)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " START");
    int c;
    dyn_bool activity;
    string name_row, color, curent_color, curent_value;
    uint ust_enab, msg_enab, sound_enab;
    bool isUst = false;

    getValue(name, "nameToColumn", col, c);
//         DebugN(row, c);
    getValue(name, "rowHeader", row, name_row);
    getValue(name, "cellBackColRC", row, col, color);
    mapping mode = Mode_.getMode();

    shared_ptr<StateTab> tab = getCurrentTable(name);

    dyn_string txt;
    int answer;
    uint mask;

    //if (tab.tableData.isVibration) return;


    if (tab.needToFlip)
    {

      langString header_row;
      getValue(name, "rowHeader", row, header_row);

      if (mappingHasKey(maskUst, (string)header_row))
      {
        mask = maskUst[(string)header_row];
        ust_enab     = (mode["Archive"]) ? tab.tableData.UstEnable[c - 3][2] : tab.tableData.UstEnable[c - 3][3];
        msg_enab     = (mode["Archive"]) ? tab.tableData.UstMsg[c - 3][2] : tab.tableData.UstMsg[c - 3][3];
        sound_enab   = (mode["Archive"]) ? tab.tableData.UstSound[c - 3][2] : tab.tableData.UstSound[c - 3][3];
        isUst = true;
      }
    }
    else
    {
      if (mappingHasKey(maskUst, col))
      {
        ust_enab     = (mode["Archive"]) ? tab.tableData.UstEnable[row + 1][2] : tab.tableData.UstEnable[row + 1][3];
        msg_enab     = (mode["Archive"]) ? tab.tableData.UstMsg[row + 1][2] : tab.tableData.UstMsg[row + 1][3];
        sound_enab   = (mode["Archive"]) ? tab.tableData.UstSound[row + 1][2] : tab.tableData.UstSound[row + 1][3];
        mask = maskUst[col];
        isUst = true;
      }
    }


    bool enable = (ust_enab & mask) > 0;

    if (isUst)
    {


      txt = makeDynString( //"CHECK_BUTTON, Включить уставку, 1, 1, " + (int)((ust_enab & mask) > 0),
              "CHECK_BUTTON, Включить уставку, 1, 1, " + ((color == CCCCCC) ? 0 : ((ust_enab & mask) > 0) ? 1 : 0),
              "SEPARATOR", // Разделительная линия
              "CHECK_BUTTON, Включить звук, 2, " + (int)enable + ", " + ((color == CCCCCC) ? 0 : ((sound_enab & mask) > 0) ? 1 : 0),
              "SEPARATOR", // Разделительная линия
              "CHECK_BUTTON, Включить сообщения, 3, " + (int)enable + ", " + ((color == CCCCCC) ? 0 : ((msg_enab & mask) > 0) ? 1 : 0));




      popupMenu(txt, answer);

      int value;
      string path, form, rez_value;

      int r = (tab.needToFlip) ? c - 3 : row + 1;

      switch (answer)
      {
        case 1:
          if (dynCount(tab.needWriteToDB, tab.tableData.tagObjects[r]) == 0) dynAppend(tab.needWriteToDB, tab.tableData.tagObjects[r]);

          curent_value = (mode["Archive"]) ? tab.tableData.rowsWithDataArch[r][c + 1] : tab.tableData.rowsWithDataPLC[row + 1][c + 1];

          value = (color != CCCCCC) ? (ust_enab & ~mask) : (ust_enab | mask);
          curent_color = (color == CCCCCC) ? "_Transparent" : CCCCCC;

//                       DebugN(r, c, tab.tableData.rowsWithDataPLC[r][c+1]);
          rez_value = (color == CCCCCC) ? curent_value : (tab.tableData.isVibration) ? curent_value : "";


          setValue(name, "cellFormatRC", row, col, "[0s,,,ALIGNMENT_CENTER]");
          setValue(name, "cellBackColRC", row, col, curent_color);
          setValue(name, "cellValueRC", row, col, rez_value);

          path = tab.tableData.UstEnable[r][1];
          buf_write_to_para_[path] = makeMapping();
          buf_write_to_para_[path]["Current Value"] = value;
          buf_write_to_para_[path]["Title Table"]   = name;
          buf_write_to_para_[path]["Selected Rows"] = row;
          buf_write_to_para_[path]["Selected Columns"] = c;
          buf_write_to_para_[path]["Title Column"]  = col;
          buf_write_to_para_[path]["Title Tab"]     = tab.tagTab;
          buf_write_to_para_[path]["Old Value"] = ust_enab;
//                       setValue(name, "cellBackColRC", row, col, WARNING);
          setValue("TAB1", "registerIcon", tab.id, "2.png");
          tab.haveBeenChanges = true;


          if (mode["Archive"])
          {
            tab.tableData.UstEnable[r][2] = value;

            if ((value & mask) == 0)
            {
              //
              tab.tableData.UstSound[r][2]  = sound_enab & ~mask;
              path = tab.tableData.UstSound[r][1];
              buf_write_to_para_[path] = makeMapping();
              buf_write_to_para_[path]["Current Value"] = value;
              buf_write_to_para_[path]["Title Table"]   = name;
              buf_write_to_para_[path]["Selected Rows"] = row;
              buf_write_to_para_[path]["Selected Columns"] = c;
              buf_write_to_para_[path]["Title Column"]  = col;
              buf_write_to_para_[path]["Title Tab"]     = tab.tagTab;
              buf_write_to_para_[path]["Old Value"] = sound_enab;
              //
              tab.tableData.UstMsg[r][2]  = msg_enab & ~mask;
              path = tab.tableData.UstMsg[r][1];
              buf_write_to_para_[path] = makeMapping();
              buf_write_to_para_[path]["Current Value"] = value;
              buf_write_to_para_[path]["Title Table"]   = name;
              buf_write_to_para_[path]["Selected Rows"] = row;
              buf_write_to_para_[path]["Selected Columns"] = c;
              buf_write_to_para_[path]["Title Column"]  = col;
              buf_write_to_para_[path]["Title Tab"]     = tab.tagTab;
              buf_write_to_para_[path]["Old Value"] = msg_enab;
            }
          }
          else
          {
            tab.tableData.UstEnable[r][3] = value;

            if ((value & mask) == 0)
            {

              //
              tab.tableData.UstSound[r][3]  = sound_enab & ~mask;
              path = tab.tableData.UstSound[r][1];
              buf_write_to_para_[path] = makeMapping();
              buf_write_to_para_[path]["Current Value"] = value;
              buf_write_to_para_[path]["Title Table"]   = name;
              buf_write_to_para_[path]["Selected Rows"] = row;
              buf_write_to_para_[path]["Selected Columns"] = c;
              buf_write_to_para_[path]["Title Column"]  = col;
              buf_write_to_para_[path]["Title Tab"]     = tab.tagTab;
              buf_write_to_para_[path]["Old Value"] = sound_enab;
              //
              tab.tableData.UstMsg[r][3]  = msg_enab & ~mask;
              path = tab.tableData.UstMsg[r][1];
              buf_write_to_para_[path] = makeMapping();
              buf_write_to_para_[path]["Current Value"] = value;
              buf_write_to_para_[path]["Title Table"]   = name;
              buf_write_to_para_[path]["Selected Rows"] = row;
              buf_write_to_para_[path]["Selected Columns"] = c;
              buf_write_to_para_[path]["Title Column"]  = col;
              buf_write_to_para_[path]["Title Tab"]     = tab.tagTab;
              buf_write_to_para_[path]["Old Value"] = msg_enab;
            }
          }

//                       DebugN(__FUNCTION__ , buf_write_to_para_);
          break;

        case 2:

          //DebugN(sound_enab, mask, tab.tableData.UstSound[r][3]);
          if (dynCount(tab.needWriteToDB, tab.tableData.tagObjects[r]) == 0) dynAppend(tab.needWriteToDB, tab.tableData.tagObjects[r]);

          value = (color == CCCCCC) ? (sound_enab & ~mask) : ((sound_enab & mask) > 0) ? (sound_enab & ~mask) : (sound_enab | mask);
          path = tab.tableData.UstSound[r][1];
          buf_write_to_para_[path] = makeMapping();
          buf_write_to_para_[path]["Current Value"] = value;
          buf_write_to_para_[path]["Title Table"]   = name;
          buf_write_to_para_[path]["Selected Rows"] = row;
          buf_write_to_para_[path]["Selected Columns"] = c;
          buf_write_to_para_[path]["Title Column"]  = col;
          buf_write_to_para_[path]["Title Tab"]     = tab.tagTab;
          buf_write_to_para_[path]["Old Value"] = sound_enab;
          setValue("TAB1", "registerIcon", tab.id, "2.png");
          tab.haveBeenChanges = true;

          if (mode["Archive"])
          {
            tab.tableData.UstSound[r][2]  = value;
          }
          else
          {
            tab.tableData.UstSound[r][3]  = value;
          }

//                       DebugN(__FUNCTION__ , buf_write_to_para_);
          break;

        case 3:
          if (dynCount(tab.needWriteToDB, tab.tableData.tagObjects[r]) == 0) dynAppend(tab.needWriteToDB, tab.tableData.tagObjects[r]);

          value = (color == CCCCCC) ? (msg_enab & ~mask) : ((msg_enab & mask) > 0) ? (msg_enab & ~mask) : (msg_enab | mask);
          path = tab.tableData.UstMsg[r][1];
          buf_write_to_para_[path] = makeMapping();
          buf_write_to_para_[path]["Current Value"] = value;
          buf_write_to_para_[path]["Title Table"]   = name;
          buf_write_to_para_[path]["Selected Rows"] = row;
          buf_write_to_para_[path]["Selected Columns"] = c;
          buf_write_to_para_[path]["Title Column"]  = col;
          buf_write_to_para_[path]["Title Tab"]     = tab.tagTab;
          buf_write_to_para_[path]["Old Value"] = msg_enab;
          setValue("TAB1", "registerIcon", tab.id, "2.png");
          tab.haveBeenChanges = true;

          if (mode["Archive"])
          {
            tab.tableData.UstMsg[r][2]  = value;
          }
          else
          {
            tab.tableData.UstMsg[r][3]  = value;
          }

//                       DebugN(__FUNCTION__ , buf_write_to_para_);
          break;

        default: DebugN(__FUNCTION__, name_row); break;
      }

    }
  }

  private fillTables(anytype &tab, bool FocusOnFirstRow = true, bool isArch = false)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    mapping mode = Mode_.getMode();
    dyn_mixed tmp;
    shape table = tab.classTable.get_table();
    string format = "";
    int cCount = table.columnCount();
    int rCount = table.lineCount();
    table.columnVisibility(cCount - 1, FALSE);
    dyn_string col_name_;
    dyn_langString row_name_;
    bool isUst;
    uint mask, ust_enab;
    anytype rows = (isArch || mode["Archive"]) ? tab.tableData.rowsWithDataArch : tab.tableData.rowsWithDataPLC;

    for (int i = 1; i <= cCount; i++)
    {
      col_name_[i] = table.columnName(i - 1);
    }

    for (int i = 1; i <= dynlen(rows); i++)
    {
      setValue(tab.tagTable, "rowHeader", i - 1, rows[i][3]);
    }

    for (int i = 1; i <= rCount; i++)
    {
      getValue(tab.tagTable, "rowHeader", i - 1, row_name_[i]);
    }

    int count = -1;

    for (int i = 1; i <= (dynlen(rows)); i++)
    {
      if (dynlen(rows) < 1 || dynlen(rows[i]) < 4)
      {
        continue;
      }

      count++;
//           table.rowHeader(count,rows[i][3]);

      for (int j = 1; j <= dynlen(col_name_) - 1; j++)
      {
        tmp[1] = (rows[i][j] == "TRUE") ? true : (rows[i][j] == "FALSE") ? false : rows[i][j];
        tmp[2] = "";
        tmp[3] = "";

        isUst = (tab.needToFlip) ? ((rows[i][3].contains("UstMin") || rows[i][3].contains("UstMax")) && j > 4) :
                (col_name_[j].contains("UstMin") || col_name_[j].contains("UstMax"));


        int r = (tab.needToFlip) ? j - 4 : i;
        int c = (tab.needToFlip) ? i : j - 4;

        if (isUst)
        {
          string key = (tab.needToFlip) ? row_name_[i] : col_name_[j];
          ust_enab = (isArch || mode["Archive"]) ? tab.tableData.UstEnable[r][2] : tab.tableData.UstEnable[r][3];
//                 if (i == 1) DebugN(ust_enab, key, tab.tableData.UstEnable[r]);

          if (mappingHasKey(maskUst, key))
          {
            mask = maskUst[key];
            format = ((ust_enab & mask) == mask || tab.tableData.isVibration) ? tab.tableData.format[r][c] : "";
//                   if (i == 1) DebugN(ust_enab, mask, key, tab.tableData.UstEnable[r]);
          }

          tmp[2] = ((ust_enab & mask) == mask) ? "" : CCCCCC;
          tmp[1] = ((ust_enab & mask) == mask || tab.tableData.isVibration) ? tmp[1] : "";

          if ((ust_enab & mask) == 0)
          {
            table.cellEditableRC(count, col_name_[j], FALSE);
          }

        }
        else
        {
//           if (tab.needToFlip)
//           {
//             if (j > 4 && j < dynlen(col_name_) - 1) format = tab.tableData.format[r][c];
//           }
//           else
//           {
//             format = tab.tableData.format[i][j];
//           }
          if (j > 4 && j < dynlen(col_name_) - 1) format = tab.tableData.format[r][c];
        }

//               Задание формата ячейкам (todo нужно будет вынести в отдельный приватный метод)
        if (col_name_[j] == "name")
        {
          table.cellFormatRC(count, col_name_[j], "[0s,,,ALIGNMENT_LEFT]");
        }
        else
        {
          if (col_name_[j] == "id" || col_name_[j] == "tag" || col_name_[j] == "unit")
          {
            table.cellFormatRC(count, col_name_[j], "[0s,,,ALIGNMENT_CENTER]");
          }
          else
          {
            table.cellFormatRC(count, col_name_[j], "[" + strltrim(format, "%") + ",False,False,AlignHCenter|AlignVCenter,False]");
          }
        }

        table.cellValueRC(count, col_name_[j], tmp);
        table.cellEditableRC(count, col_name_[j], FALSE);

        //перемещаем фокус на первую строку, если это необходимо
        if (FocusOnFirstRow)
        {
          table.lineVisible(0);
        }

      }
    }

    this.TabView.init = false;
    changingSizeTable(tab);
  }

  //ИНИЦИАЛИЗАЦИЯ ТАБЛИЦ
  private initTables()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    for (int i = 1; i <= dynlen(Tab_); i++)
    {
      //создаем таблицу для каждой вкладки
      shape TABLE_                    = addShape(myModuleName(), myPanelName(), 1, "TABLE", Tab_[i].tagTable);
      shared_ptr<TableViewScad> Table = new TableViewScad(TABLE_, Tab_[i].needToFlip, editingIsAllowed, "Аналог");
      Tab_[i].classTable              = Table;
    }

    QueryToDataBase(true);
  }


  private QueryToDataBase(bool init = false)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    IndicatorLoad.start();

    for (int i = 1; i <= dynlen(Tab_); i++)
    {
      // формируем запрос в БД
      string request = getDataFromSQLanalog;
      strreplace(request, "$2", Tab_[i].nameSQLTable);

      // запрос в БД
      dyn_dyn_string result = db.getData(request);

      if (dynlen(result) == 0) continue; //пропускаем, если нет результата

      //заполнение полей класса
      Tab_[i].tableData.clear();
      Tab_[i].fillingObjectsWithDataAnalog(result);

      if (init) initColumns(i);
      processingRequest(Tab_[i]);
    }

    TabView.setTabEnable(true);
    IndicatorLoad.stop();
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --->  END");
  }


  private initColumns(int i)
  {

    dyn_string tags = Tab_[i].getTags();
    dyn_string columns  = Tab_[i].getColums();

     // добавляем в конец таблицы колонку, чтобы была граница
    dynInsertAt(columns, "",    dynlen(columns) + 1);
    dynInsertAt(tags,    "end", dynlen(tags) + 1);

    // формирование колонок таблиц
    Tab_[i].classTable.insert_columns(columns, tags);
    Tab_[i].classTable.append_lines(Tab_[i].getCountLine());
  }

  public printTables()
  {
    string nameTab;
    getValue("TAB1", "namedActiveRegister", nameTab);
    shared_ptr<StateTab> tab = getCurrentTab(nameTab);
    shared_ptr<ClassPrintTable> PT = new ClassPrintTable(tab);
    string msg = "Крата уставок \"" + tab.title + "\" отправлена на печать";
    openInformationPanel(makeDynString("$sInformation:" + msg + "", "$iTimer:0", "$bCritical:false"), "-1", "-1");
    CreateMultiInstanceMessage("Произведена печать карты уставок \"" + tab.title + "\" пользователем " + getUserName(), "", "armMessages_10", "armMessages_10", getHostname());
    PT.createTable();
  }

  // Обработка результата запроса в БД
  private processingRequest(anytype& tab)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    //заполняем словарь для архивных данных
    dynClear(tab.tableData.rowsWithDataPLC);
    dynClear(tab.tableData.rowsWithDataArch);

    tab.fillingTableRows();

    //заполняем виджет "таблица" данными
    fillTables(tab);

  }

  public writeToSQL()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    IndicatorLoad.start();
    mapping mode = Mode_.getMode();

    if (!(bool)mode["PLC"]) updateRowsTable();
    else comparingArrays();

    for (int i = 1; i <= dynlen(Tab_); ++i)
    {
      int id = startThread("createQuery", i);
      waitThread(id);
      fillTables(Tab_[i], false, true);
      setValue("TAB1", "registerIcon", Tab_[i].id, "");
      Tab_[i].haveBeenChanges = false;
    }

    IndicatorLoad.stop();
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + "----> END");
  }

  private createMessage(anytype buff, string key)
  {
    string cur_value_   = buff["Current Value"];
    string old_value_   = buff["Old Value"];
    string table_name_  = buff["Title Table"];
    int row_            = buff["Selected Rows"];
    int col_            = buff["Selected Columns"];
    string name_column_ = buff["Title Column"];
    string tab_name_    = buff["Title Tab"];
    string nameUst;
    string msg, msg1;
    bool isUstOnOff = false;
    int col;
    getValue(table_name_, "nameToColumn", name_column_, col);
    string rowHeader;
    getValue(table_name_, "rowHeader", row_, rowHeader);

    shared_ptr<StateTab> tab = getCurrentTab(tab_name_);

    int r = (tab.needToFlip) ? col - 3 : row_ + 1;
    int c = (tab.needToFlip) ? row_ + 1 : col - 3;

    nameUst = tab.tableData.nameObjects[r];
    string unit = tab.tableData.units[r][c];
    string tagUst = tab.tableData.nameUst[r][c];

    if (key.contains("UstEnable") || key.contains("UstMsg") || key.contains("UstSound"))
    {
      isUstOnOff = true;
      dpGet(key, old_value_);
//         DebugN(old_value_);
      int count1 = 6;
      int count2 = 7;

      for (int i = 0; i < 16; ++i)
      {

        if (!tab.needToFlip)
        {
          if (i < 6)
          {
            tagUst = tab.tableData.nameUst[row_ + 1][count1];
            count1--;
          }
          else if (i > 7 && i < 14)
          {
            tagUst = tab.tableData.nameUst[row_ + 1][count2];
            count2++;
          }
          else continue;
        }
        else
        {
          if (i < 6)
          {
            tagUst = tab.tableData.nameUst[col_ - 2][count1];
            count1--;
          }
          else if (i > 7 && i < 14)
          {
            tagUst = tab.tableData.nameUst[col_ - 2][count2];
            count2++;
          }
          else continue;
        }

        strreplace(nameUst, "\n", "");
        strreplace(tagUst, "\n", "");

        if ((int)cur_value_ > (int)old_value_)
        {
          if (getBit((int)cur_value_, i) && !getBit((int)old_value_, i))
          {
//                 DebugN("ON", cur_value_, old_value_, count1, count2, i);
            if (key.contains("UstEnable")) msg = "Пользователь " + getUserName() + " отправил(а) команду включить устаку \"$1\"($5) в ПЛК";
            else if (key.contains("UstMsg")) msg = "Пользователь " + getUserName() + " отправил(а) команду включить выдачу сообщений по уставке \"$1\"($5) в ПЛК";
            else if (key.contains("UstSound")) msg = "Пользователь " + getUserName() + " отправил(а) команду включить звуковое оповещение по уставке \"$1\"($5) в ПЛК";

            strreplace(msg, "$1", nameUst);
            strreplace(msg, "$5", tagUst);
            CreateMultiInstanceMessage(msg, "", "armMessages_10", "armMessages_10", getHostname());
          }
        }
        else if ((int)cur_value_ < (int)old_value_)
        {
          if (!getBit((int)cur_value_, i) && getBit((int)old_value_, i))
          {
            if (key.contains("UstEnable")) msg = "Пользователь " + getUserName() + " отправил(а) команду отключить устаку \"$1\"($5) в ПЛК";
            else if (key.contains("UstMsg")) msg = "Пользователь " + getUserName() + " отправил(а) команду отключить выдачу сообщений по уставке \"$1\"($5) в ПЛК";
            else if (key.contains("UstSound")) msg = "Пользователь " + getUserName() + " отправил(а) команду отключить звуковое оповещение по уставке \"$1\"($5) в ПЛК";

            strreplace(msg, "$1", nameUst);
            strreplace(msg, "$5", tagUst);
            CreateMultiInstanceMessage(msg, "", "armMessages_10", "armMessages_10", getHostname());
          }
        }
      }
    }

    if (!isUstOnOff)
    {
      msg = "Пользователь " + getUserName() + " отправил(а) команду сохранить устаку \"$1\"($5) в ПЛК";
      strreplace(msg, "$1", nameUst);
      strreplace(msg, "$5", tagUst);


      msg1 = "Пользователь " + getUserName() + " изменил(а) уставку \"$1\"($5) c $2 $3 на $4 $3";
      strreplace(msg1, "$1", nameUst);
      strreplace(msg1, "$2", old_value_);
      strreplace(msg1, "$3", unit);
      strreplace(msg1, "$4", cur_value_);
      strreplace(msg1, "$5", tagUst);
    }

    if (!msg.isEmpty() && !isUstOnOff) CreateMultiInstanceMessage(msg, "", "armMessages_10", "armMessages_10", getHostname());

    if (!isUstOnOff) CreateMultiInstanceMessage(msg1, "", "armMessages_10", "armMessages_10", getHostname());
  }

  private createQuery(int i)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    string ust_tag;
    string obj_tag;
    string obj = Tab_[i].nameSQLTable;                   //получаем имя таблицы в SQL;
    bool rotateTable = Tab_[i].needToFlip;                             //проверяем повернута таблица или нет;
    mapping mode = Mode_.getMode();

    int shift = 0;

    if (dynlen(Tab_[i].needWriteToDB) == 0) return;

    dyn_string rows = Tab_[i].needWriteToDB;
    DebugN(Tab_[i].needWriteToDB);
    for (int row = 1; row <= dynlen(rows); ++row)
    {
      int indx = dynContains(Tab_[i].tableData.tagObjects, rows[row]);

      if (indx == 0) continue;

      string updateSQL = writeToDb;
      dyn_string val = ((bool)mode["PLC"]) ? Tab_[i].tableData.valuesPLC[indx] : Tab_[i].tableData.valuesArch[indx];
      strreplace(updateSQL, "$1", obj);
      strreplace(updateSQL, "$3", rows[row]);
      strreplace(updateSQL, "$2", strjoin(val, ","));

      DebugN(updateSQL);

      db.setData(updateSQL);
      db_re.setData(updateSQL);

      string updateSQL = writeToDbSettings;
      dyn_string val;
      dynAppend(val, ((bool)mode["PLC"]) ? Tab_[i].tableData.UstEnable[indx][3] : Tab_[i].tableData.UstEnable[indx][2]);
      dynAppend(val, ((bool)mode["PLC"]) ? Tab_[i].tableData.UstMsg[indx][3] : Tab_[i].tableData.UstMsg[indx][2]);
      dynAppend(val, ((bool)mode["PLC"]) ? Tab_[i].tableData.UstSound[indx][3] : Tab_[i].tableData.UstSound[indx][2]);
      strreplace(updateSQL, "$1", obj);
      strreplace(updateSQL, "$3", rows[row]);
      strreplace(updateSQL, "$2", strjoin(val, ","));

      DebugN(updateSQL);

      db.setData(updateSQL);
      db_re.setData(updateSQL);

      if ((bool)mode["PLC"]) Tab_[i].tableData.UstEnable[indx][2] = Tab_[i].tableData.UstEnable[indx][3];

      if ((bool)mode["PLC"]) Tab_[i].tableData.UstMsg[indx][2]    = Tab_[i].tableData.UstMsg[indx][3];

      if ((bool)mode["PLC"]) Tab_[i].tableData.UstSound[indx][2]  = Tab_[i].tableData.UstSound[indx][3];

    }

    if ((bool)mode["PLC"]) Tab_[i].tableData.valuesArch = Tab_[i].tableData.valuesPLC;

    if ((bool)mode["PLC"]) Tab_[i].tableData.rowsWithDataArch = Tab_[i].tableData.rowsWithDataPLC;

    dynClear(Tab_[i].needWriteToDB);

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  ~EntityMapAnalog()
  {
    DebugN("setPointMap is closed");
  }
};