ppchrtdp.pas

pasa人力资源考勤管理系统

{------------------------------------------------------------------------------}
{ TppCustomDBChart.GetSeriesForDataPipeline }

procedure TppCustomDBChart.GetSeriesForDataPipeline(aDataPipeline: TppDataPipeline; aSeriesList: TChartSeriesList);
var
  liIndex: Longint;
  lSeries: TChartSeries;
begin

  aSeriesList.Clear;

  for liIndex := 0 to SeriesCount - 1 do
    begin
      lSeries := Series[liIndex];

      if (lSeries.DataSource = aDataPipeline) and
         (lSeries.MandatoryValueList.ValueSource <> '') then
        aSeriesList.Add(lSeries);

    end;

end; {procedure, GetSeriesForDataPipeline}

{------------------------------------------------------------------------------}
{ TppCustomDBChart.RefreshDataPipeline }

procedure TppCustomDBChart.RefreshDataPipeline(aDataPipeline: TppDataPipeline);
var
  lSaveCursor: TCursor;
  liIndex: Integer;
  lSeriesList: TChartSeriesList;
  lSeries: TChartSeries;
  lbTraverseAllData: Boolean;
begin

  if not(aDataPipeline.Active) then  Exit;

  if FRefreshingData then Exit;

  FRefreshingData := True;

  lSeriesList := TChartSeriesList.Create;
  lbTraverseAllData := True;

  try
    GetSeriesForDataPipeline(aDataPipeline, lSeriesList);

    if (lSeriesList.Count > 0) then
      begin
        lSaveCursor := Screen.Cursor;

        if FShowGlassCursor then
          Screen.Cursor := crHourGlass;

        try
          {clear series points}
          for liIndex := 0 to lSeriesList.Count - 1 do
            lSeriesList[liIndex].Clear;

          {convert data to series points}
          if (lbTraverseAllData) then
            TraverseDataPipeline(aDataPipeline, lSeriesList)

          else
            begin
              for liIndex := 0 to lSeriesList.Count - 1 do
                begin
{$IFDEF Tee50}
                  lSeries := lSeriesList[liIndex];
{$ELSE}
                  lSeries := lSeriesList.Series[liIndex];
{$ENDIF}

                  RecordToPoint(aDataPipeline, lSeries);
                end;
            end;

          {refresh any related series}
          for liIndex := 0 to lSeriesList.Count - 1 do
            TChartSeries(lSeriesList[liIndex]).RefreshSeries;

        finally
          if FShowGlassCursor then
            Screen.Cursor := lSaveCursor;
        end; {try-finally, process each record}

      end; {if, list series created}

  finally
    lSeriesList.Free;
    FRefreshingData := False;
  end; {try-finally, build list of series}

end; {procedure, RefreshDataPipeline}


{******************************************************************************
 *
 ** D P   T E E   C H A R T
 *
{******************************************************************************}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.Create }

constructor TppDPTeeChart.Create(aOwner: TComponent);
begin

  inherited Create(aOwner);

  FDataPipeList := TList.Create;

end; {constructor, Create}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.Destroy }

destructor TppDPTeeChart.Destroy;
begin

  FDataPipeList.Free;

  inherited Destroy;

end; {destructor, Destroy}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.Notify }

procedure TppDPTeeChart.Notify(aCommunicator: TppCommunicator; aOperation: TppOperationType);
var
  liIndex: Integer;
  lSeries: TChartSeries;
begin

  inherited Notify(aCommunicator, aOperation);

  case aOperation of

    ppopRemove:
      begin
        {delete pipeline from list}
        liIndex := FDataPipeList.IndexOf(aCommunicator);

        if (liIndex = -1) then Exit;

        FDataPipeList.Delete(liIndex);

        if (csDestroying in ComponentState) then Exit;

        {clear DataSource}
        for liIndex := 0 to Chart.SeriesCount - 1 do
          begin
            lSeries := Chart.Series[liIndex];

            if (lSeries.DataSource = aCommunicator) then
             lSeries.DataSource := nil;
          end;

     {   TppDPTeeChartControl(Chart).RefreshData;}

        {repaint control}
        InvalidateDesignControl;

      end;

    ppopActiveChange:
      if (pppcDesigning in DesignState) and not(Printing) and not(csDestroying in ComponentState)
          and not TppDPTeeChartControl(Chart).FRefreshingData then

           {repaint control}
          InvalidateDesignControl;


   {the following code caused problems if 2 Charts were connected to the same
    datapipeline. This code is only used at design-time. The user can manually refresh
    the chart by selecting the refresh data menu command.}
   {ppopDataChange:

      if (pppcDesigning in DesignState) and not(Printing) and not(csDestroying in ComponentState)
          and not TppDPTeeChartControl(Chart).FRefreshingData then
        begin
          TppDPTeeChartControl(Chart).RefreshData;

          {repaint control}
     {     InvalidateDesignControl;

        end;}

  end;


end; {procedure, Notify}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.Loaded }

procedure TppDPTeeChart.Loaded;
begin


  UpdateDataPipeList;

  {TppDPTeeChartControl(Chart).RefreshData;}

  {repaint control}
 { InvalidateDesignControl;}

  inherited Loaded;

end; {procedure, Loaded}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.PropertiesToDrawCommand }

procedure TppDPTeeChart.PropertiesToDrawCommand(aDrawCommand: TppDrawCommand);
begin

  UpdateDataPipeList;

  TppDPTeeChartControl(Chart).RefreshData;

  inherited  PropertiesToDrawCommand(aDrawCommand);


end; {procedure, PropertiesToDrawCommand}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.PaintDesignControl}

procedure TppDPTeeChart.PaintDesignControl(aCanvas: TCanvas);
begin
  if TppDPTeeChartControl(Chart).RefreshingData then Exit;

  inherited PaintDesignControl(aCanvas);

end; {procedure, PaintDesignControl}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.GetDataPipelines }

procedure TppDPTeeChart.GetDataPipelines(aDataPipelines: TList);
var
  liIndex: Integer;
  lDataPipeline: TppDataPipeline;
begin

  for liIndex := 0 to FDataPipeList.Count-1 do
    begin
      lDataPipeline := FDataPipeList[liIndex];
      if (aDataPipelines.IndexOf(DataPipeline) = -1) then
        aDataPipelines.Add(lDataPipeline);
    end;

end; {procedure, GetDataPipelines}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.UpdateDataPipeList }

procedure TppDPTeeChart.UpdateDataPipeList;
var
  liIndex: Longint;
  lSeries: TChartSeries;
  lDataPipeline: TppDataPipeline;
begin

  for liIndex := 0 to FDataPipeList.Count - 1 do
    TppDataPipeline(FDataPipeList[liIndex]).RemoveNotify(Self);

  FDataPipeList.Clear;

  if (Chart = nil) then Exit;

  for liIndex := 0 to Chart.SeriesCount - 1 do
    begin
      lSeries := Chart.Series[liIndex];

      if (lSeries.DataSource <> nil) and (lSeries.DataSource is TppDataPipeline) then
        begin
          lDataPipeline := TppDataPipeline(lSeries.DataSource);

          if (FDataPipeList.IndexOf(lDataPipeline) = -1) then
            begin
              lDataPipeline.AddNotify(Self);

              FDataPipeList.Add(lDataPipeline);
            end;
        end;

    end;

  TppDPTeeChartControl(Chart).DataPipeList := FDataPipeList;

end; {procedure, UpdateDataPipeList}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.CreateChart }

procedure TppDPTeeChart.CreateChart(var aChart: TCustomChart);
begin

  {create & configure tee chart control}

 {note: create with a nil owner and then insert into the Owner
         at the bottom of this procedure - this avoids D5 lockup}

  aChart := TppDPTeeChartControl.Create(nil);

  TppDPTeeChartControl(aChart).StreamingParent := Self;

  {use global parent window as the parent}
  aChart.Parent := ppParentWnd;

  aChart.Name := GetValidName(aChart);

  aChart.Title.Text.Clear;
  aChart.Title.Text.Add('Chart');
  aChart.Foot.Font.Color := clRed;
  aChart.Foot.Font.Style :=[fsItalic];
  aChart.Color := clWhite;
  aChart.BevelOuter := bvNone;
  aChart.BufferedDisplay := False;


  if Owner <> nil then
    Owner.InsertComponent(aChart);
  

end; {procedure, CreateChart}

{$IFDEF Tee50}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.Edit }

procedure TppDPTeeChart.Edit;
var
  lProc: TOnCreateEditSeries;
begin

  lProc := TeeEdiSeri.InternalOnCreateEditSeries;

  TeeEdiSeri.InternalOnCreateEditSeries := ppChDPEdDlg.OnCreateEditDBChart;

  inherited Edit;

  TeeEdiSeri.InternalOnCreateEditSeries := lProc;

  UpdateDataPipeList;

 { TppDPTeeChartControl(Chart).RefreshData;}

  {repaint control}
  InvalidateDesignControl;

end; {procedure, Edit}

{$ELSE}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.Edit }

procedure TppDPTeeChart.Edit;
var
  lProc: TOnCreateEditSeries;
begin

  lProc := IEditCha.InternalOnCreateEditSeries;

  IEditCha.InternalOnCreateEditSeries := ppChDPEd.OnCreateEditDBChart;

  inherited Edit;

  IEditCha.InternalOnCreateEditSeries := lProc;

  UpdateDataPipeList;

 { TppDPTeeChartControl(Chart).RefreshData;}

  {repaint control}
  InvalidateDesignControl;

end; {procedure, Edit}

{$ENDIF}


{------------------------------------------------------------------------------}
{ TppDPTeeChart.CreatePopupMenu }

procedure TppDPTeeChart.CreatePopupMenu(aOwner: TComponent; var aPopupMenu: TppPopupMenu);
begin

  inherited CreatePopupMenu(aOwner, aPopupMenu);

  {paramters: GroupIndex, Name, Caption, StringId}
  aPopupMenu.AddItem(25, 'RefreshData', '',  497);

end; {procedure, CreatePopupMenu}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.PopupMenuClick }

procedure TppDPTeeChart.PopupMenuClick(Sender: TObject);
begin

  inherited PopupMenuClick(Sender);

  {assign menu item event handlers}
  TppPopupMenu(Sender).ItemByName('RefreshData').OnClick  := RefreshDataMenuClick;

end; {procedure, PopupMenuClick}

{------------------------------------------------------------------------------}
{ TppDPTeeChart.RefreshDataMenuClick }

procedure TppDPTeeChart.RefreshDataMenuClick(Sender: TObject);
begin

{  TppDPTeeChartControl(Chart).RefreshData;}

  {repaint control}
  InvalidateDesignControl;

end; {procedure, RefreshDataMenuClick}

{******************************************************************************
 *
 ** D A T A   P I P E   T E E   C H A R T   C O N T R O L
 *
{******************************************************************************}

{------------------------------------------------------------------------------}
{ TppDPTeeChartControl.Create }

constructor TppDPTeeChartControl.Create(aOwner: TComponent);
begin
  inherited Create(aOwner);

  FStreamingParent := nil;

end; {constructor, Create}

{------------------------------------------------------------------------------}
{ TppDPTeeChartControl.Destroy }

destructor TppDPTeeChartControl.Destroy;
begin

  {remove from parent}
  SetStreamingParent(nil);


  inherited Destroy;

end; {destructor, Destroy}

{------------------------------------------------------------------------------}
{ TppDPTeeChartControl.SetStreamingParent }

procedure TppDPTeeChartControl.SetStreamingParent(aParent: TComponent);
begin

  if (FStreamingParent <> nil) and (FStreamingParent is TppCustomTeeChart) then
    TppCustomTeeChart(FStreamingParent).SetChartProperty(nil);

  FStreamingParent := aParent;

  if (FStreamingParent <> nil) and (FStreamingParent is TppCustomTeeChart) then
    TppCustomTeeChart(FStreamingParent).SetChartProperty(Self);

end; {procedure, SetStreamingParent}

{------------------------------------------------------------------------------}
{ TppDPTeeChartControl.HasParent }

function TppDPTeeChartControl.HasParent: Boolean;
begin
  Result := True;
end; {function, HasParent}

{------------------------------------------------------------------------------}
{ TppDPTeeChartControl.GetParentComponent - required method for Components with HasParent = True }

function TppDPTeeChartControl.GetParentComponent: TComponent;
begin
  Result := FStreamingParent;
end; {function, GetParentComponent}


{------------------------------------------------------------------------------}
{ TppDPTeeChartControl.SetParentComponent - required method for Components with HasParent = True }

procedure TppDPTeeChartControl.SetParentComponent(Value: TComponent);
begin
  if (Value is TppCustomTeeChart) then
    SetStreamingParent(Value);
end;

{------------------------------------------------------------------------------}
{ TppDPTeeChartControl.ReadState }

procedure TppDPTeeChartControl.ReadState(Reader: TReader);
begin

  inherited ReadState(Reader);

  {use global parent window as the parent}
  Parent := ppParentWnd;

end;

{******************************************************************************
 *
 ** I N I T I A L I Z A T I O N   /   F I N A L I Z A T I O N
 *
{******************************************************************************}

initialization

  RegisterClasses([TppDPTeeChart, TppDPTeeChartControl]);

  ppRegisterComponent(TppDPTeeChart, 'Data Components', 6, 463, '', 0);

finalization

  ppUnRegisterComponent(TppDPTeeChart);

end.