Добавьте файлы проекта.

2026-06-05 15:58:03 +07:00
parent 785bd7dc5d
commit cf8ef7add7
56 changed files with 13478 additions and 0 deletions
--- a/QWERTYkez.ExcelProcessor/Editors/ExcelColumn.cs
+++ b/QWERTYkez.ExcelProcessor/Editors/ExcelColumn.cs
@@ -0,0 +1,502 @@
+namespace QWERTYkez.ExcelProcessor.Editors;
+
+/// <summary>
+/// Внутренняя реализация <see cref="IColumn"/>.
+/// </summary>
+internal sealed class ExcelColumn : IColumn
+{
+    internal readonly ExcelWriter _writer;
+    internal readonly ExcelSheet _sheet;
+    internal uint _colIndex;
+
+    internal ExcelColumn(ExcelWriter writer, ExcelSheet sheet, uint colIndex)
+    {
+        _writer = writer;
+        _sheet = sheet;
+        _colIndex = colIndex;
+    }
+
+    public uint Index => _colIndex;
+    public string IndexLetter => NumberToColumnLetter(_colIndex);
+
+
+
+    /// <summary>Устанавливает ширину столбца без создания объекта IColumn.</summary>
+    internal static void SetWidth(ExcelWriter writer, ExcelSheet sheet, uint colIndex, ColumnWidth width)
+    {
+        writer.ThrowIfDisposed();
+        lock (writer._syncLock)
+        {
+            var col = GetOrCreateColumnElementInternal(sheet, colIndex);
+
+            double widthInChars;
+
+            if (width.IsCharacterUnit)
+            {
+                // Если ширина задана в символах, используем напрямую
+                widthInChars = width.CharacterValue;
+            }
+            else
+            {
+                double targetPoints = width.GetTargetPoints();
+                widthInChars = writer.TryGetCalibrateCoeff(targetPoints, out var closestCw)
+                        ? closestCw : targetPoints / ColumnWidth.DefaultPointsPerChar;
+            }
+
+
+            col.Width = widthInChars;
+            col.CustomWidth = true;
+        }
+    }
+
+    /// <summary>Возвращает ширину столбца.</summary>
+    internal static ColumnWidth GetWidth(ExcelWriter writer, ExcelSheet sheet, uint colIndex)
+    {
+        writer.ThrowIfDisposed();
+        lock (writer._syncLock)
+        {
+            var col = GetColumnElementInternal(sheet, colIndex);
+            if (col is Column column
+                && column.CustomWidth?.Value == true
+                && column.Width?.Value is { } wid)
+                return ColumnWidth.FromCharacters(wid);
+            return ColumnWidth.FromCharacters(8.43); // стандартная ширина
+        }
+    }
+
+    // Вспомогательные внутренние методы (перенести существующую логику)
+    private static Column? GetColumnElementInternal(ExcelSheet sheet, uint colIndex)
+    {
+        var cols = sheet.Worksheet.GetFirstChild<Columns>();
+        if (cols == null) return null;
+        foreach (Column col in cols.Elements<Column>())
+        {
+            if (col?.Min?.Value is { } min
+             && col?.Max?.Value is { } max
+             && min <= colIndex
+             && max >= colIndex)
+                return col;
+        }
+        return null;
+    }
+
+    private static Column GetOrCreateColumnElementInternal(ExcelSheet sheet, uint colIndex)
+    {
+        var existing = GetColumnElementInternal(sheet, colIndex);
+        if (existing != null) return existing;
+
+        var worksheet = sheet.Worksheet;
+        var cols = worksheet.GetFirstChild<Columns>();
+        if (cols == null)
+        {
+            cols = new Columns();
+            worksheet.InsertAt(cols, 0);
+        }
+        var newCol = new Column
+        {
+            Min = colIndex,
+            Max = colIndex,
+            Width = 8.43,
+            CustomWidth = true
+        };
+        cols.Append(newCol);
+        return newCol;
+    }
+
+
+
+    public IColumn MoveTo(uint index)
+    {
+        if (index == _colIndex) return this;
+        _writer.ThrowIfDisposed();
+        lock (_writer._syncLock)
+        {
+            // Копируем данные в новую позицию
+            CopyColumnData(_colIndex, index);
+            // Очищаем исходный столбец
+            ClearColumnData(_colIndex);
+            _colIndex = index;
+        }
+        return this;
+    }
+
+    public IColumn MoveTo(string index)
+    {
+        uint idx = CellAddressHelper.ColumnLetterToIndex(index);
+        return MoveTo(idx);
+    }
+
+    public ColumnWidth Width
+{
+    get
+    {
+        _writer.ThrowIfDisposed();
+        lock (_writer._syncLock)
+        {
+            var column = GetColumnElement();
+            if (column is Column col && col.Width?.Value is { } val && col.CustomWidth?.Value == true)
+                return ColumnWidth.FromCharacters(val);
+            return ColumnWidth.FromCharacters(8.43); // стандартная ширина
+        }
+    }
+    set
+    {
+        _writer.ThrowIfDisposed();
+        lock (_writer._syncLock)
+        {
+            var col = GetOrCreateColumnElement();
+            double widthInChars;
+
+            if (value.IsCharacterUnit)
+            {
+                // Если ширина задана в символах, используем напрямую
+                widthInChars = value.CharacterValue;
+            }
+            else
+            {
+                double targetCm = value.GetTargetCentimeters();
+                widthInChars = _writer.TryGetCalibrateCoeff(targetCm, out var closestCw)
+                        ? closestCw : targetCm * (ColumnWidth.DefaultPointsPerChar / 28.3464566929);
+            }
+
+            col.Width = widthInChars;
+            col.CustomWidth = true;
+        }
+    }
+}
+
+    public IColumn SetNumberFormat(NumberFormatPattern format)
+    {
+        if (format == null) return this;
+        _writer.ThrowIfDisposed();
+        lock (_writer._syncLock)
+        {
+            int fmtId = GetOrCreateNumberFormatId(format);
+            // Применяем ко всем ячейкам столбца
+            var sheetData = _sheet.GetSheetData();
+            foreach (var row in sheetData.Elements<Row>())
+            {
+                var cell = FindCellInRow(row, _colIndex);
+                cell?.StyleIndex = (uint)fmtId;
+            }
+        }
+        return this;
+    }
+
+    public ICell Cell(uint row)
+    {
+        return new ExcelCell(_writer, _sheet, row, _colIndex);
+    }
+
+    public IColumn Cell(uint row, Action<ICell> edit)
+    {
+        var cell = Cell(row);
+        edit(cell);
+        return this;
+    }
+
+    public IColumn Cell(uint row, string value)
+    {
+        Cell(row).Set(value); return this;
+    }
+
+    public IColumn Cell(uint row, bool value)
+    {
+        Cell(row).Set(value); return this;
+    }
+
+    public IColumn Cell(uint row, string value, NumberFormatPattern? format = null)
+    {
+        Cell(row).Set(value, format); return this;
+    }
+
+    public IColumn Cell(uint row, DateTime value, NumberFormatPattern? format = null)
+    {
+        Cell(row).Set(value, format); return this;
+    }
+
+    public IColumn Cell(uint row, decimal value, NumberFormatPattern? format = null)
+    {
+        Cell(row).Set(value, format); return this;
+    }
+
+    public IColumn Cell(uint row, double value, NumberFormatPattern? format = null)
+    {
+        Cell(row).Set(value, format); return this;
+    }
+
+    public IColumn Cell(uint row, float value, NumberFormatPattern? format = null)
+    {
+        Cell(row).Set(value, format); return this;
+    }
+
+    public IColumn Cell(uint row, int value, NumberFormatPattern? format = null)
+    {
+        Cell(row).Set(value, format); return this;
+    }
+
+    public IColumn Cell(uint row, long value, NumberFormatPattern? format = null)
+    {
+        Cell(row).Set(value, format); return this;
+    }
+
+
+
+
+
+
+    public void ClearContents()
+    {
+        _writer.ThrowIfDisposed();
+        lock (_writer._syncLock)
+        {
+            ClearColumnData(_colIndex);
+        }
+    }
+
+    public void ClearFormats()
+    {
+        _writer.ThrowIfDisposed();
+        lock (_writer._syncLock)
+        {
+            var sheetData = _sheet.GetSheetData();
+            foreach (var row in sheetData.Elements<Row>())
+            {
+                var cell = FindCellInRow(row, _colIndex);
+                cell?.StyleIndex = null;
+            }
+        }
+    }
+
+    public void Clear()
+    {
+        ClearContents();
+        ClearFormats();
+    }
+
+    public void Remove()
+    {
+        _writer.ThrowIfDisposed();
+        lock (_writer._syncLock)
+        {
+            // Очищаем данные
+            ClearColumnData(_colIndex);
+            // Удаляем элемент Column, если он существует
+            DeleteColumnElement();
+        }
+    }
+
+    public IColumn CopyTo(uint index, out IColumn copiedColumn)
+    {
+        _writer.ThrowIfDisposed();
+        lock (_writer._syncLock)
+        {
+            CopyColumnData(_colIndex, index);
+            copiedColumn = new ExcelColumn(_writer, _sheet, index);
+            return this;
+        }
+    }
+
+    public IColumn CopyTo(string index, out IColumn copiedColumn)
+    {
+        uint idx = CellAddressHelper.ColumnLetterToIndex(index);
+        return CopyTo(idx, out copiedColumn);
+    }
+
+    // Вспомогательные методы
+
+    private Column? GetColumnElement()
+    {
+        var cols = _sheet.Worksheet.GetFirstChild<Columns>();
+        if (cols == null) return null;
+        foreach (Column col in cols.Elements<Column>())
+        {
+            if (col?.Min?.Value is { } min
+             && col?.Max?.Value is { } max
+             && min <= _colIndex
+             && max >= _colIndex)
+                return col;
+        }
+        return null;
+    }
+
+    private Column GetOrCreateColumnElement()
+    {
+        var existing = GetColumnElement();
+        if (existing != null) return existing;
+
+        var worksheet = _sheet.Worksheet;
+        var cols = worksheet.GetFirstChild<Columns>();
+        if (cols == null)
+        {
+            cols = new Columns();
+            worksheet.InsertAt(cols, 0);
+        }
+
+        var newCol = new Column
+        {
+            Min = _colIndex,
+            Max = _colIndex,
+            Width = 8.43,
+            CustomWidth = true
+        };
+        cols.Append(newCol);
+        return newCol;
+    }
+
+    private void DeleteColumnElement()
+    {
+        var col = GetColumnElement();
+        col?.Remove();
+    }
+
+    private void CopyColumnData(uint sourceCol, uint targetCol)
+    {
+        if (sourceCol == targetCol) return;
+        var sheetData = _sheet.GetSheetData();
+        // Сначала удаляем существующие данные в целевом столбце (если нужно перезаписать)
+        ClearColumnData(targetCol);
+        // Копируем значения и форматы из sourceCol в targetCol
+        foreach (var row in sheetData.Elements<Row>())
+        {
+            var sourceCell = FindCellInRow(row, sourceCol);
+            if (sourceCell != null)
+            {
+                var targetCell = FindCellInRow(row, targetCol);
+                if (targetCell == null)
+                {
+                    targetCell = new Cell();
+                    // Вставляем в нужное место (по порядку столбцов)
+                    InsertCellInRow(row, targetCell, targetCol);
+                }
+                // Копируем содержимое и стиль
+                targetCell.DataType = sourceCell.DataType;
+                targetCell.CellValue = sourceCell.CellValue?.CloneNode(true) as CellValue;
+                targetCell.CellFormula = sourceCell.CellFormula?.CloneNode(true) as CellFormula;
+                targetCell.StyleIndex = sourceCell.StyleIndex;
+                // Если есть InlineString, клонируем
+                if (sourceCell.InlineString != null)
+                    targetCell.InlineString = (InlineString)sourceCell.InlineString.CloneNode(true);
+            }
+        }
+        // Копируем ширину столбца
+        var sourceColElem = GetColumnElementForIndex(sourceCol);
+        if (sourceColElem?.Width is { } width)
+        {
+            var targetColElem = GetOrCreateColumnElementForIndex(targetCol);
+            targetColElem.Width = width;
+            targetColElem.CustomWidth = sourceColElem.CustomWidth;
+        }
+    }
+
+    private void ClearColumnData(uint col)
+    {
+        var sheetData = _sheet.GetSheetData();
+        foreach (var row in sheetData.Elements<Row>().ToList())
+        {
+            var cell = FindCellInRow(row, col);
+            cell?.Remove();
+        }
+    }
+
+    private Cell? FindCellInRow(Row row, uint colIndex)
+    {
+        foreach (var cell in row.Elements<Cell>())
+        {
+            string cellRef = cell.CellReference?.Value ?? string.Empty;
+            if (TryParseCellReference(cellRef, out uint _, out uint colIdx) && colIdx == colIndex)
+                return cell;
+        }
+        return null;
+    }
+
+    private void InsertCellInRow(Row row, Cell cell, uint colIndex)
+    {
+        string newRef = NumberToColumnLetter(colIndex) + (row.RowIndex?.Value ?? 1).ToString();
+        cell.CellReference = newRef;
+        // Вставляем в правильном порядке (по возрастанию столбцов)
+        bool inserted = false;
+        foreach (var existing in row.Elements<Cell>().ToList())
+        {
+            if (TryParseCellReference(existing.CellReference?.Value ?? string.Empty, out _, out uint existingCol) &&
+                existingCol > colIndex)
+            {
+                existing.InsertBeforeSelf(cell);
+                inserted = true;
+                break;
+            }
+        }
+        if (!inserted)
+            row.Append(cell);
+    }
+
+    private Column? GetColumnElementForIndex(uint col)
+    {
+        var cols = _sheet.Worksheet.GetFirstChild<Columns>();
+        if (cols == null) return null;
+        foreach (Column c in cols.Elements<Column>())
+        {
+            if (c.Min?.Value is { } min
+             && c.Max?.Value is { } max
+             && min <= col
+             && max >= col)
+                return c;
+        }
+        return null;
+    }
+
+    private Column GetOrCreateColumnElementForIndex(uint col)
+    {
+        var existing = GetColumnElementForIndex(col);
+        if (existing != null) return existing;
+
+        var worksheet = _sheet.Worksheet;
+        var cols = worksheet.GetFirstChild<Columns>();
+        if (cols == null)
+        {
+            cols = new Columns();
+            worksheet.InsertAt(cols, 0);
+        }
+        var newCol = new Column
+        {
+            Min = col,
+            Max = col,
+            Width = 8.43,
+            CustomWidth = true
+        };
+        cols.Append(newCol);
+        return newCol;
+    }
+
+    private int GetOrCreateNumberFormatId(NumberFormatPattern format)
+    {
+        return _writer.GetOrCreateCellFormatId(numberFormat: format);
+    }
+
+    private static bool TryParseCellReference(string reference, out uint row, out uint col)
+    {
+        row = 0; col = 0;
+        if (string.IsNullOrEmpty(reference)) return false;
+        int i = 0;
+        while (i < reference.Length && char.IsLetter(reference[i])) i++;
+        if (i == 0) return false;
+        string colPart = reference.Substring(0, i);
+        string rowPart = reference.Substring(i);
+        if (!uint.TryParse(rowPart, out row)) return false;
+        col = CellAddressHelper.ColumnLetterToIndex(colPart);
+        return true;
+    }
+
+    private static string NumberToColumnLetter(uint col)
+    {
+        if (col == 0) throw new ArgumentException("Column number must be > 0");
+        string result = "";
+        while (col > 0)
+        {
+            col--;
+            result = (char)('A' + (col % 26)) + result;
+            col /= 26;
+        }
+        return result;
+    }
+}