ezdims.pas

很管用的GIS控件

          Vect2.Assign( TextEnt.Points );
          Delta := FTextHeight * 0.20;
          Vect2[0] := Point2d( Vect2[0].X - Delta, Vect2[0].Y + Delta );
          Vect2[1] := Point2d( Vect2[1].X - Delta, Vect2[1].Y - Delta );
          Vect2[2] := Point2d( Vect2[2].X + Delta, Vect2[2].Y - Delta );
          Vect2[3] := Point2d( Vect2[3].X + Delta, Vect2[3].Y + Delta );
          Vect2[4] := Vect2[0];
          If VectIntersect( textLine.Points, Vect2, Vect1, true ) And ( Vect1.Count = 2 ) Then
          Begin
            If Dist2d( textLine.Points[0], Vect1[0] ) < Dist2d( textLine.Points[0], Vect1[1] ) Then
            Begin
              p1 := Vect1[0];
              p2 := Vect1[1];
            End
            Else
            Begin
              p2 := Vect1[1];
              p1 := Vect1[0];
            End;
            p0 := textLine.Points[0];
            p3 := textLine.Points[1];
            With textLine.Points Do
            Begin
              Clear;
              Add( p0 );
              Add( p1 );
              Add( p2 );
              Add( p3 );
              Parts.Add( 0 );
              Parts.Add( 2 );
            End;
            TextLine2Text.Points[1] := TextLine2Text.Points[0];
          End;
        Finally
          Vect1.Free;
          Vect2.Free;
        End;
      End;
    End
    Else
    Begin
      IntersVect := TEzVector.Create( 2 );
      Vect1 := TEzVector.Create( Points.Count );
      Vect2 := TEzVector.Create( 2 );
      Try
        Vect1.Assign( Points );
        Delta := FTextHeight * 0.20;
        Vect1[0] := Point2d( Vect1[0].X - Delta, Vect1[0].Y + Delta );
        Vect1[1] := Point2d( Vect1[1].X - Delta, Vect1[1].Y - Delta );
        Vect1[2] := Point2d( Vect1[2].X + Delta, Vect1[2].Y - Delta );
        Vect1[3] := Point2d( Vect1[3].X + Delta, Vect1[3].Y + Delta );
        Vect1[4] := Vect1[0];
        Vect2.Add( MidPoint );
        Vect2.Add( Point2d( ( Points[0].X + Points[3].X ) / 2, ( Points[0].Y + Points[1].Y ) / 2 ) );
        If EzLib.VectIntersect( Vect1, Vect2, IntersVect, true ) Then
        Begin
          TextLine2Text.Points[1] := IntersVect[0];
        End;
      Finally
        IntersVect.Free;
        Vect1.Free;
        Vect2.Free;
      End;
    End;
  End;

  // left line
  If Abs( BaseLineNoRot[0].Y - TextCoordY ) < FTextHeight Then
  Begin
    LeftLine.Points[0] := Point2d( textLineNoRot[0].X, textLineNoRot[0].Y + FTextHeight / 2 );
    LeftLine.Points[1] := Point2d( textLineNoRot[0].X, textLineNoRot[0].Y - FTextHeight / 2 );
  End
  Else
  Begin
    If textCoordY > BaseLineNoRot[0].Y Then
      TmpHeight := FTextHeight / 2
    Else
      TmpHeight := -FTextHeight / 2;
    LeftLine.Points[0] := BaseLineNoRot[0];
    LeftLine.Points[1] := Point2d( BaseLineNoRot[0].X, textCoordY + TmpHeight );
    If Abs( BaseLineNoRot[0].Y - TextCoordY ) < FTextHeight Then
    Begin
      LeftLine.Points[0] := Point2d( BaseLineNoRot[0].X, BaseLineNoRot[0].Y - TmpHeight );
      LeftLine.Points[1] := Point2d( BaseLineNoRot[0].X, BaseLineNoRot[0].Y + TmpHeight );
    End;
  End;
  // rotate the line
  LeftLine.Points[0] := TransformPoint2d( LeftLine.Points[0], M );
  LeftLine.Points[1] := TransformPoint2d( LeftLine.Points[1], M );

  // right line
  If Abs( BaseLineNoRot[1].Y - TextCoordY ) < FTextHeight Then
  Begin
    RightLine.Points[0] := Point2d( BaseLineNoRot[1].X, textCoordY + FTextHeight / 2 );
    RightLine.Points[1] := Point2d( BaseLineNoRot[1].X, textCoordY - FTextHeight / 2 );
  End
  Else
  Begin
    If TextCoordY > BaseLineNoRot[1].Y Then
      TmpHeight := FTextHeight / 2
    Else
      TmpHeight := -FTextHeight / 2;
    RightLine.Points[0] := BaseLineNoRot[1];
    RightLine.Points[1] := Point2d( BaseLineNoRot[1].X, TextCoordY + TmpHeight );
    If Abs( BaseLineNoRot[1].Y - TextCoordY ) < FTextHeight Then
    Begin
      RightLine.Points[0] := Point2d( BaseLineNoRot[1].X, BaseLineNoRot[1].Y - TmpHeight );
      RightLine.Points[1] := Point2d( BaseLineNoRot[1].X, BaseLineNoRot[1].Y + TmpHeight );
    End;
  End;
  // rotate the line
  RightLine.Points[0] := TransformPoint2d( RightLine.Points[0], M );
  RightLine.Points[1] := TransformPoint2d( RightLine.Points[1], M );

  OuterArrows := false;
  If lineDist <= ( TEzFittedVectorText( TextEnt ).Width + ArrowLength * 2 ) Then
  Begin
    OuterArrows := true;
    Delta := ArrowLength * 2;
    textLineNoRot[0] := Point2d( textLineNoRot[0].X - Delta, textLineNoRot[0].Y );
    textLineNoRot[1] := Point2d( textLineNoRot[1].X + Delta, textLineNoRot[1].Y );
    TextLine.Points[0] := TransformPoint2d( textLineNoRot[0], M );
    TextLine.Points[TextLine.Points.Count - 1] := TransformPoint2d( textLineNoRot[1], M );
  End;

  If OuterArrows Then
    Delta := -ArrowLength
  Else
    Delta := ArrowLength;

  // left arrow
  ArrowPt := Point2d( BaseLineNoRot[0].X, TextCoordY );
  With LeftArrow Do
  Begin
    Points[0] := ArrowPt;
    Points[1] := Point2d( ArrowPt.X + Delta, ArrowPt.Y + ArrowHeight / 2 );
    Points[2] := Point2d( ArrowPt.X + Delta, ArrowPt.Y - ArrowHeight / 2 );
    Points[3] := ArrowPt;
  End;
  // rotate the arrow
  For I := 0 To LeftArrow.Points.Count - 1 Do
    LeftArrow.Points[I] := TransformPoint2d( LeftArrow.Points[I], M );

  // right arrow
  ArrowPt := Point2d( BaseLineNoRot[1].X, TextCoordY );
  With RightArrow Do
  Begin
    Points[0] := ArrowPt;
    Points[1] := Point2d( ArrowPt.X - Delta, ArrowPt.Y + ArrowHeight / 2 );
    Points[2] := Point2d( ArrowPt.X - Delta, ArrowPt.Y - ArrowHeight / 2 );
    Points[3] := ArrowPt;
  End;
  // rotate the arrow
  For I := 0 To RightArrow.Points.Count - 1 Do
    RightArrow.Points[I] := TransformPoint2d( RightArrow.Points[I], M );

End;

Procedure TEzDimParallel.Draw( Grapher: TEzGrapher;
  Canvas: TCanvas; Const Clip: TEzRect; DrawMode: TEzDrawMode; Data: Pointer = Nil );
Var
  i: Integer;
Begin
  For i := 0 To FEntities.Count - 1 Do
  Begin
    With TEzEntity( FEntities[i] ) Do
    Begin
      SetTransformMatrix( Self.GetTransformMatrix );
      Draw( Grapher, Canvas, Clip, DrawMode );
    End;
  End;
End;

Function TEzDimParallel.GetControlPoints(TransfPts: Boolean; Grapher: TEzGrapher=Nil): TEzVector;
Var
  textLine: Array[0..1] Of TEzPoint;
  M: TEzMatrix;
Begin
  Result := TEzVector.Create( 5 );
  textLine[0] := Point2d( Points[0].X, Points[0].Y + FTextLineDistanceApart );
  textLine[1] := Point2d( textLine[0].X + Dist2d( Points[0], Points[1] ), textLine[0].Y );
  M := Rotate2d( Angle2d( Points[0], Points[1] ), Points[0] );
  textLine[0] := TransformPoint2d( textLine[0], M );
  textLine[1] := TransformPoint2d( textLine[1], M );
  Result.Add( Points[0] );
  Result.Add( textLine[0] );
  Result.Add( Points[1] );
  Result.Add( textLine[1] );
  Result.Add( Points[2] );
End;

Procedure TEzDimParallel.UpdateControlPoint( Index: Integer;
  Const Value: TEzPoint; Grapher: TEzGrapher=Nil );
Var
  temp: TEzPoint;
Begin
  FPoints.DisableEvents := true;
  Try
    Case Index Of
      0: Points[0] := Value;
      1, 3:
        Begin
          temp := TransformPoint2d( Value, Rotate2d( -Angle2d( Points[0], Points[1] ), Points[0] ) );
          SetTextLineDistanceApart( temp.Y - Points[0].Y );
        End;
      2: Points[1] := Value;
      4: Points[2] := Value;
    End;
  Finally
    FPoints.DisableEvents := false;
  End;
  UpdateExtension;
End;

Procedure TEzDimParallel.LoadFromStream( Stream: TStream );
Begin
  If FPenTool = Nil Then
    FPenTool := TEzPenTool.Create;
  If FEntities = Nil Then
    FEntities := TList.Create;
  ClearEntities;
  FPoints.DisableEvents := true;
  Try
    Inherited LoadFromStream( Stream );
    With Stream Do
    Begin
      Read( FTextLineDistanceApart, sizeof( Double ) );
      FFontName := EzReadStrFromStream( stream );
      FPenTool.LoadFromStream( Stream );
      Read( FTextHeight, sizeof( FTextHeight ) );
      Read( FNumDecimals, sizeof( FNumDecimals ) );
    End;
    FPoints.CanGrow := False;
    FPoints.OnChange := UpdateExtension;
    FOriginalSize := StorageSize;
  Finally
    FPoints.DisableEvents := false;
  End;
  UpdateExtension;
End;

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

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

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

Procedure TEzDimParallel.SetTextLineDistanceApart( Const Value: Double );
Begin
  FTextLineDistanceApart := Value;
  UpdateExtension;
End;

Procedure TEzDimParallel.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 TEzDimParallel.GetBaseLineFrom: TEzPoint;
Begin
  Result := Points[0];
End;

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

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

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

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

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

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

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

Function TEzDimParallel.GetEntityID: TEzEntityID;
Begin
  result := idDimParallel;
End;

Function TEzDimParallel.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 TEzDimParallel.IsEqualTo(Entity: TEzEntity; IncludeAttribs: Boolean = False ): Boolean;
begin
  Result:= False;
  if ( Entity.EntityID <> idDimParallel ) Or Not FPoints.IsEqualTo( Entity.Points ) Or
     ( IncludeAttribs And (
         Not CompareMem( @FPenTool.FPenStyle,
                         @TEzDimParallel(Entity).FPenTool.FPenStyle,
                         SizeOf( TEzPenStyle ) ) Or
         (AnsiCompareText(FFontName, TEzDimParallel(Entity).FFontName) <> 0) Or
         (FTextHeight <> TEzDimParallel(Entity).FTextHeight) Or
         (FTextLineDistanceApart <> TEzDimParallel(Entity).FTextLineDistanceApart) ) ) Then Exit;
  Result:= True;
end;

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

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

function TEzDimParallel.GetTextHeight: Double;
begin
  Result := FTextHeight;
end;

function TEzDimParallel.GetTextLineDistanceApart: Double;
begin
  Result := FTextLineDistanceApart;
end;
{$ENDIF}

End.