iangularloggauge.pas

iocopm3.04源码,一套很好的工控开发工具

      BackGroundChange;
    end;
end;
//****************************************************************************************************************************************************
procedure TiAngularLogGauge.SetArcRangeDegrees(const Value: Integer);
begin
  if FArcRangeDegrees <> Value then
    begin
      FArcRangeDegrees := Value;
      if FArcRangeDegrees > 360 then FArcRangeDegrees := 360;
      BackGroundChange;
    end;
end;
//****************************************************************************************************************************************************
function TiAngularLogGauge.GetCenterPoint(Canvas: TCanvas): TPoint;
var
  ClientRect  : TRect;
  CenterPoint : TPoint;
  TempPoint   : TPoint;
  MinX, MaxX  : Double;
  MinY, MaxY  : Double;
  MaxRadius   : Integer;
begin
  ClientRect  := Rect(0, 0, Width, Height);
  CenterPoint := inherited GetCenterPoint(Canvas);

  MaxRadius := FArcRadius;
  MaxRadius := MaxRadius + TickMargin + TickMajorLength;
  if ShowTickLabels then MaxRadius := MaxRadius + TickLabelMargin;

  TempPoint := GetXYRadPoint(FArcStartDegrees, MaxRadius, Point(0,0));
  MaxX := TempPoint.x;
  MinX := TempPoint.x;
  MaxY := TempPoint.y;
  MinY := TempPoint.y;

  if (FArcStartDegrees >=   0) and ((FArcStartDegrees - FArcRangeDegrees) <=   0) then
    begin
      TempPoint := GetXYRadPoint(0, MaxRadius, Point(0,0));
      if TempPoint.x > MaxX then MaxX := TempPoint.x;
      if TempPoint.x < MinX then MinX := TempPoint.x;
      if TempPoint.y > MaxY then MaxY := TempPoint.y;
      if TempPoint.y < MinY then MinY := TempPoint.y;
    end;
  if (FArcStartDegrees >=  90) and ((FArcStartDegrees - FArcRangeDegrees) <=  90) then
    begin
      TempPoint := GetXYRadPoint(90, MaxRadius, Point(0,0));
      if TempPoint.x > MaxX then MaxX := TempPoint.x;
      if TempPoint.x < MinX then MinX := TempPoint.x;
      if TempPoint.y > MaxY then MaxY := TempPoint.y;
      if TempPoint.y < MinY then MinY := TempPoint.y;
    end;
  if (FArcStartDegrees >= 180) and ((FArcStartDegrees - FArcRangeDegrees) <= 180) then
    begin
      TempPoint := GetXYRadPoint(180, MaxRadius, Point(0,0));
      if TempPoint.x > MaxX then MaxX := TempPoint.x;
      if TempPoint.x < MinX then MinX := TempPoint.x;
      if TempPoint.y > MaxY then MaxY := TempPoint.y;
      if TempPoint.y < MinY then MinY := TempPoint.y;
    end;
  if (FArcStartDegrees >= 270) and ((FArcStartDegrees - FArcRangeDegrees) <= 270) then
    begin
      TempPoint := GetXYRadPoint(270, MaxRadius, Point(0,0));
      if TempPoint.x > MaxX then MaxX := TempPoint.x;
      if TempPoint.x < MinX then MinX := TempPoint.x;
      if TempPoint.y > MaxY then MaxY := TempPoint.y;
      if TempPoint.y < MinY then MinY := TempPoint.y;
    end;

  TempPoint := GetXYRadPoint(FArcStartDegrees - FArcRangeDegrees, MaxRadius , Point(0,0));
  if TempPoint.x > MaxX then MaxX := TempPoint.x;
  if TempPoint.x < MinX then MinX := TempPoint.x;
  if TempPoint.y > MaxY then MaxY := TempPoint.y;
  if TempPoint.y < MinY then MinY := TempPoint.y;

  Result := Point(CenterPoint.x - Round((MaxX + MinX)/2), CenterPoint.y - Round((MaxY + MinY)/2));

  FCenterPoint := Result;
end;
//****************************************************************************************************************************************************
function TiAngularLogGauge.PositionToDegrees(Value: Double): Double;
begin
  Result := FArcStartDegrees - FArcRangeDegrees * (Log10(Value) - Log10(PositionMin))/(Log10(PositionMax) - Log10(PositionMin));
end;
//****************************************************************************************************************************************************
procedure TiAngularLogGauge.iPaintTo(Canvas: TCanvas);
var
  CenterPoint : TPoint;
  x           : Integer;
begin
  CenterPoint := GetCenterPoint(Canvas);

  if CachedDrawing then
    begin
      if BackGroundChanged then
        begin
          CreateBackGroundBitmap;
          DrawBackGround(BackGroundBitmap.Canvas, BackGroundColor);
          DrawSections  (BackGroundBitmap.Canvas, CenterPoint);
          DrawArcRadius (BackGroundBitmap.Canvas, CenterPoint);
          DrawTicks     (BackGroundBitmap.Canvas, CenterPoint);
          ResetBackGroundChange;
        end;

      TransferBackGround(Canvas);

      DrawLabels    (Canvas, CenterPoint);
      DrawMinMax    (Canvas, CenterPoint);
      DrawLimits    (Canvas, CenterPoint);

      for x := 0 to PointerManager.Count - 1 do
        begin
          if not PointerManager.Items[x].Visible then Continue;
          DrawIndicator (Canvas, CenterPoint, PointerManager.Items[x]);
        end;

      DrawHub(Canvas, CenterPoint);
    end
  else
    begin
      DrawBackGround(Canvas, BackGroundColor);
      DrawSections  (Canvas, CenterPoint);
      DrawArcRadius (Canvas, CenterPoint);
      DrawTicks     (Canvas, CenterPoint);

      DrawLabels    (Canvas, CenterPoint);
      DrawMinMax    (Canvas, CenterPoint);
      DrawLimits    (Canvas, CenterPoint);

      for x := 0 to PointerManager.Count - 1 do
        begin
          if not PointerManager.Items[x].Visible then Continue;
          DrawIndicator (Canvas, CenterPoint, PointerManager.Items[x]);
        end;

      DrawHub(Canvas, CenterPoint);
    end;
end;
//****************************************************************************************************************************************************
procedure TiAngularLogGauge.DrawSections(Canvas: TCanvas; const OffsetPoint: TPoint);
var
  x              : Integer;
  LastStart      : Double;
  CurrentColor   : TColor;
  CurrentEnd     : Double;
  InnerRadius    : Integer;
  OuterRadius    : Integer;
begin
  LastStart   := PositionMin;
  InnerRadius := FArcRadius + TickMargin;
  OuterRadius := FArcRadius + TickMargin + TickMajorLength;

  for x := 1 to SectionCount do
    begin
      case x of
        1 :  begin CurrentColor := SectionColor1; CurrentEnd := SectionEnd1; end;
        2 :  begin CurrentColor := SectionColor2; CurrentEnd := SectionEnd2; end;
        3 :  begin CurrentColor := SectionColor3; CurrentEnd := SectionEnd3; end;
        4 :  begin CurrentColor := SectionColor4; CurrentEnd := SectionEnd4; end;
        else begin CurrentColor := SectionColor5; CurrentEnd := PositionMax; end;
      end;

      if CurrentEnd > PositionMax then CurrentEnd := PositionMax;
      if CurrentEnd < PositionMin then CurrentEnd := PositionMin;
      if CurrentEnd < LastStart   then CurrentEnd := PositionMax;
      if x = SectionCount         then CurrentEnd := PositionMax;

      ArcSegment(Canvas, PositionToDegrees(LastStart), PositionToDegrees(CurrentEnd), InnerRadius, OuterRadius, OffsetPoint, CurrentColor);

      LastStart := CurrentEnd;

      if CurrentEnd = FArcRangeDegrees then exit;
    end;
end;
//****************************************************************************************************************************************************
procedure TiAngularLogGauge.DrawArcRadius(Canvas: TCanvas; const OffsetPoint: TPoint);
var
  InnerRadius    : Integer;
  OuterRadius    : Integer;
begin
  InnerRadius := FArcRadius + TickMargin;
  OuterRadius := FArcRadius + TickMargin + TickMajorLength;
  if FShowInnerArcRadius then ArcSegment(Canvas, PositionToDegrees(PositionMin), PositionToDegrees(PositionMax), InnerRadius, InnerRadius, OffsetPoint, TickMajorColor);
  if FShowOuterArcRadius then ArcSegment(Canvas, PositionToDegrees(PositionMin), PositionToDegrees(PositionMax), OuterRadius, OuterRadius, OffsetPoint, TickMajorColor);
end;
//****************************************************************************************************************************************************
procedure TiAngularLogGauge.DrawTicks(Canvas: TCanvas; const OffsetPoint: TPoint);
var
  MajorCount     : Integer;
  OuterPoint     : TPoint;
  InnerPoint     : TPoint;
  MajorRadius1   : Double;
  MajorRadius2   : Double;
  MinorRadius1   : Double;
  MinorRadius2   : Double;
  TextRadius     : Double;
  TextPoint      : TPoint;
  TickValue      : Double;
  TextString     : String;
  x, y           : Integer;
  DegreeMajor    : Double;
  DegreeMinor    : Double;
  PositionMajor  : Double;
  PositionMinor  : Double;
begin
  if PositionMax = PositionMin then exit;

  with Canvas do
    begin
      MajorCount := Trunc(Log10(PositionMax) - Log10(PositionMin));

      Brush.Style := bsClear;

      MajorRadius1 := FArcRadius + TickMargin - 1;
      MajorRadius2 := FArcRadius + TickMargin + TickMajorLength;

      case TickMinorAlignment of
        itmnaInside  : begin
                         MinorRadius1 := MajorRadius1;
                         MinorRadius2 := MajorRadius1 + TickMinorLength;
                       end;
        itmnaCenter  : begin
                         MinorRadius1 := (MajorRadius1 + MajorRadius2)/2 - TickMinorLength/2;
                         MinorRadius2 := (MajorRadius1 + MajorRadius2)/2 + TickMinorLength/2;
                       end;
        itmnaOutside : begin
                         MinorRadius1 := MajorRadius2;
                         MinorRadius2 := MajorRadius2 - TickMinorLength;
                       end;
        else           begin
                         MinorRadius1 := 0;
                         MinorRadius2 := 0;
                       end;
      end;

      Font.Assign(TickLabelFont);

      for x := 0 to MajorCount do
        begin
          PositionMajor := PositionMin * Power(10, x);
          DegreeMajor   := PositionToDegrees(PositionMajor);
          //------------------------------------------------------------------------------------------------------------------------------------------
          Pen.Color  := TickMajorColor;
          OuterPoint := GetXYRadPoint(DegreeMajor, MajorRadius1, OffsetPoint);
          InnerPoint := GetXYRadPoint(DegreeMajor, MajorRadius2, OffsetPoint);
          Polyline([InnerPoint, OuterPoint]);
          //------------------------------------------------------------------------------------------------------------------------------------------
          Pen.Color := TickMinorColor;
          for y := 2 to 9 do
            begin
              if (PositionMin * Power(10, x) * y) > PositionMax then Break;
              PositionMinor := PositionMajor + PositionMajor*(y-1);
              DegreeMinor   := PositionToDegrees(PositionMinor);

              OuterPoint := GetXYRadPoint(DegreeMinor, MinorRadius1, OffsetPoint);
              InnerPoint := GetXYRadPoint(DegreeMinor, MinorRadius2, OffsetPoint);
              Polyline([InnerPoint, OuterPoint]);
            end;
          //------------------------------------------------------------------------------------------------------------------------------------------
          TickValue :=  PositionMin * Power(10, x);

          case FTickLabelStyle of
            illsValue      : TextString  := Trim(SysUtils.Format('%.' + IntToStr(TickLabelPrecision  ) + 'f', [TickValue]));
            illsScientific : TextString  := Trim(SysUtils.Format('%.' + IntToStr(TickLabelPrecision+1) + 'e', [TickValue]));
          end;

          if Assigned(OnCustomizeTickLabel) then TOnCustomizeTickLabel(OnCustomizeTickLabel)(Self, x, TextString);

          TextRadius  := MajorRadius2 + TickLabelMargin + 4;
          TextPoint   := GetXYRadPoint(DegreeMajor, TextRadius, OffsetPoint);

          TextOUt(TextPoint.x - TextWidth (TextString) div 2, TextPoint.y - TextHeight(TextString) div 2, TextString);
        end;
          //------------------------------------------------------------------------------------------------------------------------------------------
    end;
end;
//****************************************************************************************************************************************************
procedure TiAngularLogGauge.DrawHub(Canvas: TCanvas; const OffsetPoint: TPoint);
begin
  with Canvas do
    begin
      if FShowHub then
        begin
          Pen.Color   := FHubColor;
          Brush.Color := FHubColor;
          Ellipse(OffsetPoint.x + FHubSize div 2, OffsetPoint.y + FHubSize div 2, OffsetPoint.x - FHubSize div 2, OffsetPoint.y - FHubSize div 2);
        end;
    end;
end;
//****************************************************************************************************************************************************
procedure TiAngularLogGauge.DrawMinMax(Canvas: TCanvas; const OffsetPoint: TPoint);
begin
  if ShowMaxPointer then
    begin
      FMaxPointer.Position      := CurrentMax;
      FMaxPointer.Style         := ord(MinMaxPointerStyle);
      FMaxPointer.Margin        := MinMaxPointerMargin;
      FMaxPointer.Size          := MinMaxPointerSize;
      FMaxPointer.DrawScaleSide := False;
      FMaxPointer.Color         := MaxPointerColor;

      DrawIndicator(Canvas, OffsetPoint, FMaxPointer);
    end;

  if ShowMinPointer then
    begin
      FMinPointer.Position      := CurrentMin;
      FMinPointer.Style         := ord(MinMaxPointerStyle);
      FMinPointer.Margin        := MinMaxPointerMargin;