frxcross.pas

报表控件。FastReport 是非常强大的报表控件

    Item := Item.Add;
    Item.Name := 'item';
    Item.Text := IntToStr(Integer(f));
  end;

  procedure AddItem2(f: TfrxCrossSortOrder; const Name: String);
  var
    Item: TfrxXMLItem;
  begin
    Item := x.Root.FindItem(Name);
    Item := Item.Add;
    Item.Name := 'item';
    Item.Text := IntToStr(Integer(f));
  end;

begin
  x := TfrxXMLDocument.Create;
  x.Root.Name := 'cross';

  try
    x.Root.Add.Name := 'cellmemos';
    x.Root.Add.Name := 'columnmemos';
    x.Root.Add.Name := 'columntotalmemos';
    x.Root.Add.Name := 'rowmemos';
    x.Root.Add.Name := 'rowtotalmemos';
    x.Root.Add.Name := 'cellfunctions';
    x.Root.Add.Name := 'columnsort';
    x.Root.Add.Name := 'rowsort';

    for i := 0 to CellLevels - 1 do
    begin
      AddItem(CellMemos[i], 'cellmemos');
      AddItem1(CellFunctions[i], 'cellfunctions');
    end;
    for i := 0 to ColumnLevels - 1 do
    begin
      AddItem(ColumnMemos[i], 'columnmemos');
      AddItem(ColumnTotalMemos[i], 'columntotalmemos');
      AddItem2(ColumnSort[i], 'columnsort');
    end;
    for i := 0 to RowLevels - 1 do
    begin
      AddItem(RowMemos[i], 'rowmemos');
      AddItem(RowTotalMemos[i], 'rowtotalmemos');
      AddItem2(RowSort[i], 'rowsort');
    end;

    x.SaveToStream(Stream);
  finally
    x.Free;
  end;
end;

function TfrxCustomCrossView.CreateMemo(Parent: TfrxComponent): TfrxCustomMemoView;
begin
  if FDotMatrix then
    Result := TfrxDMPMemoView.Create(Parent) else
    Result := TfrxMemoView.Create(Parent);
end;

procedure TfrxCustomCrossView.CorrectDMPBounds(Memo: TfrxCustomMemoView);
begin
  if Memo is TfrxDMPMemoView then
  begin
    Memo.Left := Memo.Left + fr1CharX;
    Memo.Top := Memo.Top + fr1CharY;
    Memo.Width := Memo.Width - fr1CharX;
    Memo.Height := Memo.Height - fr1CharY;
  end;
end;

function TfrxCustomCrossView.GetCellFunctions(Index: Integer): TfrxCrossFunction;
begin
  Result := FMatrix.CellFunctions[Index];
end;

function TfrxCustomCrossView.GetCellMemos(Index: Integer): TfrxCustomMemoView;
begin
  Result := FMatrix.CellMemos[Index];
end;

function TfrxCustomCrossView.GetColumnMemos(Index: Integer): TfrxCustomMemoView;
begin
  Result := FMatrix.ColumnMemos[Index];
end;

function TfrxCustomCrossView.GetColumnTotalMemos(Index: Integer): TfrxCustomMemoView;
begin
  Result := FMatrix.ColumnTotalMemos[Index];
end;

function TfrxCustomCrossView.GetRowMemos(Index: Integer): TfrxCustomMemoView;
begin
  Result := FMatrix.RowMemos[Index];
end;

function TfrxCustomCrossView.GetRowTotalMemos(Index: Integer): TfrxCustomMemoView;
begin
  Result := FMatrix.RowTotalMemos[Index];
end;

procedure TfrxCustomCrossView.SetCellFunctions(Index: Integer; const Value: TfrxCrossFunction);
begin
  FMatrix.CellFunctions[Index] := Value;
end;

procedure TfrxCustomCrossView.SetCellFields(const Value: TStrings);
begin
  FCellFields.Assign(Value);
end;

procedure TfrxCustomCrossView.SetColumnFields(const Value: TStrings);
begin
  FColumnFields.Assign(Value);
end;

procedure TfrxCustomCrossView.SetPlainCells(const Value: Boolean);
begin
  FPlainCells := Value;
  FMatrix.PlainCells := Value;
end;

procedure TfrxCustomCrossView.SetRowFields(const Value: TStrings);
begin
  FRowFields.Assign(Value);
end;

function TfrxCustomCrossView.GetColumnSort(Index: Integer): TfrxCrossSortOrder;
begin
  Result := FMatrix.ColumnSort[Index];
end;

function TfrxCustomCrossView.GetRowSort(Index: Integer): TfrxCrossSortOrder;
begin
  Result := FMatrix.RowSort[Index];
end;

procedure TfrxCustomCrossView.SetColumnSort(Index: Integer; Value: TfrxCrossSortOrder);
begin
  FMatrix.ColumnSort[Index] := Value;
end;

procedure TfrxCustomCrossView.SetRowSort(Index: Integer; Value: TfrxCrossSortOrder);
begin
  FMatrix.RowSort[Index] := Value;
end;

function TfrxCustomCrossView.GetShowColumnTotal: Boolean;
begin
  Result := ColumnTotalMemos[0].Visible;
end;

function TfrxCustomCrossView.GetShowRowTotal: Boolean;
begin
  Result := RowTotalMemos[0].Visible;
end;

procedure TfrxCustomCrossView.SetShowColumnTotal(const Value: Boolean);
begin
  ColumnTotalMemos[0].Visible := Value;
end;

procedure TfrxCustomCrossView.SetShowRowTotal(const Value: Boolean);
begin
  RowTotalMemos[0].Visible := Value;
end;

procedure TfrxCustomCrossView.SetCellLevels(const Value: Integer);
begin
  FCellLevels := Value;
end;

procedure TfrxCustomCrossView.SetColumnLevels(const Value: Integer);
begin
  FColumnLevels := Value;
end;

procedure TfrxCustomCrossView.SetRowLevels(const Value: Integer);
begin
  FRowLevels := Value;
end;

procedure TfrxCustomCrossView.SetDotMatrix(const Value: Boolean);
begin
  FDotMatrix := Value;
  FMatrix.InitMemos(Value);
  if FDotMatrix then
  begin
    FGapX := 0;
    FGapY := 0;
  end;
end;

procedure TfrxCustomCrossView.Draw(Canvas: TCanvas; ScaleX, ScaleY,
  OffsetX, OffsetY: Extended);
begin
  inherited;
  with Canvas do
  begin
    Font.Assign(Self.Font);
    TextOut(FX + 2, FY + 2, Name);
  end;
end;

procedure TfrxCustomCrossView.BeginMatrix;
begin
  FMatrix.MaxWidth := FMaxWidth;
  FMatrix.MinWidth := FMinWidth;
  FMatrix.DefHeight := FDefHeight;
  FMatrix.GapX := FGapX;
  FMatrix.GapY := FGapY;
  FMatrix.Init(FRowLevels, FColumnLevels, FCellLevels);
  FMatrix.ColumnHeader.Visible := FShowColumnHeader;
  FMatrix.RowHeader.Visible := FShowRowHeader;
end;

procedure TfrxCustomCrossView.AddValue(const Rows, Columns, Cells: array of Variant);
begin
  if not IsCrossValid then
    raise Exception.Create('Cross-tab is not valid'); 
  FMatrix.AddValue(Rows, Columns, Cells);
end;

procedure TfrxCustomCrossView.EndMatrix;
begin
  FMatrix.CreateHeaders;
  FMatrix.CalcTotals;
  FMatrix.CalcBounds;
end;

procedure TfrxCustomCrossView.FillMatrix;
begin
end;

function TfrxCustomCrossView.ColCount: Integer;
begin
  Result := FMatrix.ColCount;
end;

function TfrxCustomCrossView.RowCount: Integer;
begin
  Result := FMatrix.RowCount;
end;

function TfrxCustomCrossView.IsCrossValid: Boolean;
begin
  Result := True;
end;

function TfrxCustomCrossView.IsGrandTotalColumn(Index: Integer): Boolean;
begin
  Result := FMatrix.IsGrandTotalColumn(Index);
end;

function TfrxCustomCrossView.IsGrandTotalRow(Index: Integer): Boolean;
begin
  Result := FMatrix.IsGrandTotalRow(Index);
end;

function TfrxCustomCrossView.IsTotalColumn(Index: Integer): Boolean;
begin
  Result := FMatrix.IsTotalColumn(Index);
end;

function TfrxCustomCrossView.IsTotalRow(Index: Integer): Boolean;
begin
  Result := FMatrix.IsTotalRow(Index);
end;

function TfrxCustomCrossView.ColumnHeaderHeight: Extended;
begin
  Result := FMatrix.ColumnHeader.Height;
  if FMatrix.NoColumns then
    Result := 0;
end;

function TfrxCustomCrossView.RowHeaderWidth: Extended;
begin
  Result := FMatrix.RowHeader.Width;
  if FMatrix.NoRows then
    Result := 0;
end;

procedure TfrxCustomCrossView.DoCalcHeight(Row: Integer; var Height: Extended);
var
  v: Variant;
begin
  if FOnCalcHeight <> '' then
  begin
    v := VarArrayOf([Row, FMatrix.GetRowIndexes(Row), Height]);
    if Report <> nil then
      Report.DoParamEvent(FOnCalcHeight, v);
    Height := v[2];
  end;
  if Assigned(FOnBeforeCalcHeight) then
    FOnBeforeCalcHeight(Row, FMatrix.GetRowIndexes(Row), Height);
end;

procedure TfrxCustomCrossView.DoCalcWidth(Column: Integer; var Width: Extended);
var
  v: Variant;
begin
  if FOnCalcWidth <> '' then
  begin
    v := VarArrayOf([Column, FMatrix.GetColumnIndexes(Column), Width]);
    if Report <> nil then
      Report.DoParamEvent(FOnCalcWidth, v);
    Width := v[2];
  end;
  if Assigned(FOnBeforeCalcWidth) then
    FOnBeforeCalcWidth(Column, FMatrix.GetColumnIndexes(Column), Width);
end;

procedure TfrxCustomCrossView.DoOnCell(Memo: TfrxCustomMemoView;
  Row, Column, Cell: Integer; const Value: Variant);
var
  v: Variant;
begin
  if FOnPrintCell <> '' then
  begin
    v := VarArrayOf([Integer(Memo), Row, Column, Cell, FMatrix.GetRowIndexes(Row),
      FMatrix.GetColumnIndexes(Column), Value]);
    if Report <> nil then
      Report.DoParamEvent(FOnPrintCell, v);
  end;
  if Assigned(FOnBeforePrintCell) then
    FOnBeforePrintCell(Memo, Row, Column, Cell, FMatrix.GetRowIndexes(Row),
      FMatrix.GetColumnIndexes(Column), Value);
end;

procedure TfrxCustomCrossView.DoOnColumnHeader(Memo: TfrxCustomMemoView;
  Header: TfrxCrossHeader);
var
  v: Variant;
begin
  if FOnPrintColumnHeader <> '' then
  begin
    v := VarArrayOf([Integer(Memo), Header.GetIndexes, Header.GetValues, Header.Value]);
    if Report <> nil then
      Report.DoParamEvent(FOnPrintColumnHeader, v);
  end;
  if Assigned(FOnBeforePrintColumnHeader) then
    FOnBeforePrintColumnHeader(Memo, Header.GetIndexes, Header.GetValues, Header.Value);
end;

procedure TfrxCustomCrossView.DoOnRowHeader(Memo: TfrxCustomMemoView;
  Header: TfrxCrossHeader);
var
  v: Variant;
begin
  if FOnPrintRowHeader <> '' then
  begin
    v := VarArrayOf([Integer(Memo), Header.GetIndexes, Header.GetValues, Header.Value]);
    if Report <> nil then
      Report.DoParamEvent(FOnPrintRowHeader, v);
  end;
  if Assigned(FOnBeforePrintRowHeader) then
    FOnBeforePrintRowHeader(Memo, Header.GetIndexes, Header.GetValues, Header.Value);
end;

procedure TfrxCustomCrossView.BeforePrint;
begin
  inherited;
  if FClearBeforePrint then
    BeginMatrix;
end;

procedure TfrxCustomCrossView.GetData;
begin
  inherited;
  Report.SetProgressMessage(frxResources.Get('crFillMx'));
  if IsCrossValid then
    FillMatrix;
  Report.SetProgressMessage(frxResources.Get('crBuildMx'));
  EndMatrix;
  RenderMatrix;
end;

procedure TfrxCustomCrossView.RenderMatrix;
var
  i, j, Page: Integer;
  CurY, AddWidth: Extended;
  Band: TfrxBand;
  ColumnItems: TList;

  function GetCellBand(RowIndex, ColumnIndex: Integer): TfrxBand;
  var
    i, j, iFrom, iTo: Integer;
    Cell: Variant;
    RowItems: TList;
    ColumnItem, RowItem: TfrxCrossHeader;
    m, Memo: TfrxCustomMemoView;
    RowSize, CellSize, CellOffs, LeftMargin, TopMargin: Extended;
  begin
    RowItems := FMatrix.RowHeader.TerminalItems;
    RowItem := RowItems[RowIndex];
    RowSize := RowItem.Bounds.Bottom / CellLevels;

    Result := TfrxNullBand.Create(Report);
    Result.Height := RowItem.Bounds.Bottom;

    iFrom := TfrxBand(FColumnBands[ColumnIndex]).Tag mod 65536;
    iTo := TfrxBand(FColumnBands[ColumnIndex]).Tag div 65536;
    LeftMargin := TfrxCrossHeader(ColumnItems[iFrom]).Bounds.Left;
    TopMargin := RowItem.Bounds.Top;

    for i := iFrom to iTo do
    begin
      ColumnItem := ColumnItems[i];

      CellOffs := 0;
      for j := 0 to CellLevels - 1 do
      begin
        Cell := FMatrix.GetValue(RowIndex, i, j);

        { which memo to use? }
        if RowItem.IsTotal then
          m := RowItem.Memo
        else if ColumnItem.IsTotal then
          m := ColumnItem.Memo
        else
          m := CellMemos[j];

        Memo := CreateMemo(Result);
        Memo.Assign(m);
        SetupOriginalComponent(Memo, m);
        if Cell <> Null then
          THackMemoView(Memo).Value := Cell else
          THackMemoView(Memo).Value := 0;

        Memo.Text := Memo.FormatData(Cell, CellMemos[j].DisplayFormat);
        Memo.Rotation := 0;
        Memo.HAlign := CellMemos[j].HAlign;