iangulargauge.pas

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

//****************************************************************************************************************************************************
procedure TiAngularGauge.DrawLimits(Canvas: TCanvas; const OffsetPoint: TPoint);
var
  x        : Integer;
  APointer : TiGaugePointer;
begin
  for x := 0 to LimitCount -1 do
    begin
      if LimitShowUpperPointer[x] then
        begin
          APointer := TiGaugePointer.Create(nil);
          try
            APointer.Position      := LimitUpperValue[x];
            APointer.Style         := ord(iagpsArrow);
            APointer.Margin        := LimitPointerMargin[x];
            APointer.Size          := LimitPointerSize[x];
            APointer.DrawScaleSide := LimitDrawScaleSide[x];
            APointer.Color         := LimitUpperPointerColor[x];

            DrawIndicator(Canvas, OffsetPoint, APointer);
          finally
            APointer.Free;
          end;
        end;

      if LimitShowLowerPointer[x] then
        begin
          APointer := TiGaugePointer.Create(nil);
          try
            APointer.Position      := LimitLowerValue[x];
            APointer.Style         := ord(iagpsArrow);
            APointer.Margin        := LimitPointerMargin[x];
            APointer.Size          := LimitPointerSize[x];
            APointer.DrawScaleSide := LimitDrawScaleSide[x];
            APointer.Color         := LimitLowerPointerColor[x];

            DrawIndicator(Canvas, OffsetPoint, APointer);
          finally
            APointer.Free;
          end;
        end;
    end;
end;
//****************************************************************************************************************************************************
procedure TiAngularGauge.DrawIndicator(Canvas: TCanvas; const OffsetPoint: TPoint; APointer: TiGaugePointer);
var
  PointerEndPoint  : TPoint;
  PointerBasePoint : TPoint;
  PointerDegress   : Double;
  Point1           : TPoint;
  Point2           : TPoint;
  OuterRadius      : Integer;
  InnerRadius      : Integer;
  PointArray       : Array[0..2] of TPoint;
  ARect            : TRect;
begin
  with Canvas, APointer do
    begin
      Brush.Style := bsSolid;
      Brush.Color := Color;
      Pen.Color   := Color;

      PointerDegress := PositionToDegrees(Position);

      OuterRadius := FArcRadius - Margin;
      InnerRadius := FArcRadius - Margin - Size;

      PointerEndPoint := GetXYRadPoint(PointerDegress, OuterRadius, OffsetPoint);

      case TiAngularGaugePointerStyle(Style) of
        iagpsArrowLine : begin
                           Polyline([OffsetPoint, PointerEndPoint]);
                           PointerBasePoint := GetXYRadPoint(PointerDegress, InnerRadius, OffsetPoint);
                           Point1 := GetXYRadPoint(PointerDegress + 90, Size/2, PointerBasePoint);
                           Point2 := GetXYRadPoint(PointerDegress - 90, Size/2, PointerBasePoint);
                           Polygon([Point1, Point2, PointerEndPoint]);

                           PointArray[0] := Point1;
                           PointArray[1] := Point2;
                           PointArray[2] := PointerEndPoint;
                           {$IFDEF iVCL}
                           APointer.Region := CreatePolygonRgn(PointArray, 3, ALTERNATE);
                           {$ENDIF}
                         end;
        iagpsArrow     : begin
                           if DrawScaleSide then
                             begin
                               OuterRadius := FArcRadius + Margin + Size;
                               InnerRadius := FArcRadius + Margin;
                               PointerEndPoint  := GetXYRadPoint(PointerDegress, InnerRadius, OffsetPoint);
                               PointerBasePoint := GetXYRadPoint(PointerDegress, OuterRadius, OffsetPoint);
                             end
                           else PointerBasePoint := GetXYRadPoint(PointerDegress, InnerRadius, OffsetPoint);

                           Point1 := GetXYRadPoint(PointerDegress + 90, Size/2, PointerBasePoint);
                           Point2 := GetXYRadPoint(PointerDegress - 90, Size/2, PointerBasePoint);
                           Polygon([Point1, Point2, PointerEndPoint]);

                           PointArray[0] := Point1;
                           PointArray[1] := Point2;
                           PointArray[2] := PointerEndPoint;
                           {$IFDEF iVCL}
                           APointer.Region := CreatePolygonRgn(PointArray, 3, ALTERNATE);
                           {$ENDIF}
                         end;
        iagpsLine      : begin
                           Polyline([OffsetPoint, PointerEndPoint]);

                           ARect := GetClickRect([PointerEndPoint], 8);
                           {$IFDEF iVCL}
                           APointer.Region := CreateRectRgn(ARect.Left, ARect.Top, ARect.Right, ARect.Bottom);
                           {$ENDIF}
                         end;
        iagpsTriangle  : begin
                           Polyline([OffsetPoint, PointerEndPoint]);
                           Point1 := GetXYRadPoint(PointerDegress + 90, Size/2, OffsetPoint);
                           Point2 := GetXYRadPoint(PointerDegress - 90, Size/2, OffsetPoint);
                           Polygon([Point1, Point2, PointerEndPoint]);

                           PointArray[0] := Point1;
                           PointArray[1] := Point2;
                           PointArray[2] := PointerEndPoint;
                           {$IFDEF iVCL}
                           APointer.Region := CreatePolygonRgn(PointArray, 3, ALTERNATE);
                           {$ENDIF}
                         end;
      end;
    end;
end;
//****************************************************************************************************************************************************
procedure TiAngularGauge.DrawLabels(Canvas: TCanvas; const CenterPoint: TPoint);
var
  TextString  : String;
  x, y        : Integer;
begin
  with Canvas do
    begin
      if FShowLabel1 then
        begin
          Font.Assign(FLabel1Font);
          Brush.Style := bsClear;
          TextString  := FLabel1Text;

          case FLabel1AlignVertical of
            iavCenter : y := FLabel1OffsetY + CenterPoint.y - TextHeight(TextString) div 2;
            iavBottom : y := FLabel1OffsetY + Height - TextHeight(TextString);
            else        y := FLabel1OffsetY + 0;
          end;

          case FLabel1AlignHorizontal of
            iahCenter : x := FLabel1OffsetX + CenterPoint.x - TextWidth(TextString) div 2;
            iahRight  : x := FLabel1OffsetX + Width - TextWidth(TextString);
            else        x := FLabel1OffsetX + 0;
          end;

          TextOut(x, y, TextString);
        end;

      if FShowLabel2 then
        begin
          Font.Assign(FLabel2Font);
          Brush.Style := bsClear;
          TextString  := FLabel2Text;

          case FLabel2AlignVertical of
            iavCenter : y := FLabel2OffsetY + CenterPoint.y - TextHeight(TextString) div 2;
            iavBottom : y := FLabel2OffsetY + Height - TextHeight(TextString);
            else        y := FLabel2OffsetY + 0;
          end;

          case FLabel2AlignHorizontal of
            iahCenter : x := FLabel2OffsetX + CenterPoint.x - TextWidth(TextString) div 2;
            iahRight  : x := FLabel2OffsetX + Width - TextWidth(TextString);
            else        x := FLabel2OffsetX + 0;
          end;

          TextOut(x, y, TextString);
        end;
  end;
end;
//****************************************************************************************************************************************************
procedure TiAngularGauge.iMouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var
  i : Integer;
begin
  if (Button = mbLeft) then
    begin
      if MinMaxUserCanMove then
        begin
          FMouseDownX := X;
          FMouseDownY := Y;
          if      ShowMinPointer {$IFDEF iVCL}and (FMinPointer.Region <> 0) and PtInRegion(FMinPointer.Region, X,Y){$ENDIF} then
            begin
              FMinPointer.MouseDown := True;
              FOldCurrentValue      := CurrentMin;
              FMouseDownDegrees     := RadToDeg(ArcTan2(Y-FCenterPoint.y,X-FCenterPoint.x));
            end
          else if ShowMaxPointer {$IFDEF iVCL}and (FMaxPointer.Region <> 0) and PtInRegion(FMaxPointer.Region, X,Y){$ENDIF} then
            begin
              FMaxPointer.MouseDown := True;
              FOldCurrentValue      := CurrentMax;
              FMouseDownDegrees     := RadToDeg(ArcTan2(Y-FCenterPoint.y,X-FCenterPoint.x));
            end;
          InvalidateChange;
        end;

      for i := 0 to PointerCount-1 do
        begin
          PointerManager.Items[i].MouseDown := True;
          if not PointerManager.Items[i].Visible then Continue;
          {$IFDEF iVCL}
          PointerManager.Items[i].MouseDown := PtInRegion(PointerManager.Items[i].Region, X, Y);
          {$ENDIF}
        end;
    end;
end;
//****************************************************************************************************************************************************
procedure TiAngularGauge.iMouseMove(Shift: TShiftState; X, Y: Integer);
var
  CurrentDegrees : Double;   
  DeltaAngle     : Double;
begin
  if not(FMaxPointer.MouseDown or FMinPointer.MouseDown) then Exit;

  CurrentDegrees  := RadToDeg(ArcTan2(Y-FCenterPoint.y,X-FCenterPoint.x));

  if -CurrentDegrees > FArcStartDegrees then CurrentDegrees := -FArcStartDegrees;

  DeltaAngle      := FMouseDownDegrees - CurrentDegrees;
  if DeltaAngle >  200 then DeltaAngle := DeltaAngle - 360;
   if DeltaAngle < -200 then DeltaAngle := DeltaAngle + 360;

  FMouseDownDegrees := CurrentDegrees;

  if FMaxPointer.MouseDown then
    begin
      if FReverseScale then
        CurrentMax := CurrentMax + DeltaAngle/FArcRangeDegrees*(PositionMax - PositionMin)
      else
        CurrentMax := CurrentMax - DeltaAngle/FArcRangeDegrees*(PositionMax - PositionMin);

      if CurrentMin > CurrentMax then CurrentMin := CurrentMax;
    end
  else if FMinPointer.MouseDown then
    begin
      if FReverseScale then
        CurrentMin := CurrentMin + DeltaAngle/FArcRangeDegrees*(PositionMax - PositionMin)
      else
        CurrentMin := CurrentMin - DeltaAngle/FArcRangeDegrees*(PositionMax - PositionMin);

      if CurrentMax < CurrentMin then CurrentMax := CurrentMin;
    end;
end;
//****************************************************************************************************************************************************
procedure TiAngularGauge.iMouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
var
  i : Integer;
begin
  FMinPointer.MouseDown := False;
  FMaxPointer.MouseDown := False;

  for i := 0 to PointerCount-1 do
    begin
      if not PointerManager.Items[i].Visible then Continue;
      if PointerManager.Items[i].MouseDown then
        begin
          {$IFDEF iVCL}
          if PtInRegion(PointerManager.Items[i].Region, X, Y) then if Assigned(OnClickPointer) then OnClickPointer(i);
          {$ENDIF}
        end;
    end;
end;
//****************************************************************************************************************************************************
function TiAngularGauge.GetPointerColor  : TColor;                    begin Result :=                            PointerManager.Items[0].Color; end;
function TiAngularGauge.GetPointerMargin : Integer;                   begin Result :=                            PointerManager.Items[0].Margin;end;
function TiAngularGauge.GetPointerSize   : Integer;                   begin Result :=                            PointerManager.Items[0].Size;  end;
function TiAngularGauge.GetPointerStyle  : TiAngularGaugePointerStyle;begin Result := TiAngularGaugePointerStyle(PointerManager.Items[0].Style);end;
//****************************************************************************************************************************************************
procedure TiAngularGauge.SetPointerMargin(const Value: Integer);                   begin PointerManager.Items[0].Margin := Value;     end;
procedure TiAngularGauge.SetPointerColor (const Value: TColor);                    begin PointerManager.Items[0].Color  := Value;     end;
procedure TiAngularGauge.SetPointerSize  (const Value: Integer);                   begin PointerManager.Items[0].Size   := Value;     end;
procedure TiAngularGauge.SetPointerStyle (const Value: TiAngularGaugePointerStyle);begin PointerManager.Items[0].Style  := ord(Value);end;
//****************************************************************************************************************************************************
function TiAngularGauge.GetPointersMargin(Index:Integer):Integer;                   begin Result:=PointerManager.Items[Index].Margin;                           end;
function TiAngularGauge.GetPointersStyle (Index:Integer):TiAngularGaugePointerStyle;begin Result:=TiAngularGaugePointerStyle(PointerManager.Items[Index].Style);end;
//****************************************************************************************************************************************************
procedure TiAngularGauge.SetPointersMargin(Index,         Value: Integer                  );begin PointerManager.Items[Index].Margin:=Value;     end;
procedure TiAngularGauge.SetPointersStyle (Index:Integer; Value:TiAngularGaugePointerStyle);begin PointerManager.Items[Index].Style :=ord(Value);end;
//****************************************************************************************************************************************************
end.