ezdims.pas

很管用的GIS控件

      Read( FNumDecimals, sizeof( FNumDecimals ) );
    End;
    FPoints.CanGrow := False;
    FPoints.OnChange := UpdateExtension;
    FOriginalSize := StorageSize;
  Finally
    FPoints.DisableEvents := false;
  End;
  UpdateExtension;
End;

Procedure TEzDimVertical.SaveToStream( Stream: TStream );
Begin
  Inherited SaveToStream( Stream );
  With Stream Do
  Begin
    EzWriteStrToStream( FFontName, stream );
    FPenTool.SaveToStream( Stream );
    Write( FTextHeight, sizeof( FTextHeight ) );
    Write( FNumDecimals, sizeof( FNumDecimals ) );
  End;
  FOriginalSize := StorageSize;
End;

Procedure TEzDimVertical.SetNumDecimals( Value: Integer );
Begin
  FNumDecimals := Value;
  UpdateExtension;
End;

Procedure TEzDimVertical.SetTextHeight( Const Value: Double );
Begin
  FTextHeight := Value;
  UpdateExtension;
End;

Procedure TEzDimVertical.SetTextLineX( Const Value: Double );
Begin
  Points[3] := Point2d( Value, 0 );
  UpdateExtension;
End;

Procedure TEzDimVertical.UpdateExtension;
Var
  i: integer;
  TmpR: TEzRect;
Begin
  If FPoints.DisableEvents then Exit;
  Calculate;
  FBox := INVALID_EXTENSION;
  For i := 0 To FEntities.Count - 1 Do
  Begin
    TmpR := TEzEntity( FEntities[i] ).FBox;
    FBox.Emin.X := dMin( FBox.Emin.X, TmpR.Emin.X );
    FBox.Emin.Y := dMin( FBox.Emin.Y, TmpR.Emin.Y );
    FBox.Emax.X := dMax( FBox.Emax.X, TmpR.Emax.X );
    FBox.Emax.Y := dMax( FBox.Emax.Y, TmpR.Emax.Y );
  End;
End;

Function TEzDimVertical.GetBaseLineFrom: TEzPoint;
Begin
  Result := Points[0];
End;

Function TEzDimVertical.GetBaseLineTo: TEzPoint;
Begin
  Result := Points[1];
End;

Function TEzDimVertical.GetTextBasePoint: TEzPoint;
Begin
  Result := Points[2]
End;

Function TEzDimVertical.GetTextLineX: Double;
Begin
  Result := Points[3].X;
End;

Procedure TEzDimVertical.SetBaseLineFrom( Const Value: TEzPoint );
Begin
  Points[0] := Value;
  UpdateExtension;
End;

Procedure TEzDimVertical.SetBaseLineTo( Const Value: TEzPoint );
Begin
  Points[1] := Value;
  UpdateExtension;
End;

Procedure TEzDimVertical.SetFontName( Const Value: String );
Begin
  FFontName := Value;
  UpdateExtension;
End;

Procedure TEzDimVertical.SetTextBasePoint( Const Value: TEzPoint );
Begin
  Points[2] := Value;
  UpdateExtension;
End;

Function TEzDimVertical.StorageSize: Integer;
Begin
  result := Length( FFontName );
End;

Function TEzDimVertical.GetEntityID: TEzEntityID;
Begin
  result := idDimVertical;
End;

Function TEzDimVertical.PointCode( Const Pt: TEzPoint; Const Aperture: Double;
  Var Distance: Double; SelectPickingInside: Boolean; UseDrawPoints: Boolean=True ): Integer;
Var
  I: Integer;
Begin
  Result := PICKED_NONE;
  If ( FEntities = Nil ) Or ( FEntities.Count = 0 ) Then
    Exit;
  For I := 0 To FEntities.Count - 1 Do
  Begin
    Result := TEzEntity( FEntities[I] ).PointCode( Pt, Aperture, Distance, SelectPickingInside, UseDrawPoints );
    If Result >= PICKED_INTERIOR Then Exit;
  End;
End;

function TEzDimVertical.IsEqualTo(Entity: TEzEntity; IncludeAttribs: Boolean = False ): Boolean;
begin
  Result:= False;
  if ( Entity.EntityID <> idDimVertical ) Or Not FPoints.IsEqualTo( Entity.Points ) Or
     ( IncludeAttribs And (
         Not CompareMem( @FPenTool.FPenStyle,
                         @TEzDimVertical(Entity).FPenTool.FPenStyle,
                         SizeOf( TEzPenStyle ) ) Or
         (AnsiCompareText(FFontName, TEzDimVertical(Entity).FFontName) <> 0) Or
         (FTextHeight <> TEzDimVertical(Entity).FTextHeight) ) ) Then Exit;
  Result:= True;
end;


{$IFDEF BCB}
function TEzDimVertical.GetFontName: String;
begin
  Result := FFontName;
end;

function TEzDimVertical.GetNumDecimals: Integer;
begin
  Result := FNumDecimals;
end;

function TEzDimVertical.GetTextHeight: Double;
begin
  Result := FTextHeight;
end;
{$ENDIF}

{ TEzDimParallel }

Constructor TEzDimParallel.CreateEntity( Const BaseLineFrom, BaseLineTo: TEzPoint;
  Const TextLineDistanceApart: Double );
Begin
  Inherited Create( 4 );

  FPoints.DisableEvents := true;
  FPoints.Add( BaseLineFrom );
  FPoints.Add( BaseLineTo );
  { when text base point is (MAXCOORD,MAXCOORD) then it must be recalculated }
  FPoints.Add( Point2d( MAXCOORD, MAXCOORD ) );
  FPoints.Add( Point2d( 0, TextLineDistanceApart ) );
  FPoints.DisableEvents := false;
  FPoints.CanGrow := false;

  UpdateExtension;
End;

Destructor TEzDimParallel.Destroy;
Begin
  FPenTool.Free;
  If FEntities <> Nil Then
  Begin
    ClearEntities;
    FEntities.Free;
  End;
  Inherited Destroy;
End;

procedure TEzDimParallel.Initialize;
begin
  FEntities := TList.Create;
  FPenTool := TEzPenTool.Create;
  With Ez_Preferences Do
  Begin
    FFontName := DefFontStyle.Name;
    FTextHeight := DefFontStyle.Height;
    FNumDecimals := NumDecimals;
    FPenTool.Assign( DefPenStyle );
  End;
  FPenTool.Style := 1;
end;

Function TEzDimParallel.BasicInfoAsString: string;
Begin
  Result:= Format(sDimParallelInfo, [BaseLineFrom.X,BaseLineFrom.Y,
    BaseLineTo.X,BaseLineTo.Y,TextLineDistanceApart]);
End;

Function TEzDimParallel.AttribsAsString: string;
Begin
  Result:= Format( sPenInfo, [Pentool.Style, Pentool.Color, Pentool.Width]) + CrLf +
    Format(sVectorFontInfo, [FontName]);
End;

Procedure TEzDimParallel.ClearEntities;
Var
  I: Integer;
Begin
  If FEntities = Nil Then
    exit;
  For I := 0 To FEntities.Count - 1 Do
    TEzEntity( FEntities[I] ).Free;
  FEntities.Clear;
End;

Function TEzDimParallel.IsTextOnLine: Boolean;
Var
  V: TEzVector;
Begin
  If EqualPoint2d( TextBasePoint, Point2d( MAXCOORD, MAXCOORD ) ) Then
  Begin
    Result := true;
    exit;
  End;
  V := TEzVector.Create( 2 );
  Try
    Result := VectIntersect( TEzEntity( FEntities[6] ).Points, TEzEntity( FEntities[0] ).Points, V, true );
  Finally
    V.Free;
  End;
End;

Procedure TEzDimParallel.Calculate;
Var
  temp, textCent, p0, p1, p2, p3: TEzPoint;
  textCoordY, TextDistApart, lineDist, lineAngle: Double;
  TextBasePoint: TEzPoint;
  ArrowHeight, ArrowLength, Delta: Double;
  ArrowPt, MidPoint, p: TEzPoint;
  TmpHeight: Double;
  OuterArrows: Boolean;
  BaseLine, baseLineNoRot, textLineNoRot: Array[0..1] Of TEzPoint;
  TmpEnt: TEzEntity;
  TextEnt: TEzEntity;
  TextLine: TEzEntity;
  LeftLine: TEzEntity;
  LeftArrow: TEzEntity;
  RightLine: TEzEntity;
  RightArrow: TEzEntity;
  TextLine2Text: TEzEntity;
  IntersVect, Vect1, Vect2: TEzVector;
  M: TEzMatrix;
  I: Integer;
Begin
  If FEntities = Nil Then
    FEntities := TList.Create;
  If FPenTool = Nil Then
    FPenTool := TEzPenTool.Create;
  p := NULL_POINT;
  If Points.Count = 0 Then
  Begin
    Points.Add( p );
    Points.Add( p );
    Points.Add( p );
  End;
  If FEntities.Count = 0 Then
  Begin
    // text line
    TmpEnt := TEzPolyLine.CreateEntity( [p, p] );
    TEzPolyLine( TmpEnt ).PenTool.Assign( FPenTool );
    FEntities.Add( TmpEnt );
    // line from center of text line to text entity
    TmpEnt := TEzPolyLine.CreateEntity( [p, p] );
    TEzPolyLine( TmpEnt ).PenTool.Assign( FPenTool );
    FEntities.Add( TmpEnt );
    // left arrow
    TmpEnt := TEzPolygon.CreateEntity( [p, p, p, p] );
    With TEzPolygon( TmpEnt ) Do
    Begin
      PenTool.Assign( Self.FPenTool );
      BrushTool.Pattern := 1;
      BrushTool.ForeColor := FPenTool.Color;
    End;
    FEntities.Add( TmpEnt );
    // right arrow
    TmpEnt := TEzPolygon.CreateEntity( [p, p, p, p] );
    With TEzPolygon( TmpEnt ) Do
    Begin
      PenTool.Assign( Self.FPenTool );
      BrushTool.Pattern := 1;
      BrushTool.ForeColor := FPenTool.Color;
    End;
    FEntities.Add( TmpEnt );
    // left line
    TmpEnt := TEzPolyLine.CreateEntity( [p, p] );
    TEzPolyLine( TmpEnt ).PenTool.Assign( Self.FPenTool );
    FEntities.Add( TmpEnt );
    // right line
    TmpEnt := TEzPolyLine.CreateEntity( [p, p] );
    TEzPolyLine( TmpEnt ).PenTool.Assign( Self.FPenTool );
    FEntities.Add( TmpEnt );
    // text entity
    TmpEnt := TEzFittedVectorText.CreateEntity( NULL_POINT, '', 1, -1, 0 );
    TEzFittedVectorText( TmpEnt ).FontName := self.FFontName;
    TEzFittedVectorText( TmpEnt ).FontColor := FPenTool.Color;
    FEntities.Add( TmpEnt );
  End;

  If EqualPoint2d( Points[0], Points[1] ) Then Exit;
  TextBasePoint := Points[2];
  TextDistApart := FTextLineDistanceApart;

  If Points[0].X > Points[1].X Then
  Begin
    Points.DisableEvents := true;
    temp := Points[0];
    Points[0] := Points[1];
    Points[1] := temp;
    Points.DisableEvents := false;
  End;
  BaseLine[0] := Points[0];
  BaseLine[1] := Points[1];

  TextLine := FEntities[0];
  TextLine2Text := FEntities[1];
  LeftArrow := FEntities[2];
  RightArrow := FEntities[3];
  LeftLine := FEntities[4];
  RightLine := FEntities[5];
  TextEnt := FEntities[6];

  // the text line
  ArrowHeight := FTextHeight / 2;
  ArrowLength := FTextHeight;
  lineDist := Dist2d( BaseLine[0], BaseLine[1] );
  lineAngle := Angle2d( BaseLine[0], BaseLine[1] );

  M := Rotate2d( lineAngle, BaseLine[0] );
  TextLine.Points[0] := TransformPoint2d( Point2d( BaseLine[0].X, BaseLine[0].Y + TextDistApart ), M );
  TextLine.Points[1] := TransformPoint2d( Point2d( BaseLine[0].X + lineDist, BaseLine[0].Y + TextDistApart ), M );

  baseLineNoRot[0] := baseLine[0];
  baseLineNoRot[1] := Point2d( baseLine[0].X + lineDist, baseLine[0].Y );

  textLineNoRot[0] := Point2d( baseLineNoRot[0].X, baseLineNoRot[0].Y + TextDistApart );
  textLineNoRot[1] := Point2d( baseLineNoRot[1].X, baseLineNoRot[1].Y + TextDistApart );

  textCoordY := baseLineNoRot[0].Y + TextDistApart;

  // the text
  With TEzFittedVectorText( TextEnt ) Do
  Begin
    BeginUpdate;
    Text := Format( '%.*n', [FNumDecimals, lineDist] );
    Height := FTextHeight;
    Width := -1; // force to calculate the text width
    MidPoint := Point2d( ( textLine.Points[0].X + textLine.Points[1].X ) / 2,
      ( textLine.Points[0].Y + textLine.Points[1].Y ) / 2 );
    If EqualPoint2d( TextBasePoint, Point2d( MAXCOORD, MAXCOORD ) ) Then
    Begin
      BasePoint := Point2d( MidPoint.X - Width / 2, MidPoint.Y + Height * ( 1.25 ) );
      Self.Points.DisableEvents := true;
      Self.Points[2] := BasePoint;
      Self.Points.DisableEvents := false;
    End
    Else
      BasePoint := TextBasePoint;
    EndUpdate;
    TextLine2Text.Points[0] := MidPoint;
    If Self.IsTextOnLine Then
    Begin
      Centroid( TextCent.X, TextCent.Y );
      temp := Perpend( textCent, textLine.Points[0], textLine.Points[1] );
      BasePoint := Point2d( temp.X - Width / 2, temp.Y + Height );
      TextLine2Text.Points[1] := temp;
      If ( temp.X > textLine.Points[0].X ) And ( temp.X < textLine.Points[1].X ) And
        ( temp.Y > ezlib.dMin( textLine.Points[0].Y, textLine.Points[1].Y ) ) And
        ( temp.Y < ezlib.dMax( textLine.Points[0].Y, textLine.Points[1].Y ) ) Then
      Begin
        // split into parts
        Vect1 := TEzVector.Create( 2 );
        Vect2 := TEzVector.Create( TextEnt.Points.Count );
        Try