Ejemplo n.º 1
0
        public void ShiftColumnDown()
        {
            IGridConfiguration conf = CreateTestConfig();
            IGrid grid = new SquareGrid(conf);

            List <ICellContent> contents = new List <ICellContent>(conf.ColumnCount * conf.RowCount);

            FillColumnContents(grid, contents);

            Assert.AreSame(contents[0], grid.Columns[0][0].Content);
            Assert.AreSame(contents[1], grid.Columns[0][1].Content);
            ICellContent firstRowContent = grid.Columns[0][0].Content;

            grid.Accept(new ColumnDownShifter(0, 3));

            Assert.AreSame(firstRowContent, grid.Columns[0][3].Content);

            grid.Accept(new ColumnDownShifter(0, 10));

            Assert.AreSame(firstRowContent, grid.Columns[0][3].Content);

            grid.Accept(new ColumnDownShifter(0, 13));

            Assert.AreSame(firstRowContent, grid.Columns[0][1].Content);
        }
Ejemplo n.º 2
0
        public void Put(ICellContent content)
        {
            if (!this.IsEmpty)
            {
                throw new InvalidOperationException();
            }

            this.Content = content;
        }
Ejemplo n.º 3
0
        public void SetGridCellContent()
        {
            IGridConfiguration conf = CreateTestConfig();
            IGrid grid = new SquareGrid(conf);

            ICellContent content = Substitute.For <ICellContent>();

            Cell.Cell cell = grid.GetCell(0, 0);
            cell.Content = content;

            Assert.AreEqual(content, grid.GetCell(0, 0).Content);
        }
Ejemplo n.º 4
0
 void FillColumnContents(IGrid grid, List <ICellContent> contents)
 {
     foreach (CellCollection column in grid.Columns)
     {
         column.Foreach(delegate(Cell.Cell c)
         {
             ICellContent content = Substitute.For <ICellContent>();
             c.Content            = content;
             contents.Add(content);
         });
     }
 }
Ejemplo n.º 5
0
 void FillRowContents(IGrid grid, List <ICellContent> contents)
 {
     foreach (CellCollection row in grid.Rows)
     {
         row.Foreach(delegate(Cell.Cell c)
         {
             ICellContent content = Substitute.For <ICellContent>();
             c.Content            = content;
             contents.Add(content);
         });
     }
 }
Ejemplo n.º 6
0
        private static void ConvertFile(String sourcePath)
        {
            using (FileStream input = File.OpenRead(sourcePath))
                using (BinaryReader br = new BinaryReader(input))
                {
                    CshHeader header = new CshHeader
                    {
                        Type         = br.ReadBigUInt32(),
                        ColumnNumber = br.ReadBigUInt32(),
                        RowNumber    = br.ReadBigUInt32()
                    };

                    if (header.Type != 0)
                    {
                        throw new NotSupportedException($"Unknown type: {header.Type}");
                    }

                    CshCell[] cells = new CshCell[header.ColumnNumber * header.RowNumber];
                    input.DangerousReadStructs(cells, cells.Length);

                    String targetPath = Path.ChangeExtension(sourcePath, ".csv");

                    ICellContent[] buff = new ICellContent[header.ColumnNumber];

                    using (CsvWriter writer = new CsvWriter(targetPath))
                    {
                        Int32 cellIndex = 0;
                        for (Int32 r = 0; r < header.RowNumber; r++)
                        {
                            for (Int32 c = 0; c < header.ColumnNumber; c++)
                            {
                                CshCell      cell    = cells[cellIndex++];
                                ICellContent content = ReadContent(input, cell);
                                buff[c] = content;
                            }

                            ContentEntry entry = new ContentEntry(buff);
                            writer.WriteEntry(entry, null);
                        }
                    }
                }
        }
Ejemplo n.º 7
0
 public Cell(ICellContent content, Coordinates coords)
 {
     this.Coordinates = coords;
     this.Put(content);
 }
 public void AddContent(ICellContent openXmlParagraphModel)
 {
     _contents.Add(openXmlParagraphModel);
 }
Ejemplo n.º 9
0
 public void Empty()
 {
     Content = NullContent.Instance;
 }
Ejemplo n.º 10
0
        private static void TransformBackFile(String csvPath, String decPath)
        {
            String tmpPath;

            CshCell[] cells;
            using (FileStream decInput = File.OpenRead(decPath))
                using (BinaryReader decBr = new BinaryReader(decInput))
                {
                    CshHeader header = new CshHeader
                    {
                        Type         = decBr.ReadBigUInt32(),
                        ColumnNumber = decBr.ReadBigUInt32(),
                        RowNumber    = decBr.ReadBigUInt32()
                    };

                    if (header.Type != 0)
                    {
                        throw new NotSupportedException($"Unknown type: {header.Type}");
                    }

                    cells = new CshCell[header.ColumnNumber * header.RowNumber];
                    decInput.DangerousReadStructs(cells, cells.Length);

                    RowCsvEntry[] data = CsvReader.Read <RowCsvEntry>(csvPath);
                    if (header.RowNumber != data.Length)
                    {
                        throw new InvalidDataException($"header.RowNumber ({header.RowNumber}) != data.Length ({data.Length})");
                    }

                    tmpPath = decPath + ".tmp";
                    using (FileStream decOutput = File.Create(tmpPath))
                        using (BinaryWriter decBw = new BinaryWriter(decOutput))
                        {
                            decBw.WriteBig(header.Type);
                            decBw.WriteBig(header.ColumnNumber);
                            decBw.WriteBig(header.RowNumber);
                            Int64 headerOffset = decOutput.Position;

                            // Reserve space for header
                            decOutput.DangerousWriteStructs(cells, cells.Length);

                            if (decOutput.Position != decInput.Position)
                            {
                                throw new InvalidDataException();
                            }

                            AlignData(decOutput);

                            Int32 cellIndex = 0;
                            for (Int32 r = 0; r < header.RowNumber; r++)
                            {
                                RowCsvEntry row = data[r];

                                for (Int32 c = 0; c < header.ColumnNumber; c++)
                                {
                                    CshCell      cell        = cells[cellIndex++];
                                    ICellContent cellContent = ReadContent(decInput, cell);

                                    if (cell.Offset != 0)
                                    {
                                        cell.Offset          = (UInt32)decOutput.Position;
                                        cells[cellIndex - 1] = cell; // It's a struct
                                    }

                                    if (cellContent is StringContent str)
                                    {
                                        str.ParseValue(CsvParser.String(row.Raw[c]));
                                    }

                                    cellContent.Write(decOutput, decBw);
                                    AlignData(decOutput);
                                }
                            }

                            // Update offsets
                            decOutput.Position = headerOffset;
                            decOutput.DangerousWriteStructs(cells, cells.Length);


                            // For test
                            //CheckFiles(decInput, decOutput);
                        }
                }

            File.Delete(decPath);
            File.Move(tmpPath, decPath);
        }