PIR/PIRTypes.pas - master - YakuninAV/Convertors

PIR/PIRTypes.pas
2 063 строки85 KB
YakuninAV
begin with gitflick
31 июл 2026, 15:21
31 июл 2026, 15:211dc0fc6
{*******************************************************}
{                                                       }
{       DBD PIR library                                 }
{                                                       }
{       Copyright (C) 2020 Databasis Development        }
{                                                       }
{*******************************************************}
/// Модуль, содержащий объявления типов для работы с ПИР
unit PIRTypes;

{$I Synopse.inc}

interface

uses
  SysUtils, Classes, Types, StrUtils, Graphics,
  SynCommons,
  DBDIntfs, DBDStrUtils,
  PIRImportConsts;

var
  /// Символ для выделения адреса области таблицы в тексте
  PirTableAddressMark: AnsiChar = '$';
  /// Разделитель уровней
  pirContentsLevelSeparator: AnsiChar = '.';
  /// Разделитель частей
  pirContentsPartSeparator: AnsiChar = '-';
  /// Фонт используемый по умолчанию
  //  name, size, styles, charset, color
  pirDefaultFont: string = 'Tahoma,8,[],DEFAULT_CHARSET,clWindowText';
  /// Цвет фона по умолчанию
  pirDefaultColor: Integer = -16777211; //clWindow;

type

  /// Опции, используемые при импорте
  // pirImpAutoSave - сохраняет результат импорта автоматически
  // pirImpNoLog - отключает протоколирование
  TPIRImporterOption = (pirImpAutoSave, pirImpNoLog);
  /// Набор опций импорта
  TPIRImporterOptions = set of TPIRImporterOption;

  /// Тип источника информации
  //  pirQUSTConst    - константа
  //  pirQUSTAddress  - номер колонки или строки, содержащей информацию
  //  pirTSTText      - текст, в котором могут находится адресные ссылки
  //  pirQUSTNameTail - номер колонки или строки, содержащей текст, в конце которого, после запятой, содержится информация
  TPIRTableSourceType = (pirTSTConst, pirTSTAddress, pirTSTText, pirTSTNameTail);
  /// Набор типов источников информации
  TPIRTableSourceTypes = set of TPIRTableSourceType;

  /// Состояние документа
  // pirDSImported   - Документ введён в систему
  // pirDSInWork     - Документ находится в работе
  // pirDSPreRelease - Документ готовится к выпуску
  // pirDSReleased   - Документ выпущен
  // pirDSModified   - В выпущенный документ внесены изменения
  // pirDSCanceled   - Документ отменён
  TPIRDocumentState = (pirDSImported, pirDSInWork, pirDSPreRelease, pirDSReleased, pirDSModified, pirDSCanceled);

  /// Опции формирования текста параметра
  // pirQPTOName  - включить в текст наименование параметра
  // pirQPTOUnit  - включить в текст название единицы измерения
  // pirQPTOValue - включить в текст значение(я) параметра, значение(я) выводится как в исходнике
  // pirQPTOBands - включить в текст граничные значения параметра в формате "от ... до ..."
  TPIRQuotationParameterTextOption = (pirQPTOName, pirQPTOUnit, pirQPTOValue, pirQPTOBands);
  /// Набор опций для формирования текста параметра
  TPIRQuotationParameterTextOptions = set of TPIRQuotationParameterTextOption;

  /// Типы параметров расценок
  // pirQPKEnum - (E) - значение для подбора расценки
  // pirQPKList - (L) - список значений с описаниями для организации расчёта
  // pirQPKBand - (P) - диапазон значений, используется только для расчётов, но не подбора расценки
  // pirQPKSpan - (S) - диапазон значений, как для расчётов, так и для подбора расценки
  // pirQPKAddn - (A) - дополнительная расценка
  // pirQPKFrml - (N) - Количественная формула
  TPIRQuotationParameterKind = (pirQPKBand, pirQPKSpan, pirQPKEnum, pirQPKList, pirQPKAddn, pirQPKFrml);
  /// Набор типов параметров расценок
  TPIRQuotationParameterKinds = set of TPIRQuotationParameterKind;

  /// Тип изыскательских работ
  // pirSWTField - полевые работы
  // pirSWTDesc  - камеральные работы
  // pirSWTLab   - лабораторные работы
  // pirSWTFree  - свободные работы (всё в куче)
  // pirSWTNone  - не изысканательская работа
  TPIRSurveyWorkType = (pirSWTField, pirSWTDesc, pirSWTLab, pirSWTFree, pirSWTNone);
  /// Набор типов изыскательских работ
  TPIRSurveyWorkTypes = set of TPIRSurveyWorkType;

const
  /// Типы параметрв расценок, которые могут быть использваны в качестве объёмных
  PIRQuotationParameterVolumed: TPIRQuotationParameterKinds = [pirQPKBand, pirQPKSpan];

  PIRQuotationParameterTextNone: TPIRQuotationParameterTextOptions = [];
  PIRQuotationParameterTextFull: TPIRQuotationParameterTextOptions = [pirQPTOName, pirQPTOUnit, pirQPTOValue];
  PIRQuotationParameterTextValueOnly: TPIRQuotationParameterTextOptions = [pirQPTOValue];
  PIRQuotationParameterTextWOUnit: TPIRQuotationParameterTextOptions = [pirQPTOName, pirQPTOValue];
  PIRQuotationParameterTextWOName: TPIRQuotationParameterTextOptions = [pirQPTOUnit, pirQPTOValue];
  PIRQuotationParameterTextBandsOnly: TPIRQuotationParameterTextOptions = [pirQPTOBands];
  PIRQuotationParameterTextBands: TPIRQuotationParameterTextOptions = [pirQPTOName, pirQPTOUnit, pirQPTOBands];

type
  /// Виды таблиц
  //   - pirTKUndefine  - неопределено
  //   - pirTKDummy     - необрабатываемая таблица
  //   - pirTKQuotation - таблица с расценками
  //   - pirTKContinue  - продолжение таблицы
  TPIRTableKind = (pirTKUndefine, pirTKDummy, pirTKQuotation, pirTKContinue);
  TPIRTableKinds = set of TPIRTableKind;

  /// Тип цены указанной в таблице
  //   - pirTPKparamA  - параметр A (одна колонка)
  //   - pirTPKparamB  - параметр B (одна колонка)
  //   - pirTPKparamAB - параметры A и B (две колонки, если объединенная ячейка, то A)
  //   - pirTPKparamBA - параметры A и B (две колонки, если объединенная ячейка, то B)
  TPIRTablePriceKind = (pirTPKparamA, pirTPKparamB, pirTPKparamAB, pirTPKparamBA);
  TPIRTablePriceKinds = set of TPIRTablePriceKind;

  /// Масштаб цен указанных в таблице
  //   - pirTMPRouble   - цены в рублях
  //   - pirTMPThousand - цены в тысячах рублей
  //   - pirTMPMillion  - цены в миллионах рублей
  TPIRTableMeashureOfPrice = (pirTMPRouble, pirTMPThousand, pirTMPMillion);
  TPIRTableMeashureOfPrices = set of TPIRTableMeashureOfPrice;

  /// Строка для сортировки наименования/обозначения разблюдовки
  TPIRSortCaption = string[pirSortCaptionLength];

  ///Виды распределения стоимости для работы
  // - pirwdtPartitions: распределение по разделам документации
  // - pirwdtConstructions: распределение по сооружениям
  TPIRWorkDistributionType = (pirwdtPartitions, pirwdtConstructions);
  TPIRWorkDistributionTypes = set of TPIRWorkDistributionType;

  /// Виды работ
  //   - pirWorkUndefine: неопределено
  //   - pirWorkField: полевые работы
  //   - pirWorkCameral: камеральные работы
  //   - pirWorkLabor: лабораторные работы
  //   - pirWorkExploration: изыскательские работы
  TPIRWorkType = (pirWorkField, pirWorkCameral, pirWorkLabor, pirWorkExploration, pirWorkUndefine);
  TPIRWorkTypes = set of TPIRWorkType;

  // deprecated
  TPIRTableRange = record
  public
    Bottom, Left, Right, Top: Integer;
    /// Получить область из текста
    // Addr - строка вида "RnCm" или "CmRn" или "Rn" или "Cm"
    // где R - признак номера строки "R" или "r"
    //     C - признак номера колонки "C" или "c"
    //     n и m - номера строки и колонки соответственно
    constructor Create(const Addr: string); overload;
    /// Получчить область по координатам
    constructor Create(const aTop, aLeft: Integer; const aBottom: Integer=-1; const aRight: Integer=-1); overload;
    /// Область в виде ячейки
    constructor CreateCell(const aRow, aCol: Integer);
    /// Область в виде колонки
    constructor CreateCol(const aTop, aCol: Integer; const aBottom: Integer=-1);
    /// Область в виде строки
    constructor CreateRow(const aRow, aLeft: Integer; const aRight: Integer=-1);
    /// Пустой регион
    procedure Clear;
    /// Получить копию
    procedure CopyFrom(const aSrc: TPIRTableRange); inline;
    /// Область в виде ячейки
    function isCell: Boolean; inline;
    /// Область в виде колонки
    function isCol: Boolean; inline;
    /// Область в виде строки
    function isRow: Boolean; inline;
    /// Возвращает true, если заданы валидные границы области
    function isValid: Boolean;
    /// Возвращает true, если область не задана
    function Undefined: Boolean;
    /// JSON-строка
    function ToJSON: RawUTF8;
    /// JSON-документ
    function ToDoc: Variant;
  end;
  TPIRTableRanges = array of TPIRTableRange;

  /// Координаты ячейки таблицы
  TPIRTableCell = record
  public
    Row, Col: Integer;
    /// Получить координаты ячейки из строки с адресом
    // Addr - строка вида "RnCm" или "CmRn" или "Rn" или "Cm"
    // где R - признак номера строки "R" или "r"
    //     C - признак номера колонки "C" или "c"
    //     n и m - номера строки и колонки соответственно
    // Сформировать запись
    constructor Create(const Addr: string); overload;
    constructor Create(const aRow,aCol: Integer); overload;
    constructor Create(Doc: Variant); overload;
    constructor Create(PDoc: PDocVariantData); overload;
    ///
    constructor CreateUTF8(const Addr: RawUTF8);
    /// Очистить
    procedure Clear; inline;
    /// Возвращает true, если область является колонкой
    function isCol: Boolean;
    /// Возвращает true, если область является строкой
    function isRow: Boolean;
    /// Возвращает true, если область не задана
    function Undefined: Boolean; inline;
    /// Функция возвращает сроку с адресом ячейки в формате "RnCm"
    function ToAddr: string; inline;
    /// Функция возвращает сроку с адресом ячейки в формате "RnCm"
    function ToAddrUTF8: RawUTF8; inline;
    /// JSON-строка
    function ToJSON: RawUTF8; inline;
    /// JSON-документ
    function ToDoc: Variant; inline;
    /// Функция переводит строку в координаты
    // Addr - строка вида "RnCm" или "CmRn" или "Rn" или "Cm"
    // где R - признак номера строки "R" или "r"
    //     C - признак номера колонки "C" или "c"
    //     n и m - номера строки и колонки соответственно
    // в случае успеха номера строки и колонки возвращаются через vRow и vCol, если R или C отсутсувют
    // соответствующая переменная не изменяется
    class function AddrToRC(const Addr: string; var vRow: Integer; var vCol: Integer): Boolean; static;
  end;
  TPIRTableCells = array of TPIRTableCell;

  /// Элемент описания таблицы
  TPIRItemDescriptor = record
  private
    FCellTL, FCellBR: TPIRTableCell;
    FSource: string;
    FFont: string;
    FColor: TColor;
    FSrcType: TPIRTableSourceType;
    procedure SetCellTL(const Value: TPIRTableCell);
    procedure SetColor(const Value: TColor);
    procedure SetFont(const Value: string);
    procedure SetSource(const Value: string);
    procedure SetSrcType(const Value: TPIRTableSourceType);
    procedure SetCellBR(const Value: TPIRTableCell);
  public
    /// Источник информации о единице измерения
    property Source: string read FSource write SetSource;
    /// Стартовая ячейка (верхний левый угол)
    property CellTL: TPIRTableCell read FCellTL write SetCellTL;
    /// Последняя ячейка (нижний правый угол)
    property CellBR: TPIRTableCell read FCellBR write SetCellBR;
    /// Тип источника
    property SrcType: TPIRTableSourceType read FSrcType write SetSrcType;
    /// Цвет для выделения области, содержащей наименоване единицы измерения
    property Color: TColor read FColor write SetColor;
    /// Фонт для выделения области, содержащей наименоване единицы измерения
    property Font: string read FFont write SetFont;
    /// Конструктор формирует запись из JSON-документа
    constructor Create(Doc: Variant); overload;
    /// Конструктор формирует запись из JSON-документа
    constructor Create(PDoc: PDocVariantData); overload;
    /// Конструктор формирует запись извлекая информацию и строки
    constructor Create(const aSrcType: TPIRTableSourceType; const aSource: string); overload;
    /// Конструктор объявляет область ниже и правее заданной ячейки
    constructor Create(const aCellTL: TPIRTableCell); overload;
    /// Конструктор объявляет область-колонку
    constructor CreateCol(const Col: Integer);
    /// Конструктор объявляет текстовую константу
    constructor CreateConst(const Text: string);
    /// Конструктор объявляет область заданную двумя ячейками
    constructor CreateFrame(const aCellTL, aCellBR: TPIRTableCell);
    /// Конструктор объявляет область-строку
    constructor CreateRow(const Row: Integer);
    /// Функция возвращет true, если указанная ячейка входит в элемент
    function InvolveCell(const aRow, aCol: Integer): Boolean;
    /// Процедура очищает информацию
    procedure Clear;
    /// Функция возвращает количество колонок в элементе
    function Cols: Integer;
    /// Функция возвращает количество строк в элементе
    function Rows: Integer;
    /// Функция возвращает JSON-строку
    function ToJSON: RawUTF8;
    /// Функция возвращает JSON-документ
    function ToDoc: Variant;
  end;
  TPIRItemDescriptors = array of TPIRItemDescriptor;

  /// Описатель параметра расценки для импорта
  TPIRTableParameterDescriptor = record
  private
    FApprox: Word;
    FRC_Value: TPIRItemDescriptor;
    FisVolume: Boolean;
    FKind: TPIRQuotationParameterKind;
    FAlias: string;
    FRC_Unit: TPIRItemDescriptor;
    FTextOptions: TPIRQuotationParameterTextOptions;
    FRC_Name: TPIRItemDescriptor;
    function GetText: string;
    function GetX1: string;
    function GetX2: string;
    procedure SetAlias(const Value: string);
    procedure SetApprox(const Value: Word);
    procedure SetisVolume(const Value: Boolean);
    procedure SetRC_Name(const Value: TPIRItemDescriptor);
    procedure SetRC_Unit(const Value: TPIRItemDescriptor);
    procedure SetRC_Value(const Value: TPIRItemDescriptor);
    procedure SetTextOptions(const Value: TPIRQuotationParameterTextOptions);
  public
    /// Описание источника наименований параметра
    property RC_Name: TPIRItemDescriptor read FRC_Name write SetRC_Name;
    /// Описание источника единицы измерения параметра
    property RC_Unit: TPIRItemDescriptor read FRC_Unit write SetRC_Unit;
    /// Описание источника значений параметра
    property RC_Value: TPIRItemDescriptor read FRC_Value write SetRC_Value;
    /// Тип параметра
    property Kind: TPIRQuotationParameterKind read FKind;// write SetKind;
    /// Признак объёмного параметра (параметра, содержащего минимальное и максимальное значения объёма работ).
    // Признак может быть установлен только для параметров типа "S" или "P"
    // Только один параметр может быть объёмным у расценки
    property isVolume: Boolean read FisVolume write SetisVolume;
    /// Тип аппроксимации цены расценки. Устанавливается только для объёмных параметров
    // 0 - аппроксимация не используется
    // 1 - экстраполяция
    property Approx: Word read FApprox write SetApprox;
    /// Алиас параметра
    property Alias: string read FAlias write SetAlias;
    /// Первое значение параметра
    // Для раценок типа "S" и "P" используется как значение по умолчанию на границе диапазона значение (min или max)
    // Для расценок типа "E" используется для выбора расценки из группы по списку значений параметра
    // Для расценок типа "L" содержит список значений используемых при расчётах стоимости
    property X1: string read GetX1;
    /// Второе значение параметра
    // Для раценок типа "S" и "P" содержит значение второй границы диапазона
    // Для расценок типа "E" должно быть пусто
    // Для расценок типа "L" содержит список описаний значений используемых при расчётах стоимости (из X1)
    property X2: string read GetX2;
    /// Текст с описанием параметра для использования при формировании расценки
    property Text: string read GetText;
    /// Опции формирования текста
    property TextOptions: TPIRQuotationParameterTextOptions read FTextOptions write SetTextOptions;
    /// Конструктор
    constructor Create(Doc: Variant; const TxtOpt:TPIRQuotationParameterTextOptions=[]); overload;
    constructor Create(PDoc: PDocVariantData; const TxtOpt:TPIRQuotationParameterTextOptions=[]); overload;
    /// Конструтор формирует запись с информацией о параметре
    constructor Create(const aKind: TPIRQuotationParameterKind; const aAlias, aName, aUnitName, aValue: string;
                       const aisVolume: Boolean = False; const aApprox: Integer = pirQuotationParamAproxNone;
                       const TxtOpt:TPIRQuotationParameterTextOptions=[]); overload;
    /// Конструтор формирует запись для параметра тип "E"
    constructor CreateEnum(const aAlias, aName, aValue: string; const aUnitName: string='';
                           const TxtOpt:TPIRQuotationParameterTextOptions=[]);
    /// Конструтор формирует запись для параметра тип "L"
    constructor CreateList(const aAlias, aName, aValues, aDescrs: string; const aUnitName: string='';
                           const TxtOpt:TPIRQuotationParameterTextOptions=[]);
    /// Конструтор формирует запись для объёмного параметра по умолчанию ( от 1 )
    constructor CreateVolumeDef(const aAlias, aName, aUnitName, aValue: string;
                                const TxtOpt:TPIRQuotationParameterTextOptions=[]);
    /// Конструтор формирует запись параметра типа "S"
    constructor CreateSpan(const aAlias, aName, aUnitName, aValue: string;
                           const aisVolume: Boolean = False; const aApprox: Integer = pirQuotationParamAproxNone;
                           const TxtOpt:TPIRQuotationParameterTextOptions=[]);
    /// Конструтор формирует запись параметра типа "P"
    constructor CreateBand(const aAlias, aName, aUnitName, aValue: string;
                           const TxtOpt:TPIRQuotationParameterTextOptions=[]);
    /// Конструтор формирует запись из JSON-строки для изыскательских работ
    constructor CreateSurvey(const SurveyType:TPIRSurveyWorkType;
                             const aAlias:string='Z'; const aName: string=pirSurveyWorkTypeParamName;
                             const TxtOpt:TPIRQuotationParameterTextOptions=[]);
    /// Процедура очищает информацию
    procedure Clear;
    /// Функция возвращает JSON-строку
    function ToJSON: RawUTF8;
    /// Функция возвращает JSON-документ
    function ToDoc: Variant;
  end;

  /// Описатель таблицы для импорта
  TPIRTableDescriptor = record
  private
    FName: string;
    FRC_Parameters: TPIRItemDescriptors;
    FRowID: Boolean;
    FID: string;
    FRC_Data: TPIRItemDescriptor;
    FKind: TPIRTableKind;
    FRC_Unit: TPIRItemDescriptor;
    FRC_Name: TPIRItemDescriptor;
    FMeashureOfPrice: TPIRTableMeashureOfPrice;
    FPriceKind: TPIRTablePriceKind;
    FRowCount: Integer;
    FColCount: Integer;
    FTabNameToRow: Boolean;
    FRC_Prefix: TPIRItemDescriptor;
    FRC_Suffix: TPIRItemDescriptor;
    FHaveDefaultVolumeParameter: Boolean;
    function GetRC_Parameter(Index: integer): TPIRItemDescriptor;
    procedure SetID(const Value: string);
    procedure SetKind(const Value: TPIRTableKind);
    procedure SetName(const Value: string);
    procedure SetRC_Data(const Value: TPIRItemDescriptor);
    procedure SetRC_Name(const Value: TPIRItemDescriptor);
    procedure SetRC_Unit(const Value: TPIRItemDescriptor);
    procedure SetRowID(const Value: Boolean);
    procedure SetMeashureOfPrice(const Value: TPIRTableMeashureOfPrice);
    procedure SetPriceKind(const Value: TPIRTablePriceKind);
    procedure SetColCount(const Value: Integer);
    procedure SetRowCount(const Value: Integer);
    procedure SetTabNameToRow(const Value: Boolean);
    procedure SetRC_Prefix(const Value: TPIRItemDescriptor);
    procedure SetRC_Suffix(const Value: TPIRItemDescriptor);
    procedure SetHaveDefaultVolumeParameter(const Value: Boolean);
  public
    /// Идентификатор (номер) таблицы
    property ID: string read FID write SetID;
    /// Наименование таблицы
    property Name: string read FName write SetName;
    /// Включать наименование таблицы в наименование строки
    property TabNameToRow: Boolean read FTabNameToRow write SetTabNameToRow;
    /// Признак наличия идентификатора строки в левой колонке
    property RowID: Boolean read FRowID write SetRowID;
    /// Признак наличия объёмного параметра по умолчанию
    property HaveDefaultVolumeParameter: Boolean read FHaveDefaultVolumeParameter write SetHaveDefaultVolumeParameter;
    /// Вид таблицы
    property Kind: TPIRTableKind read FKind write SetKind;
    /// Тип параметра цены
    property PriceKind: TPIRTablePriceKind read FPriceKind write SetPriceKind;
    /// Масштаб цен
    property MeashureOfPrice: TPIRTableMeashureOfPrice read FMeashureOfPrice write SetMeashureOfPrice;
    /// Количество обрабатываемых колонок
    property ColCount: Integer read FColCount write SetColCount;
    /// Количество обрабатываемых строк
    property RowCount: Integer read FRowCount write SetRowCount;
    /// Описание фрейма с параметрами цен расценок
    property RC_Data: TPIRItemDescriptor read FRC_Data write SetRC_Data;
    /// Описание источника префикса для наименований расценок
    property RC_Prefix: TPIRItemDescriptor read FRC_Prefix write SetRC_Prefix;
    /// Описание источника наименований расценок
    property RC_Name: TPIRItemDescriptor read FRC_Name write SetRC_Name;
    /// Описание источника суффикса для наименований расценок
    property RC_Suffix: TPIRItemDescriptor read FRC_Suffix write SetRC_Suffix;
    /// Описание источника единицы измерения расценок
    property RC_Unit: TPIRItemDescriptor read FRC_Unit write SetRC_Unit;
    /// Параметры
    property RC_Parameter[Index: integer]: TPIRItemDescriptor read GetRC_Parameter;
    /// Массив параметров
    property RC_Parameters: TPIRItemDescriptors read FRC_Parameters;
    /// Конструктор
    constructor Create(Doc: Variant); overload;
    /// Конструктор
    constructor Create(PDoc: PDocVariantData); overload;
    /// Функция возвращает символ представляющий тип таблицы
    class function pirTableKindToChar(const tk:TPIRTableKind): Char; static;
    /// Функция возвращает строку представляющую тип таблицы
    class function pirTableKindToString(const tk:TPIRTableKind): string; static;
    /// Функция определяет высоту шапки таблицы
    class function HeadEvaluation(PDoc: PDocVariantData): Integer; static;
    /// Функция добавляет параметр
    function AddParam(Param: TPIRItemDescriptor): Integer;
    /// Функция возвращает параметры оформления ячейки
    function CellProps(const aRow, aCol: Integer; out oColor: TColor; out oFont: string): Boolean;
    /// Очистить информацию
    procedure Clear;
    /// Очистить информацию о параметрах
    procedure ClearParameters;
    /// Функция возвращает количество параметров
    function ParamCount: Integer;
    /// Функция возвращает JSON-строку
    function ToJSON: RawUTF8;
    /// Функция возвращает JSON-документ
    function ToDoc: Variant;
  end;
  TPIRTableDescriptors = array of TPIRTableDescriptor;

  /// Область просмотра базы для расценок
  //   - pircsAll: все расценки
  //   - pircsShifr: все расценки с заданым шифром нормативной базы документов
  //   - pircsDoc: все расценки документа
  //   - pircsTab: все расценки таблицы
  //   - pircsGroup: все расценки таблицы с заданной группой
  //   - pircsRow: все расценки из строки таблицы
  //   - pircsCol: все расценки из колонки таблицы
  TPIRCypherScope = (pircsAll, pircsShifr, pircsDoc, pircsTab, pircsGroup, pircsRow, pircsCol);
  TPIRCypherScopes = set of TPIRCypherScope;

  /// Флаг, определяющий способ сравнения поля Caption
  // pircfExactly - точное сравнение
  TPIRCompareCaptionFlag = (pircfExactly);

  /// Информация о документе ПИР
  TPIRDocInfo = record
  public
    /// Наименование документа
    Name: string;
    /// Код нормативной базы
    Base: string;
    /// Шифр документа
    Cypher: string;
    /// Год выпуска
    Year: Word;
  end;

  /// разблюдовка
  TPIRDistribution = record
  private
    FCode: string;
    FID: Cardinal;
    FDistrType: TPIRWorkDistributionType;
    FCaption: string;
    FSrc: string;
    FCollapse: Cardinal;
    procedure SetCaption(const Value: string);
    procedure SetCode(const Value: string);
    procedure SetCollapse(const Value: Cardinal);
    procedure SetDistrType(const Value: TPIRWorkDistributionType);
    procedure SetID(const Value: Cardinal);
    procedure SetSrc(const Value: string);
  public
    /// Наименование/описание разблюдовки
    property Caption: string read FCaption write SetCaption;
    /// Код (Аббревиатура) разблюдовки
    property Code: string read FCode write SetCode;
    /// Идентификатор разблюдовки, которая должна заменить эту разблюдовку
    property Collapse: Cardinal read FCollapse write SetCollapse;
    /// Вид разблюдовки
    property DistrType: TPIRWorkDistributionType read FDistrType write SetDistrType;
    /// Идентификатор разблюдовки
    property ID: Cardinal read FID write SetID;
    /// Обозначение разблюдовки в исходном документе
    property Src: string read FSrc write SetSrc;
    /// Конструктор
    constructor Create(const aCode, aCaption: string);
    /// Получить тип разблюдовки из символа
    class function DistrTypeFromChar(const aDistrType: Char): TPIRWorkDistributionType; static;
    /// Получить символ типа разблюдовки
    class function DistrTypeToChar(const aDistrType: TPIRWorkDistributionType): Char; static;
    /// Функция возвращает строку обозначающую тип разблюдовки
    class function DistrTypeToStr(const aDistrType: TPIRWorkDistributionType): String; static;
    ///Строка используемая для сортировки/поиска
    function SortCap: TPIRSortCaption; overload;
    /// Получить строку для сортировки наименования/обозначения разблюдовки
    class function SortCap(const aCaption: string): TPIRSortCaption; overload; static;
  end;
  /// Указатель на позицию распределения стоимости расценки
  PPIRDistribution = ^TPIRDistribution;
  /// Массив позиций распределения стоимости расценки
  TPIRDistributions = array of TPIRDistribution;
  /// Указатель на массив позиций распределения стоимости расценки
  PPIRDistributions = ^TPIRDistributions;
{
  ///Информация о документе ПИР
  // Идентификатор документа имеет вид
  // ! SHIFR [-] CODE
  // ! где
  // ! SHIFR == шифр базы данных документов - последовательность буковок (МРР, СБЦП, И др)
  // ! CODE  == код документа, содержащий в общем случае:
  // ! BASE: базовый код документа
  // ! REL: номер редакции документа
  // ! DOP: номер дополнения
  // ! YEAR: год выпуска
  TPIRDocInfo = packed record
  private
      FCode: string;
      FDocID: string;
      FDop: string;
      FFileName: string;
      FFilePath: string;
      FShifr: string;
      FTitle: string;
      FYear: string;
      FOldTableNum: boolean;
    class var FMaxHeadNumber: Integer;
    procedure ParseDocID(const ADocID: string);
    function GetCodeDop: string;
    function GetCodeFull: string;
    procedure SetDocID(const Value: string);
    procedure SetDop(const Value: string);
    function GetEmpty: Boolean; inline;
    procedure SetEmpty(const Value: Boolean); inline;
    procedure SetFileName(const Value: string);
    procedure SetOldTableNum(const Value: boolean);
  public
    /// Максимальный номер главы
    class property MaxHeadNumber: Integer read FMaxHeadNumber write FMaxHeadNumber;
    /// Код документа: последовательность цифр разделённая спец.символами, имеющая внутреннюю структуру,
    //  зависящую от нормативной базы
    property Code: string read FCode write FCode;
    /// Код с дополнением                                                deprecated
    property CodeDop: string read GetCodeDop;
    /// Полный код документа                                             deprecated
    property CodeFull: string read GetCodeFull;
    /// Идентификатор документа (имя файла содержащего документ)
    property DocID: string read FDocID write SetDocID;
    /// Номер дополнения
    property Dop: string read FDop write SetDop;
    /// Признак отсутствия информации
    property Empty: Boolean read GetEmpty write SetEmpty;
    /// Имя файла, содержащего документ, может содержать шифр и наименование документа
    property FileName: string read FFileName write SetFileName;
    ///Старые обозначения таблиц: "Раздел"-"номер"
    property OldTableNum: boolean read FOldTableNum write SetOldTableNum;
    /// Буквенный шифр нормативной базы документов ПИР ("МРР", "СБЦП" и др)
    property Shifr: string read FShifr write FShifr;
    /// Название документа ПИР
    property Title: string read FTitle write FTitle;
    /// Год выпуска документа ПИР
    property Year: string read FYear write FYear;
    // Конструтор
    constructor Create(aDocID: string; aOldTableNum: boolean = false);
    function ChangeFileName(const aFileName: string): Boolean;
    ///Проверить наличие допустимого разрешения в имени файла
    class function CheckExtension(const Str: string): Boolean; static;
    ///Очистить запись
    procedure Clear;
    ///Разбирает строку на части: шифр, код и название справочника. Возвращает true, если есть шифр
    class function GetCode(const Str: string; var vShifr, vCode, vTitle: string): Boolean; static;
    class function GetCodeEx(const Str: string; var vShifr, vCode, vTitle: string): Boolean; static;
    //Извлекает из строки шифр документа
    function GetShifr(var Str: string): string;
    /// Задать значения
    procedure Init(aDocID: string; aOldTableNum: boolean = false);
    class function New(aDocID: string; aOldTableNum: boolean = false): TPIRDocInfo; static; inline;
    /// Разбор шифра МРР
    class function ParseMRRCode(const aCode: string; out oCode, oDop, oYear: string): Boolean; static;
    /// Разобрать полный код документа на составные части
    class function ParseNewMRRCode(const aCode: string; out oCode, oDop, oYear: string): Boolean; static;
  end;

  /// Запись с информацией о наборе разблюдовок
  TPIRDistrSet = packed record
  private
    FBand: string;
    FCaption: string;
    FDistr_Type: string;
    FDiapason: string;
    FDocInfo: TPIRDocInfo;
    FFail: string;
    FID: Integer;
    FNpp: Integer;
    FNpsb: Integer;
    FColExpander: Integer;
    FOldTableID: Boolean;
    class function MakeCols(Tabs, Rows: TStringDynArray; const Str: string; var Cyps: string; const Prefix: string = ''): Boolean; static;
    class function MakeRows(Tabs: TStringDynArray; const Str: string; var Cyps: string; const Prefix: string = ''):  Boolean; static;
    class function MakeTabs(const Str: string; var Cyps: string; const Prefix: string = ''; const OldTableIDFlag: Boolean = false): Boolean; static;
    procedure SetBand(const Value: string);
    function GetCode: string;
    procedure SetColExpander(const Value: Integer);
    procedure SetDiapason(const Value: string);
    function GetEmpty: Boolean;
    procedure SetEmpty(const Value: Boolean);
    procedure SetOldTableID(const Value: Boolean);
  public
    class function AppendRowsMasks(const Rows: TStringDynArray): TStringDynArray; static;
    class function CheckDiapasonStr(const ADiapason: string; out ODiapason: string): Boolean; static;
    class function ColExpanderFromStr(const Str: string): Integer; static; inline;
    class function GenItems(const AText: string; const Expanded: Boolean = false): TStringDynArray; static;
    procedure Init(const ADocInfo: TPIRDocInfo; const ACaption, ADiapason: string; const ANpp: Integer = 0; const
        ANpsb: Integer = 0; const ADistrType: string = 'Р'; const AColExpander: Integer = 0);
    class function isAllTables(const Str: string): Boolean; static;
    /// Производит бандизацию списка расценок
    class function MakeBand(const ADiapason: string; out ABand: string; const ColExp: Integer = 0): Integer; overload;
        static; deprecated;
    class function MakeBandString(const ADiapason: string; out OBand: string; const OldTableIDFlag: Boolean = false):
        Boolean; static;
    class function New(const ADocInfo: TPIRDocInfo; const ACaption, ADiapason: string; const ANpp: Integer = 0; const
        ANpsb: Integer = 0; const ADistrType: string = 'Р'; const AColExpander: Integer = 0): TPIRDistrSet; overload;
        static; deprecated;
    class function New(const ADocInfo: TPIRDocInfo; const ACaption, ADiapason: string; const ANpp: Integer = 0; const
        ANpsb: string = ''; const ADistrType: string = 'Р'; const AColExpander: Integer = 0): TPIRDistrSet; overload;
        static;
    /// Список таблиц
    property Band: string read FBand write SetBand;
    /// Наименование
    property Caption: string read FCaption write FCaption;
    /// Код сборника
    property Code: string read GetCode;
    /// Дополнение к номеру колонки для размноженных расценок
    property ColExpander: Integer read FColExpander write SetColExpander;
    /// Таблицы (диапазон применения) (из Эксел)
    property Diapason: string read FDiapason write SetDiapason;
    /// Тип разблюдовки (по "Р" - разделам или "С" - сооружениям) Перекинули на МРР / СБЦ
    property Distr_Type: string read FDistr_Type write FDistr_Type;
    /// Сборник
    property DocInfo: TPIRDocInfo read FDocInfo;
    /// Проверить наличие информации
    property Empty: Boolean read GetEmpty write SetEmpty;
    /// Ошибки обработки диапазона
    property Fail: string read FFail write FFail;
    /// Идентификатор набора
    property ID: Integer read FID write FID;
    /// Номер по порядку (из Эксел)
    property Npp: Integer read FNpp write FNpp;
    /// Номер по сборнику (из Эксел)
    property Npsb: Integer read FNpsb write FNpsb;
    property OldTableID: Boolean read FOldTableID write SetOldTableID;
  end;

///сравнить две строки
function isEqualCaptionStr(Str1, Str2: string; Flag: TPIRCompareCaptionFlag = pircfExactly): boolean;
}


type
  /// Запись, содержащая описание параметра расценки
  // Поля наименование(Name), единица измерения(UnitName) и значение(Value) могут содержать ссылки на ячейки таблицы вида:
  //  $RnCm$, где
  //  n и m - числа
  //  R - признак строки
  //  С - признак колонки
  // если заданы строка и колонка, то значение выбирается из ячейки один раз,
  // если же задана либо строка, либо колонка, то ссылка на ячейку формируется динамически
  // команды выделяются символом "@"
  // для наименования и единицы измерения
  // U - единица измерения находится в конце текста и отделена запятой (что-то такое, тыс.м2), может завершатся двоеточием
  //
  TPIRQuotationParameter = record
  private
    FUnitName: string;
    FName: string;
    FApprox: Word;
    FisVolume: Boolean;
    FKind: TPIRQuotationParameterKind;
    FAlias: string;
    FTextOptions: TPIRQuotationParameterTextOptions;
    FValue: string;
    FX1,FX2: string;
    FCurrCol: Integer;
    FCurrRow: Integer;
    function GetX1: string;
    function GetX2: string;
    procedure SetAlias(const Value: string);
    procedure SetApprox(const Value: Word);
    procedure SetisVolume(const Value: Boolean);
//    procedure SetKind(const Value: TPIRQuotationParameterKind);
    procedure SetName(const Value: string);
    procedure SetTextOptions(const Value: TPIRQuotationParameterTextOptions);
    procedure SetUnitName(const Value: string);
    procedure SetValue(const Value: string);
    function GetText: string;
    procedure SetCurrCol(const Value: Integer);
    procedure SetCurrRow(const Value: Integer);
  public
    /// Тип параметра
    property Kind: TPIRQuotationParameterKind read FKind;// write SetKind;
    /// Признак объёмного параметра (параметра, содержащего минимальное и максимальное значения объёма работ).
    // Признак может быть установлен только для параметров типа "S" или "P"
    // Только один параметр может быть объёмным у расценки
    property isVolume: Boolean read FisVolume write SetisVolume;
    /// Тип аппроксимации цены расценки. Устанавливается только для объёмных параметров
    // 0 - аппроксимация не используется
    // 1 - экстраполяция
    property Approx: Word read FApprox write SetApprox;
    /// Алиас параметра
    property Alias: string read FAlias write SetAlias;
    /// Наименование параметра
    property Name: string read FName write SetName;
    /// Название единицы измерения величины параметра ( для "E" может отсутствовать)
    property UnitName: string read FUnitName write SetUnitName;
    /// Первое значение параметра
    // Для раценок типа "S" и "P" используется как значение по умолчанию на границе диапазона значение (min или max)
    // Для расценок типа "E" используется для выбора расценки из группы по списку значений параметра
    // Для расценок типа "L" содержит список значений используемых при расчётах стоимости
    property X1: string read GetX1;
    /// Второе значение параметра
    // Для раценок типа "S" и "P" содержит значение второй границы диапазона
    // Для расценок типа "E" должно быть пусто
    // Для расценок типа "L" содержит список описаний значений используемых при расчётах стоимости (из X1)
    property X2: string read GetX2;
    /// Значение параметра полученное из исходника
    property Value: string read FValue write SetValue;
    /// Текст с описанием параметра для использования при формировании расценки
    property Text: string read GetText;
    /// Текущая колонка таблицы расценок
    property CurrCol: Integer read FCurrCol write SetCurrCol;
    /// Текущая строка таблицы расценок
    property CurrRow: Integer read FCurrRow write SetCurrRow;
    /// Опции формирования текста
    property TextOptions: TPIRQuotationParameterTextOptions read FTextOptions write SetTextOptions;
    /// Конструтор формирует запись из JSON-строки
    constructor Create(const JSON: RawJSON; const TxtOpt:TPIRQuotationParameterTextOptions=[]); overload;
    /// Конструтор формирует запись из JSON-документа
    constructor Create(Doc: Variant; const TxtOpt:TPIRQuotationParameterTextOptions=[]); overload;
    /// Конструтор формирует запись из JSON-документа
    constructor Create(const PDoc: PDocVariantData; const TxtOpt:TPIRQuotationParameterTextOptions=[]); overload;
    /// Конструтор формирует запись с информацией о параметре
    constructor Create(const aKind: TPIRQuotationParameterKind; const aAlias, aName, aUnitName, aValue: string;
                       const aisVolume: Boolean = False; const aApprox: Integer = pirQuotationParamAproxNone;
                       const TxtOpt:TPIRQuotationParameterTextOptions=[]); overload;
    /// Конструтор формирует запись для параметра тип "E"
    constructor CreateEnum(const aAlias, aName, aValue: string; const aUnitName: string='';
                           const TxtOpt:TPIRQuotationParameterTextOptions=[]);
    /// Конструтор формирует запись для параметра тип "L"
    constructor CreateList(const aAlias, aName, aValues, aDescrs: string; const aUnitName: string='';
                           const TxtOpt:TPIRQuotationParameterTextOptions=[]);
    /// Конструтор формирует запись для объёмного параметра по умолчанию ( от 1 )
    constructor CreateVolumeDef(const aAlias, aName, aUnitName, aValue: string;
                                const TxtOpt:TPIRQuotationParameterTextOptions=[]);
    /// Конструтор формирует запись параметра типа "S"
    constructor CreateSpan(const aAlias, aName, aUnitName, aValue: string;
                           const aisVolume: Boolean = False; const aApprox: Integer = pirQuotationParamAproxNone;
                           const TxtOpt:TPIRQuotationParameterTextOptions=[]);
    /// Конструтор формирует запись параметра типа "P"
    constructor CreateBand(const aAlias, aName, aUnitName, aValue: string;
                           const TxtOpt:TPIRQuotationParameterTextOptions=[]);
    /// Конструтор формирует запись из JSON-строки для изыскательских работ
    constructor CreateSurvey(const SurveyType:TPIRSurveyWorkType;
                             const aAlias:string='Z'; const aName: string=pirSurveyWorkTypeParamName;
                             const TxtOpt:TPIRQuotationParameterTextOptions=[]);
    /// Функция выбирает информацию о параметре из таблицы
    // PDoc - указатель на JSON, являющейся таблицей
    // Row и Col указывают на ячейку из которой выбирается стоимость расценки, допустимо значение Row или Col
    // устанавливать в -1, если это значение не существенно для формирования параметра  
    function FromTable(PDoc: PDocVariantData; const Row, Col: Integer): Boolean;
    /// Функция возвращает JSON-документ с информацией о параметре
    function ToDoc: Variant;
    /// Функция возвращает JSON-строку с информацией о параметре
    function ToJSON: RawJSON; inline;
  end;
  /// Массив параметров
  TPIRQuotationParameters = array of TPIRQuotationParameter;

  TPIRPriceParam = packed record
  private
    FCoefB: Currency;
    FScale: Currency;
    FProps: string;
    procedure SetCoefB(const Value: Currency);
    procedure SetProps(const Value: string);
    procedure SetScale(const Value: Currency);
  public
    property CoefB: Currency read FCoefB write SetCoefB;
    property Scale: Currency read FScale write SetScale;
    property Props: string read FProps write SetProps;
    function ToDoc: Variant;
    function ToJSON: RawUTF8;
  end;

  /// Расценка ПИР
  TPIRQuotation = record
  private
    FParamCount: Integer;
    FUnitName: string;
    FName: string;
    FParams: TPIRQuotationParameters;
    FApproveDoc: Integer;
    FFormatCyp: string;
    FID: Integer;
    FPriceParam: TPIRPriceParam;
    FRepealDoc: Integer;
    FSurveyWorkType: TPIRSurveyWorkType;
    FprB: Extended;
    FCypher: string;
    FprA: Extended;
    FGroup: Integer;
    function GetParam(Index: Integer): TPIRQuotationParameter;
    procedure SetApproveDoc(const Value: Integer);
    procedure SetCypher(const Value: string);
    procedure SetFormatCyp(const Value: string);
    procedure SetGroup(const Value: Integer);
    procedure SetID(const Value: Integer);
    procedure SetName(const Value: string);
    procedure SetParam(Index: Integer; const Value: TPIRQuotationParameter);
    procedure SetParams(const Value: TPIRQuotationParameters);
    procedure SetprA(const Value: Extended);
    procedure SetprB(const Value: Extended);
    procedure SetPriceParam(const Value: TPIRPriceParam);
    procedure SetRepealDoc(const Value: Integer);
    procedure SetSurveyWorkType(const Value: TPIRSurveyWorkType);
    procedure SetUnitName(const Value: string);
  public
    /// Шифр
    property Cypher: string read FCypher write SetCypher;
    /// Числовой идентификатор
    property ID: Integer read FID write SetID;
    /// Наименование
    property Name: string read FName write SetName;
    /// Единица измерения
    property UnitName: string read FUnitName write SetUnitName;
    /// Параметр A цены
    property prA: Extended read FprA write SetprA;
    /// Параметр B цены
    property prB: Extended read FprB write SetprB;
    /// Номер группы
    property Group: Integer read FGroup write SetGroup;
    /// Коэффициенты цены
    property PriceParam: TPIRPriceParam read FPriceParam write SetPriceParam;
    /// Идентификатор утверждающего документа
    property ApproveDoc: Integer read FApproveDoc write SetApproveDoc;
    /// Идентификатор отменяющего документа
    property RepealDoc: Integer read FRepealDoc write SetRepealDoc;
    /// Количество параметров расценки
    property ParamCount: Integer read FParamCount;
    /// Параметры расценки
    property Param[Index: Integer]: TPIRQuotationParameter read GetParam write SetParam;
    /// Массив с параметрами расценки
    property Params: TPIRQuotationParameters read FParams write SetParams;
    /// Тип изыскательских работ
    property SurveyWorkType: TPIRSurveyWorkType read FSurveyWorkType write SetSurveyWorkType;
    ///
    property FormatCyp: string read FFormatCyp write SetFormatCyp;
    /// Функция добавляет параметр к расценке
    function AddParam(aParam: TPIRQuotationParameter): Integer;
    /// Функция возвращает JSON-документ с информацией о расценке
    function ToDoc: Variant;
    /// Функция возвращает JSON-строку с информацией о расценке
    function ToJSON: RawUTF8;
  end;

  /// Отметка пользователя
  TPIRUserMark = packed record
  private
    FUser: RawUTF8;
    FComment: RawUTF8;
    FKey: RawByteString;
    FMarkTime: TTimeLog;
    procedure SetComment(const Value: RawUTF8);
    procedure SetKey(const Value: RawByteString);
    procedure SetMarkTime(const Value: TTimeLog);
    procedure SetUser(const Value: RawUTF8);
  public
    property Comment: RawUTF8 read FComment write SetComment;
    property User: RawUTF8 read FUser write SetUser;
    property MarkTime: TTimeLog read FMarkTime write SetMarkTime;
    property Key: RawByteString read FKey write SetKey;
    constructor Create(Data: Variant; const aComment: string='');
    function ToDoc: Variant;
    function ToJSON: RawUTF8; inline;
  end;

function SurveyTypeName(ST:TPIRSurveyWorkType): string; inline;

implementation

function SurveyTypeName(ST:TPIRSurveyWorkType): string;
begin
  case ST of
    pirSWTField: Result:='Полевые работы';
    pirSWTDesc:  Result:='Камеральные работы';
    pirSWTLab:   Result:='Лабораторные работы';
    pirSWTFree:  Result:='Изыскательские работы';
  end;
end;

{ TPIRTableRegion }

procedure TPIRTableRange.Clear;
begin
  Top:=-1; Left:=-1; Bottom:=-1; Right:=-1;
end;

procedure TPIRTableRange.CopyFrom(const aSrc: TPIRTableRange);
begin
  Top:=aSrc.Top; Left:=aSrc.Left; Bottom:=aSrc.Bottom; Right:=aSrc.Right;
end;

constructor TPIRTableRange.Create(const aTop, aLeft, aBottom, aRight: Integer);
begin
  Top:=aTop; Left:=aLeft; Bottom:=aBottom; Right:=aRight;
end;

constructor TPIRTableRange.CreateRow(const aRow, aLeft, aRight: Integer);
begin
  Top:=aRow; Left:=aLeft; Bottom:=aRow; Right:=aRight;
end;

constructor TPIRTableRange.Create(const Addr: string);
var s,mk: string; i: Integer; R,C: Cardinal; ds: TDBDString; ch: Char;
begin
  Clear; R:=0; C:=0;
  if (Addr[1]='R') or (Addr[1]='r') then begin
    i:=2;
    if not DBDReadNumber(Addr,i,R) then Exit;
    if i>Length(Addr) then CreateRow(R,0,-1)
    else if (Addr[i]='C') or (Addr[i]='c') then begin
      Inc(i);
      if not DBDReadNumber(Addr,i,C) then CreateCell(R,C);
    end;
  end else if (Addr[1]='C') or (Addr[1]='c') then begin
    i:=2;
    if not DBDReadNumber(Addr,i,C) then Exit;
    if i>Length(Addr) then CreateCol(C,0,-1)
    else if (Addr[i]='R') or (Addr[i]='r') then begin
      Inc(i);
      if DBDReadNumber(Addr,i,C) then CreateCell(R,C);
    end;
  end;
end;

constructor TPIRTableRange.CreateCell(const aRow, aCol: Integer);
begin
  Top:=aRow; Left:=aCol; Bottom:=aRow; Right:=aCol;
end;

constructor TPIRTableRange.CreateCol(const aTop, aCol, aBottom: Integer);
begin
  Top:=aTop; Left:=aCol; Bottom:=aBottom; Right:=aCol;
end;

function TPIRTableRange.isCell: Boolean;
begin
  Result:=(Left>=0) and (Top>=0) and (Left=Right) and (Top=Bottom);
end;

function TPIRTableRange.isCol: Boolean;
begin
  Result:=(Left>=0) and (Left=Right);
end;

function TPIRTableRange.isRow: Boolean;
begin
  Result:=(Top>=0) and (Top=Bottom);
end;

function TPIRTableRange.isValid: Boolean;
begin
  if (Bottom>0) then Result := (Top<=Bottom)
  else if (Right>0) then Result := (Left<=Right)
  else begin
    Result := isRow
  end;


end;

function TPIRTableRange.ToDoc: Variant;
begin

end;

function TPIRTableRange.ToJSON: RawUTF8;
begin
  if      isCell then Result := '{' + '"row":' + Int32ToUtf8(Top) + ', "col":' + Int32ToUtf8(Left) + '}'
  else if isRow  then Result := '{' + '"row":' + Int32ToUtf8(Top) + ', "lft":' + Int32ToUtf8(Left)
                              + ', "rgt":' + Int32ToUtf8(Right) +'}'
  else if isCol  then Result := '{' + '"col":' + Int32ToUtf8(Left) + ', "top":' + Int32ToUtf8(Top)
                              + ', "bot":' + Int32ToUtf8(Bottom) +'}'
                 else Result := '{' + '"top":' + Int32ToUtf8(Top) + ', "lft":' + Int32ToUtf8(Left)
                              + ', "bot":' + Int32ToUtf8(Bottom) + ', "rgt":' + Int32ToUtf8(Left) +'}';
end;

function TPIRTableRange.Undefined: Boolean;
begin
  Result := (Top+Left+Bottom+Right)<=-4;
end;

{ TPIRDistribution }

constructor TPIRDistribution.Create(const aCode, aCaption: string);
begin
  SetCode(aCode); SetCaption(aCaption);
end;

class function TPIRDistribution.DistrTypeFromChar(const aDistrType: Char): TPIRWorkDistributionType;
begin
  if      aDistrType='Р' then Result:=pirwdtPartitions
  else if aDistrType='С' then Result:=pirwdtConstructions
  else raise EConvertError.Create('Неверный символ типа разблюдовки');
end;

class function TPIRDistribution.DistrTypeToChar(const aDistrType: TPIRWorkDistributionType): Char;
begin
  case aDistrType of
    pirwdtPartitions:    Result:='Р';
    pirwdtConstructions: Result:='С';
  end;
end;

class function TPIRDistribution.DistrTypeToStr(const aDistrType: TPIRWorkDistributionType): String;
begin
  case aDistrType of
    pirwdtPartitions:    Result:='Разделы';
    pirwdtConstructions: Result:='Сооружения';
  end;
end;

procedure TPIRDistribution.SetCaption(const Value: string);
begin
  FCaption := Value;
end;

procedure TPIRDistribution.SetCode(const Value: string);
begin
  FCode := Value;
end;

procedure TPIRDistribution.SetCollapse(const Value: Cardinal);
begin
  FCollapse := Value;
end;

procedure TPIRDistribution.SetDistrType(const Value: TPIRWorkDistributionType);
begin
  FDistrType := Value;
end;

procedure TPIRDistribution.SetID(const Value: Cardinal);
begin
  FID := Value;
end;

procedure TPIRDistribution.SetSrc(const Value: string);
begin
  FSrc := Value;
end;

function TPIRDistribution.SortCap: TPIRSortCaption;
begin
  result:=SortCap(FCaption);
end;

class function TPIRDistribution.SortCap(const aCaption: string): TPIRSortCaption;
begin

end;

{ TPIRQuotationParameter }

constructor TPIRQuotationParameter.Create(Doc: Variant; const TxtOpt: TPIRQuotationParameterTextOptions);
begin

end;

constructor TPIRQuotationParameter.Create(const PDoc: PDocVariantData; const TxtOpt: TPIRQuotationParameterTextOptions);
begin

end;

constructor TPIRQuotationParameter.Create(const aKind: TPIRQuotationParameterKind;
                                          const aAlias, aName, aUnitName, aValue: string;
                                          const aisVolume: Boolean; const aApprox: Integer;
                                          const TxtOpt: TPIRQuotationParameterTextOptions);
begin
  FKind:=aKind;
  SetAlias(aAlias); SetName(aName); SetUnitName(aUnitName); SetValue(aValue);
  SetisVolume(aisVolume); SetApprox(aApprox);
  SetTextOptions(TxtOpt);
end;

constructor TPIRQuotationParameter.Create(const JSON: RawJSON; const TxtOpt: TPIRQuotationParameterTextOptions);
begin

end;

constructor TPIRQuotationParameter.CreateBand(const aAlias, aName, aUnitName, aValue: string;
                                              const TxtOpt: TPIRQuotationParameterTextOptions);
begin
  Create(pirQPKBand, aAlias, aName, aUnitName, aValue, True, pirQuotationParamAproxNone, TxtOpt);
end;

constructor TPIRQuotationParameter.CreateEnum(const aAlias, aName, aValue, aUnitName: string;
                                              const TxtOpt: TPIRQuotationParameterTextOptions);
begin
  Create(pirQPKEnum, aAlias, aName, aUnitName, aValue, False, pirQuotationParamAproxNone, TxtOpt);
end;

constructor TPIRQuotationParameter.CreateList(const aAlias, aName, aValues, aDescrs, aUnitName: string;
                                              const TxtOpt: TPIRQuotationParameterTextOptions);
begin
//  Create(pirQPKList, aAlias, aName, aUnitName, aValues, False, pirQuotationParamAproxNone, TxtOpt);
end;

constructor TPIRQuotationParameter.CreateSpan(const aAlias, aName, aUnitName, aValue: string;
                                              const aisVolume: Boolean; const aApprox: Integer;
                                              const TxtOpt: TPIRQuotationParameterTextOptions);
begin
  Create(pirQPKSpan, aAlias, aName, aUnitName, aValue, aisVolume, aApprox, TxtOpt);
end;

constructor TPIRQuotationParameter.CreateSurvey(const SurveyType:TPIRSurveyWorkType;
                                                const aAlias:string='Z'; const aName: string=pirSurveyWorkTypeParamName;
                                                const TxtOpt:TPIRQuotationParameterTextOptions=[]);
begin
  Create(pirQPKEnum, aAlias, aName, '', SurveyTypeName(SurveyType), False, pirQuotationParamAproxNone, TxtOpt);
end;

constructor TPIRQuotationParameter.CreateVolumeDef(const aAlias, aName, aUnitName, aValue: string;
                                                   const TxtOpt: TPIRQuotationParameterTextOptions);
begin
  Create(pirQPKBand, aAlias, aName, aUnitName, aValue, True, pirQuotationParamAproxNone, TxtOpt);
end;

function TPIRQuotationParameter.FromTable(PDoc: PDocVariantData; const Row, Col: Integer): Boolean;
begin

end;

function TPIRQuotationParameter.GetText: string;
begin

end;

function TPIRQuotationParameter.GetX1: string;
begin
  Result:=FX1;
end;

function TPIRQuotationParameter.GetX2: string;
begin
  Result:=FX2;
end;

procedure TPIRQuotationParameter.SetAlias(const Value: string);
begin
  FAlias := Value;
end;

procedure TPIRQuotationParameter.SetApprox(const Value: Word);
begin
  if FisVolume then FApprox := Value;
end;

procedure TPIRQuotationParameter.SetCurrCol(const Value: Integer);
begin
  FCurrCol := Value;
end;

procedure TPIRQuotationParameter.SetCurrRow(const Value: Integer);
begin
  FCurrRow := Value;
end;

procedure TPIRQuotationParameter.SetisVolume(const Value: Boolean);
begin
  if FKind in PIRQuotationParameterVolumed then begin
    FisVolume:=Value;
    if not FisVolume then FApprox:=pirQuotationParamAproxNone;
  end;
end;

procedure TPIRQuotationParameter.SetName(const Value: string);
begin
  FName := Value;
end;

procedure TPIRQuotationParameter.SetTextOptions(const Value: TPIRQuotationParameterTextOptions);
begin
  FTextOptions := Value;
end;

procedure TPIRQuotationParameter.SetUnitName(const Value: string);
begin
  FUnitName := Value;
end;

procedure TPIRQuotationParameter.SetValue(const Value: string);
begin
  FValue := Value;
end;

function TPIRQuotationParameter.ToDoc: Variant;
begin
  TDocVariant.New(Result);
  with TDocVariantData(Result) do begin
  {TDocVariantData(Result).}AddValue('knd', FKind);
  {TDocVariantData(Result).}AddValue('vol', FisVolume);
  {TDocVariantData(Result).}AddValue('apr', FApprox);
  {TDocVariantData(Result).}AddValue('opt', Byte(FTextOptions));
  {TDocVariantData(Result).}AddValue('nam', StringToUTF8(FName));
  {TDocVariantData(Result).}AddValue('val', StringToUTF8(FValue));
  {TDocVariantData(Result).}AddValue('fx1', StringToUTF8(FX1));
  {TDocVariantData(Result).}AddValue('fx2', StringToUTF8(FX2));
  {TDocVariantData(Result).}AddValue('unt', StringToUTF8(FUnitName));
  {TDocVariantData(Result).}AddValue('col', FCurrCol);
  {TDocVariantData(Result).}AddValue('row', FCurrRow);
  end;
end;

function TPIRQuotationParameter.ToJSON: RawJSON;
var v: Variant;
begin
  v:=ToDoc; Result := TDocVariantData(v).ToJSON()
end;

{ TPIRPriceParam }

procedure TPIRPriceParam.SetCoefB(const Value: Currency);
begin
  FCoefB := Value;
end;

procedure TPIRPriceParam.SetProps(const Value: string);
begin
  FProps := Value;
end;

procedure TPIRPriceParam.SetScale(const Value: Currency);
begin
  FScale := Value;
end;

function TPIRPriceParam.ToDoc: Variant;
begin
  TDocVariant.New(Result);
  with TDocVariantData(Result) do begin
    AddValue('sc', FScale);
    AddValue('cb', FCoefB);
    AddValue('pp', StringToUTF8(FProps));
  end;
end;

function TPIRPriceParam.ToJSON: RawUTF8;
var v:Variant;
begin
  v:=ToDoc; Result:=TDocVariantData(v).ToJSON();
end;

{ TPIRQuotation }

function TPIRQuotation.AddParam(aParam: TPIRQuotationParameter): Integer;
begin

end;

function TPIRQuotation.GetParam(Index: Integer): TPIRQuotationParameter;
begin

end;

procedure TPIRQuotation.SetApproveDoc(const Value: Integer);
begin
  FApproveDoc := Value;
end;

procedure TPIRQuotation.SetCypher(const Value: string);
begin
  FCypher := Value;
end;

procedure TPIRQuotation.SetFormatCyp(const Value: string);
begin
  FFormatCyp := Value;
end;

procedure TPIRQuotation.SetGroup(const Value: Integer);
begin
  FGroup := Value;
end;

procedure TPIRQuotation.SetID(const Value: Integer);
begin
  FID := Value;
end;

procedure TPIRQuotation.SetName(const Value: string);
begin
  FName := Value;
end;

procedure TPIRQuotation.SetParam(Index: Integer; const Value: TPIRQuotationParameter);
begin

end;

procedure TPIRQuotation.SetParams(const Value: TPIRQuotationParameters);
begin
  FParams := Value;
end;

procedure TPIRQuotation.SetprA(const Value: Extended);
begin
  FprA := Value;
end;

procedure TPIRQuotation.SetprB(const Value: Extended);
begin
  FprB := Value;
end;

procedure TPIRQuotation.SetPriceParam(const Value: TPIRPriceParam);
begin
  FPriceParam := Value;
end;

procedure TPIRQuotation.SetRepealDoc(const Value: Integer);
begin
  FRepealDoc := Value;
end;

procedure TPIRQuotation.SetSurveyWorkType(const Value: TPIRSurveyWorkType);
begin
  FSurveyWorkType := Value;
end;

procedure TPIRQuotation.SetUnitName(const Value: string);
begin
  FUnitName := Value;
end;

function TPIRQuotation.ToDoc: Variant;
var v,a: Variant; r: TPIRQuotationParameter;
begin
{
    FParamCount: Integer;
    FID: Integer;
}
  TDocVariant.New(Result);
  TDocVariantData(Result).AddValue('cyp', StringToUTF8(FCypher));
  TDocVariantData(Result).AddValue('fmt', StringToUTF8(FFormatCyp));
  TDocVariantData(Result).AddValue('nam', StringToUTF8(FName));
  TDocVariantData(Result).AddValue('unt', StringToUTF8(FUnitName));
  TDocVariantData(Result).AddValue('pra', FprA);
  TDocVariantData(Result).AddValue('prb', FprB);
  TDocVariantData(Result).AddValue('swt', FSurveyWorkType);
  TDocVariantData(Result).AddValue('apr', FApproveDoc);
  TDocVariantData(Result).AddValue('rpl', FRepealDoc);
  TDocVariantData(Result).AddValue('grp', FGroup);
  TDocVariantData(Result).AddValue('',FPriceParam.ToDoc);
  TDocVariant.New(a);
  for r in FParams do TDocVariantData(a).AddItem(r.ToDoc);
  TDocVariantData(Result).AddValue('prm',a);
end;

function TPIRQuotation.ToJSON: RawUTF8;
var v: Variant;
begin
  v:= ToDoc; TDocVariantData(v).ToJSON();
end;

{ TPIRTableCell }

class function TPIRTableCell.AddrToRC(const Addr: string; var vRow, vCol: Integer): Boolean;
var s,mk: string; i: Integer; R,C: Cardinal; ds: TDBDString; ch: Char;
begin
  R:=0; C:=0; Result:=False;
  if (Addr[1]='R') or (Addr[1]='r') then begin
    i:=2;
    if not DBDReadNumber(Addr,i,R) then Exit;
    if i>Length(Addr) then vRow:=R
    else if (Addr[i]='C') or (Addr[i]='c') then begin
      Inc(i);
      if not DBDReadNumber(Addr,i,C) then Exit
                                     else vCol:=C;
    end;
    Result:=True;
  end else if (Addr[1]='C') or (Addr[1]='c') then begin
    i:=2;
    if not DBDReadNumber(Addr,i,C) then Exit;
    if i>Length(Addr) then vCol:=C
    else if (Addr[i]='R') or (Addr[i]='r') then begin
      Inc(i);
      if not DBDReadNumber(Addr,i,C) then Exit
                                     else vRow:=R;
    end;
    Result:=True;
  end;
end;

procedure TPIRTableCell.Clear;
begin
  Row:=-1; Col:=-1;
end;

constructor TPIRTableCell.Create(const Addr: string);
var R, C: Integer;
begin
  R:=-1; C:=-1;
  if AddrToRC(Addr,R,C) then Create(R,C) else Clear;
end;

constructor TPIRTableCell.Create(const aRow, aCol: Integer);
begin
  Row:=aRow; Col:=aCol;
end;

function TPIRTableCell.ToAddr: string;
begin
  if Row>0 then Result:='R'+IntToStr(Row) else Result:='';
  if Col>0 then Result :='C'+IntToStr(Col);
end;

function TPIRTableCell.ToAddrUTF8: RawUTF8;
begin
  if Row>0 then Result:='R'+Int32ToUtf8(Row) else Result:='';
  if Col>0 then Result:=Result+'C'+Int32ToUtf8(Col);
end;

function TPIRTableCell.ToDoc: Variant;
begin
  TDocVariant.New(Result);
  TDocVariantData(Result).AddValue('R',Row);
  TDocVariantData(Result).AddValue('C',Col);
end;

function TPIRTableCell.ToJSON: RawUTF8;
var v: Variant;
begin
  v:=ToDoc; Result:=TDocVariantData(v).ToJSON;
end;

function TPIRTableCell.Undefined: Boolean;
begin
  result:= (Row<0) and (Col<0);
end;

constructor TPIRTableCell.Create(PDoc: PDocVariantData);
begin
  Clear;
  if (PDoc<>nil) and (PDoc^.Kind=dvObject) then begin
    if not PDoc^.GetAsInteger('R',Row) then Row:=-1;
    if not PDoc^.GetAsInteger('C',Col) then Col:=-1;
  end;
end;

constructor TPIRTableCell.CreateUTF8(const Addr: RawUTF8);
var P: PUTF8Char;
begin
  Clear; P:=@Addr[2];
  if Addr[1]='R' then begin
    Row:=GetNextItemCardinalStrict(P);
    if (P<>nil) and (P^='C') then begin Inc(p); Col:=GetNextItemCardinalStrict(P); end;
  end else if Addr[1]='C' then begin
    Col:=GetNextItemCardinalStrict(P);
    if (P<>nil) and (P^='R') then Row:=GetNextItemCardinalStrict(P);
  end;
end;

function TPIRTableCell.isCol: Boolean;
begin
  result:=(Col>=0) and (Row<0);
end;

function TPIRTableCell.isRow: Boolean;
begin
  result:=(Row>=0) and (Col<0);
end;

constructor TPIRTableCell.Create(Doc: Variant);
begin
  Create(_Safe(Doc));
end;

{ TPIRTableDescriptor }

function TPIRTableDescriptor.AddParam(Param: TPIRItemDescriptor): Integer;
begin
  Result :=Length(FRC_Parameters);
  SetLength(FRC_Parameters,Result+1);
  FRC_Parameters[Result]:=Param;
end;

function TPIRTableDescriptor.CellProps(const aRow, aCol: Integer; out oColor: TColor; out oFont: string): Boolean;
begin
   oColor:=pirDefaultColor; oFont:=pirDefaultFont;
   if (aRow<0) or (aCol<0) then begin Result:=False; Exit; end;
   Result := FRC_Data.InvolveCell(aRow,aCol);
   if Result then begin
      { TODO : Проверить длину области }
      oColor:=FRC_Data.Color; oFont:=FRC_Data.Font; Exit;
   end;
   Result := FRC_Name.InvolveCell(aRow,aCol);
   if Result then begin
     oColor:=FRC_Name.Color; oFont:=FRC_Name.Font; Exit;
   end;
   Result := FRC_Unit.InvolveCell(aRow,aCol);
   if Result then begin
     oColor:=FRC_Unit.Color; oFont:=FRC_Unit.Font; Exit;
   end;

end;

procedure TPIRTableDescriptor.Clear;
begin
  FName:=''; FID:=''; FRowID:=True; FKind:=pirTKDummy; FPriceKind:=pirTPKparamB; FMeashureOfPrice:=pirTMPThousand;
  FRowCount:=0; FColCount:=0;
  FRC_Data.Clear; FRC_Name.Clear; FRC_Prefix.Clear; FRC_Suffix.Clear; FRC_Unit.Clear;
  ClearParameters;
end;

procedure TPIRTableDescriptor.ClearParameters;
begin
  SetLength(FRC_Parameters,0);
end;

constructor TPIRTableDescriptor.Create(PDoc: PDocVariantData);
var r: RawUTF8; f: Boolean; p: PDocVariantData; i: Integer; o: TPIRItemDescriptor;
begin
  Clear;
  if (PDoc<>nil) and (PDoc^.Kind=dvObject) then begin
    if PDoc^.GetAsRawUTF8(pirTableNameUTF8, r) then SetName(UTF8ToString(r));
    if PDoc^.GetAsRawUTF8('id', r) then SetID(UTF8ToString(r));
    if PDoc^.GetAsBoolean('rid', f) then SetRowID(f);
    if PDoc^.GetAsInteger('knd', i) then SetKind(TPIRTableKind(i));
    if PDoc^.GetAsInteger('prk', i) then SetPriceKind(TPIRTablePriceKind(i));
    if PDoc^.GetAsInteger('mpr', i) then SetMeashureOfPrice(TPIRTableMeashureOfPrice(i));
    if PDoc^.GetAsInteger('col', i) then SetColCount(i);
    if PDoc^.GetAsInteger('row', i) then SetRowCount(i);
    if PDoc^.GetAsDocVariant('dat', p) then SetRC_Data(TPIRItemDescriptor.Create(p));
    if PDoc^.GetAsDocVariant('nam', p) then SetRC_Name(TPIRItemDescriptor.Create(p));
    if PDoc^.GetAsDocVariant('uni', p) then SetRC_Unit(TPIRItemDescriptor.Create(p));
    if PDoc^.GetAsDocVariant('prs', p) then begin
      if p^.Kind=dvObject then begin
        AddParam(TPIRItemDescriptor.Create(Variant(p^)))
      end else if p^.Kind=dvArray then begin
        for i := 0 to p^.Count-1 do begin
          AddParam(TPIRItemDescriptor.Create(p^.Values[i]));
        end;
      end;
    end;
  end;
end;

constructor TPIRTableDescriptor.Create(Doc: Variant);
begin
  Create(_Safe(Doc));
end;

function TPIRTableDescriptor.GetRC_Parameter(Index: integer): TPIRItemDescriptor;
begin
  if (Index>=0) and (Index<Length(FRC_Parameters)) then Result := FRC_Parameters[Index]
                                                   else Result.Clear;
end;

class function TPIRTableDescriptor.HeadEvaluation(PDoc: PDocVariantData): Integer;
var h,i: Integer; a,p: PDocVariantData; f: Boolean; r: RawUTF8;
begin
  Assert(PDoc<>nil, 'Таблица дожна быть задана');
  a:=PDoc^.A['pirTableDataUTF8'];    //pirTableHaveRowIDUTF8

  for i := 0 to a^.Count-1 do begin
    p:= a^._[i];

  end;

end;

function TPIRTableDescriptor.ParamCount: Integer;
begin
  Result:= Length(FRC_Parameters);
end;

class function TPIRTableDescriptor.pirTableKindToChar(const tk: TPIRTableKind): Char;
begin
  case tk of
    pirTKUndefine: Result:='-';
    pirTKDummy: Result:='o';
    pirTKQuotation: Result:='*';
    pirTKContinue: Result:='c';
  end;
end;

class function TPIRTableDescriptor.pirTableKindToString(const tk: TPIRTableKind): string;
begin
  case tk of
    pirTKUndefine: Result:='неопределено';
    pirTKDummy: Result:='не содержит расценок';
    pirTKQuotation: Result:='расценки';
    pirTKContinue: Result:='продолжение';
  end;
end;

procedure TPIRTableDescriptor.SetColCount(const Value: Integer);
begin
  FColCount := Value;
end;

procedure TPIRTableDescriptor.SetHaveDefaultVolumeParameter(const Value: Boolean);
begin
  FHaveDefaultVolumeParameter := Value;
end;

procedure TPIRTableDescriptor.SetID(const Value: string);
begin
  FID := Value;
end;

procedure TPIRTableDescriptor.SetKind(const Value: TPIRTableKind);
begin
  FKind := Value;
end;

procedure TPIRTableDescriptor.SetMeashureOfPrice(const Value: TPIRTableMeashureOfPrice);
begin
  FMeashureOfPrice := Value;
end;

procedure TPIRTableDescriptor.SetName(const Value: string);
begin
  FName := Value;
end;

procedure TPIRTableDescriptor.SetPriceKind(const Value: TPIRTablePriceKind);
begin
  FPriceKind := Value;
end;

procedure TPIRTableDescriptor.SetRC_Data(const Value: TPIRItemDescriptor);
begin
  FRC_Data := Value;
end;

procedure TPIRTableDescriptor.SetRC_Name(const Value: TPIRItemDescriptor);
begin
  FRC_Name := Value;
end;

procedure TPIRTableDescriptor.SetRC_Prefix(const Value: TPIRItemDescriptor);
begin
  FRC_Prefix := Value;
end;

procedure TPIRTableDescriptor.SetRC_Suffix(const Value: TPIRItemDescriptor);
begin
  FRC_Suffix := Value;
end;

procedure TPIRTableDescriptor.SetRC_Unit(const Value: TPIRItemDescriptor);
begin
  FRC_Unit := Value;
end;

procedure TPIRTableDescriptor.SetRowCount(const Value: Integer);
begin
  FRowCount := Value;
end;

procedure TPIRTableDescriptor.SetRowID(const Value: Boolean);
begin
  FRowID := Value;
end;

procedure TPIRTableDescriptor.SetTabNameToRow(const Value: Boolean);
begin
  FTabNameToRow := Value;
end;

function TPIRTableDescriptor.ToDoc: Variant;
var v, arr: Variant; i: Integer;
begin
  TDocVariant.New(Result);
  TDocVariantData(Result).AddValue(pirTableNameUTF8, StringToUTF8(FName));
  TDocVariantData(Result).AddValue('id', StringToUTF8(FID));
  TDocVariantData(Result).AddValue('rid', FRowId);
  TDocVariantData(Result).AddValue('knd', Ord(FKind));
  TDocVariantData(Result).AddValue('prk', Ord(FPriceKind));
  TDocVariantData(Result).AddValue('mpr', Ord(FMeashureOfPrice));
  TDocVariantData(Result).AddValue('col', FColCount);
  TDocVariantData(Result).AddValue('row', FRowCount);
  TDocVariantData(Result).AddValue('dat', FRC_Data.ToDoc);
  TDocVariantData(Result).AddValue('nam', FRC_Name.ToDoc);
  TDocVariantData(Result).AddValue('uni', FRC_Unit.ToDoc);
  if Length(FRC_Parameters)>0 then begin
    TDocVariant.New(arr);
    for i := Low(FRC_Parameters) to High(FRC_Parameters) do begin
      v:=FRC_Parameters[i].ToDoc;
      TDocVariantData(arr).AddItem(v);
      TDocVariantData(v).Clear;
    end;
    TDocVariantData(Result).AddValue('prs',arr);
    TDocVariantData(arr).Clear;
  end;
end;

function TPIRTableDescriptor.ToJSON: RawUTF8;
var v: Variant;
begin
  v:=ToDoc; TDocVariantData(v).ToJSON();
end;

{ TPIRItemDescriptor }

procedure TPIRItemDescriptor.Clear;
begin
  FCellTL.Clear; FCellBR.Clear; SetSource(''); SetSrcType(pirTSTConst); SetFont(''); SetColor(clWindow);
end;

constructor TPIRItemDescriptor.Create(const aSrcType: TPIRTableSourceType; const aSource: string);
begin
  Clear;
  SetSrcType(aSrcType); SetSource(aSource);
  case aSrcType of
    pirTSTConst: ;
    pirTSTAddress: SetCellTL(TPIRTableCell.Create(aSource));
    pirTSTText: {извлечь адрес};
    pirTSTNameTail: {извлечь адрес};
  end;
//  if aSrcType=pirTSTAddress then SetCell(TPIRTableCell.Create(aSource));
end;

constructor TPIRItemDescriptor.Create(Doc: Variant);
begin
  Create(_Safe(Doc));
end;

constructor TPIRItemDescriptor.Create(PDoc: PDocVariantData);
var i: Integer; r: RawUTF8; p: PDocVariantData;
begin
  Clear; if (PDoc=nil) or (PDoc^.Kind<>dvObject) then Exit;
  if PDoc^.GetAsRawUTF8(pirItemDescriptorSourceUTF8,r) then SetSource(UTF8ToString(r));
  if PDoc^.GetAsRawUTF8('fn',r) then SetFont(UTF8ToString(r));
  if PDoc^.GetAsInteger('cl',i) then SetColor(i);
  if PDoc^.GetAsInteger('st',i) then SetSrcType(TPIRTableSourceType(i));
  if PDoc^.GetAsDocVariant('tl',p) then SetCellTL(TPIRTableCell.Create(p));
  if PDoc^.GetAsDocVariant('br',p) then SetCellTL(TPIRTableCell.Create(p));
end;

constructor TPIRItemDescriptor.Create(const aCellTL: TPIRTableCell);
begin
  Clear; SetSrcType(pirTSTAddress); SetCellTL(aCellTL);
end;

constructor TPIRItemDescriptor.CreateCol(const Col: Integer);
begin
  Clear; SetSrcType(pirTSTAddress); SetCellTL(TPIRTableCell.Create(-1,Col));
end;

constructor TPIRItemDescriptor.CreateConst(const Text: string);
begin
  SetSrcType(pirTSTConst); SetSource(Text);
end;

constructor TPIRItemDescriptor.CreateFrame(const aCellTL, aCellBR: TPIRTableCell);
begin
  Clear; SetSrcType(pirTSTAddress); SetCellTL(aCellTL); SetCellBR(aCellBR);
end;

constructor TPIRItemDescriptor.CreateRow(const Row: Integer);
begin
  Clear; SetSrcType(pirTSTAddress); SetCellTL(TPIRTableCell.Create(Row,-1));
end;

function TPIRItemDescriptor.InvolveCell(const aRow, aCol: Integer): Boolean;
begin
  Result := not FCellTL.Undefined;
  if Result then begin
    if FCellTL.isCol then Result:=(FCellTL.Col=aCol)
    else if FCellTL.isRow then Result:=(FCellTL.Row=aRow)
    else begin
      Result := (FCellTL.Row<=aRow) and (FCellTL.Col<=aCol);
      if Result and (not FCellBR.Undefined) then
        Result := (FCellBR.Row>=aRow) and (FCellBR.Col>=aCol);
    end;
  end;
end;

function TPIRItemDescriptor.Cols: Integer;
begin
  if FCellTL.isCol then Result:=1
                   else Result:=FCellBR.Col-FCellTL.Col+1;
end;

function TPIRItemDescriptor.Rows: Integer;
begin
  if FCellTL.isRow then Result:=1
                   else Result:=FCellBR.Row-FCellTL.Row+1;
end;

procedure TPIRItemDescriptor.SetCellBR(const Value: TPIRTableCell);
begin
  FCellBR := Value;
end;

procedure TPIRItemDescriptor.SetCellTL(const Value: TPIRTableCell);
begin
  FCellTL := Value;
end;

procedure TPIRItemDescriptor.SetColor(const Value: TColor);
begin
  FColor := Value;
end;

procedure TPIRItemDescriptor.SetFont(const Value: string);
begin
  FFont := Value;
end;

procedure TPIRItemDescriptor.SetSource(const Value: string);
begin
  FSource := Value;
end;

procedure TPIRItemDescriptor.SetSrcType(const Value: TPIRTableSourceType);
begin
  FSrcType := Value;
end;

function TPIRItemDescriptor.ToDoc: Variant;
begin
  TDocVariant.New(Result);
  TDocVariantData(Result).AddValue('tl', FCellTL.ToDoc);
  TDocVariantData(Result).AddValue('br', FCellTL.ToDoc);
  TDocVariantData(Result).AddValue(pirItemDescriptorSourceUTF8,StringToUTF8(FSource));
  TDocVariantData(Result).AddValue('st', Ord(FSrcType));
  TDocVariantData(Result).AddValue('cl', FColor);
  TDocVariantData(Result).AddValue('fn', StringToUTF8(FFont));
end;

function TPIRItemDescriptor.ToJSON: RawUTF8;
var v: Variant;
begin
  v:=ToDoc; Result := TDocVariantData(v).ToJson;
end;

{ TPIRTableParameterDescriptor }

procedure TPIRTableParameterDescriptor.Clear;
begin
    FKind:=pirQPKEnum;
    SetisVolume(False); SetAlias('');
    SetTextOptions(PIRQuotationParameterTextNone);
    SetApprox(pirQuotationParamAproxNone);
    FRC_Value.Clear; FRC_Unit.Clear; FRC_Name.Clear;
end;

constructor TPIRTableParameterDescriptor.Create(Doc: Variant; const TxtOpt: TPIRQuotationParameterTextOptions);
begin
  Create(_Safe(Doc), TxtOpt);
end;

constructor TPIRTableParameterDescriptor.Create(PDoc: PDocVariantData; const TxtOpt: TPIRQuotationParameterTextOptions);
begin
  Clear;
  SetTextOptions(TxtOpt);
end;

constructor TPIRTableParameterDescriptor.Create(const aKind: TPIRQuotationParameterKind; const aAlias, aName, aUnitName,
  aValue: string; const aisVolume: Boolean; const aApprox: Integer; const TxtOpt: TPIRQuotationParameterTextOptions);
begin
  Clear;
  FKind:=aKind; SetisVolume(aisVolume); SetApprox(aApprox); SetTextOptions(TxtOpt); SetAlias(aAlias);
//  FRC_Name.Create();
end;

constructor TPIRTableParameterDescriptor.CreateBand(const aAlias, aName, aUnitName, aValue: string;
  const TxtOpt: TPIRQuotationParameterTextOptions);
begin

end;

constructor TPIRTableParameterDescriptor.CreateEnum(const aAlias, aName, aValue, aUnitName: string;
  const TxtOpt: TPIRQuotationParameterTextOptions);
begin

end;

constructor TPIRTableParameterDescriptor.CreateList(const aAlias, aName, aValues, aDescrs, aUnitName: string;
  const TxtOpt: TPIRQuotationParameterTextOptions);
begin

end;

constructor TPIRTableParameterDescriptor.CreateSpan(const aAlias, aName, aUnitName, aValue: string; const aisVolume: Boolean;
  const aApprox: Integer; const TxtOpt: TPIRQuotationParameterTextOptions);
begin

end;

constructor TPIRTableParameterDescriptor.CreateSurvey(const SurveyType: TPIRSurveyWorkType; const aAlias, aName: string;
  const TxtOpt: TPIRQuotationParameterTextOptions);
begin

end;

constructor TPIRTableParameterDescriptor.CreateVolumeDef(const aAlias, aName, aUnitName, aValue: string;
  const TxtOpt: TPIRQuotationParameterTextOptions);
begin

end;

function TPIRTableParameterDescriptor.GetText: string;
begin

end;

function TPIRTableParameterDescriptor.GetX1: string;
begin

end;

function TPIRTableParameterDescriptor.GetX2: string;
begin

end;

procedure TPIRTableParameterDescriptor.SetAlias(const Value: string);
begin
  FAlias := Value;
end;

procedure TPIRTableParameterDescriptor.SetApprox(const Value: Word);
begin
  FApprox := Value;
end;

procedure TPIRTableParameterDescriptor.SetisVolume(const Value: Boolean);
begin
  FisVolume := Value;
end;

procedure TPIRTableParameterDescriptor.SetRC_Name(const Value: TPIRItemDescriptor);
begin
  FRC_Name := Value;
end;

procedure TPIRTableParameterDescriptor.SetRC_Unit(const Value: TPIRItemDescriptor);
begin
  FRC_Unit := Value;
end;

procedure TPIRTableParameterDescriptor.SetRC_Value(const Value: TPIRItemDescriptor);
begin
  FRC_Value := Value;
end;

procedure TPIRTableParameterDescriptor.SetTextOptions(const Value: TPIRQuotationParameterTextOptions);
begin
  FTextOptions := Value;
end;

function TPIRTableParameterDescriptor.ToDoc: Variant;
begin

end;

function TPIRTableParameterDescriptor.ToJSON: RawUTF8;
var v: Variant;
begin
  v:=ToDoc; TDocVariantData(v).ToJSON();
end;

{ TPIRUserMark }

constructor TPIRUserMark.Create(Data: Variant; const aComment: string);
begin
  FComment:= StringToUTF8(aComment);
  FUser:=ExeVersion.User;
  FKey:=CardinalToHex(HashVariant(Data, crc32c));
  FMarkTime:=TimeLogNow;
end;

procedure TPIRUserMark.SetComment(const Value: RawUTF8);
begin
  FComment := Value;
end;

procedure TPIRUserMark.SetKey(const Value: RawByteString);
begin
  FKey := Value;
end;

procedure TPIRUserMark.SetMarkTime(const Value: TTimeLog);
begin
  FMarkTime := Value;
end;

procedure TPIRUserMark.SetUser(const Value: RawUTF8);
begin
  FUser := Value;
end;

function TPIRUserMark.ToDoc: Variant;
begin
  TDocVariant.New(Result);
  TDocVariantData(Result).AddValue(pirUserMarkTimeUTF8,FMarkTime);
  TDocVariantData(Result).AddValue(pirUserMarkNameUTF8,FUser);
  TDocVariantData(Result).AddValue(pirUserMarkKeyUTF8,FKey);
  TDocVariantData(Result).AddValue(pirUserMarkCommUTF8,FComment);
end;

function TPIRUserMark.ToJSON: RawUTF8;
var v: Variant;
begin
  v:=ToDoc; Result := TDocVariantData(v).ToJSON;
end;

end.