cnreport.cpp

自定义的报表

                if (LineArray->Items[i] != NULL)
                {
                        ThisLineRect = ((TCNReportLine *)FLineList->Items[i])->LineRect;
                        ThisLineRect.Right  = ThisLineRect.Right + 1;
                        ThisLineRect.Bottom = ThisLineRect.Bottom + 1;
                        InvalidateRect(Handle, &ThisLineRect, False);

                        for (j = 0; j < ((TCNReportLine *)FLineList->Items[i])->FCells->Count; j++)
                        {
                                ThisCell = (TCNReportCell *)(((TCNReportLine *)FLineList->Items[i])->FCells->Items[j]);
                                if (ThisCell->OwnerCell != NULL)
                                        ThisCell->OwnerCell->RemoveOwnedCell(ThisCell);
                                if (ThisCell->OwnedCellCount > 0)
                                        ThisCell->RemoveAllOwnedCell();
                        }
                        delete ((TCNReportLine *)FLineList->Items[i]);
                        FLineList->Delete(i);
                }
        }

        delete LineArray;

        UpdateLines();
}
void __fastcall TCNReportControl::InsertCell(void)
{
        TCNReportCell *ThisCell, *NewCell;
        TCNReportLine *ThisLine;
        if (FSelectCells->Count != 1 ) return;

        ThisCell = (TCNReportCell *)FSelectCells->Items[0];
        ThisLine = ThisCell->OwnerLine;
        NewCell  = new TCNReportCell;
        NewCell->CopyCell(ThisCell, False);
        ThisLine->FCells->Insert(ThisLine->FCells->IndexOf(ThisCell), NewCell);
        UpdateLines();
}
void __fastcall TCNReportControl::DeleteCell(void)
{
        int I, J;
        TCNReportCell *ThisCell, *TempCell;
        TCNReportLine *ThisLine;

        if (FSelectCells->Count <= 0 ) return;

        for (I = FSelectCells->Count - 1; I >= 0; I--)
        {
                ThisCell = (TCNReportCell *)FSelectCells->Items[I];

                for ( J = ThisCell->FCellsList->Count - 1; J >= 0; J--)
                {
                        TempCell = (TCNReportCell *)ThisCell->FCellsList->Items[J];
                        TempCell->OwnerLine->FCells->Remove(TempCell);
                        delete TempCell;
                }

                ThisCell->FCellsList->Clear();

                ThisCell->OwnerLine->FCells->Remove(ThisCell);
                RemoveSelectedCell(ThisCell);
                delete ThisCell;
        }
        FSelectCells->Clear();

        UpdateLines();

        for (I = FLineList->Count - 1; I >= 0; I--)
        {
                ThisLine = (TCNReportLine *)FLineList->Items[I];
                if (ThisLine->FCells->Count <= 0 )
                {
                        FLineList->Remove(ThisLine);
                        delete ThisLine;
                }
        }
}
void __fastcall TCNReportControl::AddCell(void)
{
        TCNReportLine *ThisLine;
        TCNReportCell *ThisCell, *NewCell;

        if (FSelectCells->Count != 1 ) return;

        ThisCell = (TCNReportCell *)FSelectCells->Items[0];
        ThisLine = ThisCell->OwnerLine;
        NewCell = new TCNReportCell;
        NewCell->OwnerLine = ThisLine;
        NewCell->CopyCell( (TCNReportCell *)(ThisLine->FCells->Items[ThisLine->FCells->Count - 1]), False);
        NewCell->CellLeft = ((TCNReportCell *)(ThisLine->FCells->Items[ThisLine->FCells->Count - 1]))->CellRect.Right;
        ThisLine->FCells->Add(NewCell);

        UpdateLines();

}
void __fastcall TCNReportControl::CombineCell(void)
{
        int I, J, Count;
        TCNReportCell *OwnerCell;
        TList *LineArray;
        TCNReportCell *ThisCell, *FirstCell;
        TCNReportLine *ThisLine;
        int TempLeft, TempRight;
        TList *CellsToDelete;
        TList *CellsToCombine;
        TCNMyRect *TempRect;

        // 判断是否可以合并

        // 选中的CELL数量小于2
        if (FSelectCells->Count < 2 ) return;


        Count = FSelectCells->Count - 1;

        for ( I = 0 ; I <=  Count; I++)
        {
                ThisCell = (TCNReportCell *)FSelectCells->Items[I];

                for (J = 0 ; J < ThisCell->FCellsList->Count; J++)
                {
                        FSelectCells->Add(ThisCell->FCellsList->Items[J]);
                }
        }
        // 各个行的宽度不同

        LineArray = new TList;
        for (I = 0 ; I < FLineList->Count; I ++)
        {
                TempRect = new TCNMyRect;
                TempRect->Left = 65535;
                TempRect->Top = 0;
                TempRect->Right = 0;
                TempRect->Bottom = 0;
                LineArray->Add(TempRect);
        }

        for (I = 0 ; I < FSelectCells->Count; I++)
        {
                ThisCell = (TCNReportCell *)FSelectCells->Items[I];
                if (ThisCell->CellLeft < ((TCNMyRect *)LineArray->Items[ThisCell->OwnerLine->Index])->Left)
                        ((TCNMyRect *)LineArray->Items[ThisCell->OwnerLine->Index])->Left = ThisCell->CellLeft;

                if( (ThisCell->CellRect.Right) > ((TCNMyRect *)LineArray->Items[ThisCell->OwnerLine->Index])->Right )
                        ((TCNMyRect *)LineArray->Items[ThisCell->OwnerLine->Index])->Right = ThisCell->CellRect.Right;
        }
        TempLeft = 0;
        TempRight = 0;

        for (I = 0 ; I < LineArray->Count; I++)
        {
                if ( ((TCNMyRect *)LineArray->Items[I])->Left == 65535)
                        continue;

                if ((TempLeft == 0) && (TempRight == 0))
                {
                        TempLeft  = ((TCNMyRect *)LineArray->Items[I])->Left;
                        TempRight = ((TCNMyRect *)LineArray->Items[I])->Right;
                }
                else
                {
                        if (TempLeft  != ((TCNMyRect *)LineArray->Items[I])->Left) return;
                        if (TempRight != ((TCNMyRect *)LineArray->Items[I])->Right) return;
                }
        }
        // 将同一行上的单元格合并
        CellsToDelete  = new TList;
        CellsToCombine = new TList;

        for (I = 0 ; I < LineArray->Count ; I++)
        {
                if ( ((TCNMyRect *)LineArray->Items[I])->Left == 65535)
                        continue;

                CellsToDelete->Clear();

                FirstCell = NULL;
                ThisLine = (TCNReportLine *)FLineList->Items[I];

                for (J = 0; J < ThisLine->FCells->Count ; J ++)
                {
                        ThisCell = (TCNReportCell *)ThisLine->FCells->Items[J];
                        if (IsCellSelected(ThisCell))
                        {
                                if (FirstCell == NULL)
                                {
                                        FirstCell = ThisCell;
                                        CellsToCombine->Add(ThisCell);
                                }
                                else
                                {
                                        FirstCell->CellWidth = FirstCell->CellWidth + ThisCell->CellWidth;
                                        CellsToDelete->Add(ThisCell);
                                }
                        }
                }
                for (J = CellsToDelete->Count - 1; J >= 0; J --)
                {
                        ThisLine->FCells->Remove(CellsToDelete->Items[J]);
                        RemoveSelectedCell((TCNReportCell *)CellsToDelete->Items[J]);
                        delete ((TCNReportCell *)CellsToDelete->Items[J]);
                }
        }

        delete CellsToDelete;

        // 合并同一列的单元格
        for ( I = 0 ; I < CellsToCombine->Count; I++)
        {
                if (I > 0 )
                {
                        ((TCNReportCell *)CellsToCombine->Items[0])->AddOwnedCell( ((TCNReportCell *)CellsToCombine->Items[I]));
                }
                InvalidateRect(Handle, &(((TCNReportCell *)FSelectCells->Items[I])->CellRect), False);
        }

        while (LineArray->Count > 0)
        {
                delete ((TCNMyRect *)LineArray->Items[0]);
                LineArray->Delete(0);
        }
        delete LineArray;

        OwnerCell = (TCNReportCell *)CellsToCombine->Items[0];
        RemoveAllSelectedCell();
        AddSelectedCell(OwnerCell);
        UpdateLines();

}
void __fastcall TCNReportControl::SplitCell(void)
{
        TCNReportCell *TempCell;
        int I;

        if (CanSplit())
        {
                TempCell = ((TCNReportCell *)FSelectCells->Items[0]);
                RemoveAllSelectedCell();

                AddSelectedCell(TempCell);

                for ( I = 0; I < TempCell->FCellsList->Count; I++)
                        InvalidateRect(Handle, &(((TCNReportCell *)TempCell->FCellsList->Items[I])->CellRect), False);

                TempCell->RemoveAllOwnedCell();

                UpdateLines();
        }
}
void __fastcall TCNReportControl::VSplitCell(int Number)
{
        TCNReportCell *ThisCell, *TempCell, *TempCell2;
        int I, J, CellWidth, MaxCellCount;

        if (FSelectCells->Count != 1) return;

        ThisCell = (TCNReportCell *)FSelectCells->Items[0];

        InvalidateRect(Handle, &(ThisCell->CellRect), False);

        MaxCellCount = trunc((ThisCell->CellRect.Right - ThisCell->CellRect.Left) / 12 + 0.5);

        if (MaxCellCount > Number) MaxCellCount = Number;

        CellWidth = trunc((ThisCell->CellRect.Right - ThisCell->CellRect.Left) / MaxCellCount + 0.5);

        ThisCell->CellWidth = CellWidth;

        for( I = 0; I < MaxCellCount; I++)
        {
                if (I == 0 )
                {
                        ThisCell->CellWidth = CellWidth;
                        for (J = 0; J <  ThisCell->FCellsList->Count; J++)
                        {
                                ((TCNReportCell *)ThisCell->FCellsList->Items[J])->CellWidth = CellWidth;
                        }

                        continue;
                }
                TempCell = new TCNReportCell;
                TempCell->CopyCell(ThisCell, False);
                TempCell->OwnerLine = ThisCell->OwnerLine;

                if ( (ThisCell->OwnerLine->FCells->IndexOf(ThisCell)) == (ThisCell->OwnerLine->FCells->Count - 1) )
                        TempCell->OwnerLine->FCells->Add(TempCell);
                else
                        TempCell->OwnerLine->FCells->Insert(ThisCell->OwnerLine->FCells->IndexOf(ThisCell) + 1, TempCell);

                for (J = 0 ; J < ThisCell->FCellsList->Count ; J++)
                {
                        TempCell2 = new TCNReportCell;
                        TempCell2->CopyCell(TempCell, False);
                        TempCell->AddOwnedCell(TempCell2);
                        TempCell2->OwnerLine = ((TCNReportCell *)ThisCell->FCellsList->Items[J])->OwnerLine;

                        if ((ThisCell->OwnerLine->FCells->IndexOf(ThisCell)) == (ThisCell->OwnerLine->FCells->Count - 1) )
                                ((TCNReportCell *)ThisCell->FCellsList->Items[J])->OwnerLine->FCells->Add(TempCell2);
                        else
                                ((TCNReportCell *)ThisCell->FCellsList->Items[J])->OwnerLine->FCells->Insert(
                                                ((TCNReportCell *)ThisCell->FCellsList->Items[J])->OwnerLine->FCells->IndexOf(
                                                ((TCNReportCell *)ThisCell->FCellsList->Items[J])) + 1, TempCell2);
                }
        }
        UpdateLines();
}
bool __fastcall TCNReportControl::CanSplit(void)
{
        if (FSelectCells->Count == 1)
        {
                if (((TCNReportCell *)FSelectCells->First())->FCellsList->Count > 0 )
                        return True;
                else
                        return False;