ezentities.pas

很管用的GIS控件

    Origin: TEzPoint;
    Delta: TEzPoint;
    NumDashes: Integer;
    Dashes: Array[0..5] Of Double;
  End;

  TEzHatch = Class
  Private
    FName: String;
    FDescription: String;
    FList: TList;
    Function Get( Index: Integer ): TEzHatchData;
    Procedure Put( Index: Integer; Const Value: TEzHatchData );
  Public
    Constructor Create;
    Destructor Destroy; Override;
    Procedure Clear;
    Procedure Add( Const Hatch: TEzHatchData );
    Procedure DrawHatchTo( Vector: TEzVector; Const Clip, Extent: TEzRect;
      Grapher: TEzGrapher; Canvas: TCanvas; Color: TColor; Const Scale, Angle: Double;
      Const Matrix: TEzMatrix );
    Function Count: Integer;

    Property Name: String Read FName Write FName;
    Property Description: String Read FDescription Write FDescription;
    Property Items[Index: Integer]: TEzHatchData Read Get Write Put; Default;
  End;

  TEzHatchList = Class
  Private
    FList: TList;
    Function Get( Index: Integer ): TEzHatch;
    Procedure Put( Index: Integer; Value: TEzHatch );
  Public
    Constructor Create;
    Destructor Destroy; Override;
    Function Add: TEzHatch;
    Function Count: Integer;
    Procedure Clear;
    Procedure AddPATFile( Const FileName: String );

    Property Items[Index: Integer]: TEzHatch Read Get Write Put; Default;
  End;

Implementation

Uses
  Printers, EzBaseExpr, ezdims, EzPolyclip, EzSystem, EzGraphics, EzConsts,
  EzBasicCtrls, EzGisTiff ;


Const
  SYMBOL_ID = 8011;
  SYMBOL_VERSIONNUMBER = 100;

{------------------------------------------------------------------------------}
{                  Symbols                                                     }
{------------------------------------------------------------------------------}

{ TEzSymbol }

Constructor TEzSymbol.Create( Symbols: TEzSymbols );
Begin
  Inherited Create;
  FSymbols := Symbols;
  FEntities := TList.Create;
  UpdateExtension;
End;

Destructor TEzSymbol.Destroy;
Begin
  FDestroying := True;
  Clear;
  FEntities.Free;
  Inherited Destroy;
End;

Constructor TEzSymbol.CreateFromStream( Symbols: TEzSymbols; Stream: TStream );
Begin
  Inherited Create;
  FSymbols := Symbols;
  FEntities := TList.Create;
  LoadFromStream( Stream );
End;

Procedure TEzSymbol.Assign( Symbol: TEzSymbol );
Var
  I: Integer;
  TmpClass: TEzEntityClass;
  Ent, TmpEnt: TEzEntity;
Begin
  Clear;
  FName := Symbol.FName;
  For I := 0 To Symbol.Count - 1 Do
  Begin
    Ent := Symbol.Entities[I];
    TmpClass := GetClassFromID( Ent.EntityID );
    TmpEnt := TmpClass.Create( Ent.Points.Count );
    TmpEnt.Assign( Ent );
    FEntities.Add( TmpEnt );
  End;
  UpdateExtension;
End;

Procedure TEzSymbol.LoadFromStream( Stream: TStream );
Var
  I, N: Integer;
  EntityID: TEzEntityID;
  TmpClass: TEzEntityClass;
  TmpEntity: TEzEntity;
Begin
  Clear;
  With Stream Do
  Begin
    FName := EzReadStrFromStream( stream );
    Read( N, SizeOf( Integer ) );
    For I := 0 To N - 1 Do
    Begin
      Read( EntityID, SizeOf( TEzEntityID ) );
      TmpClass := GetClassFromID( EntityID );
      TmpEntity := TmpClass.Create( 2 );
      TmpEntity.LoadFromStream( Stream );
      FEntities.Add( TmpEntity );
    End;
    Read( FInsertionPoint, sizeof( TEzPoint ) );
  End;
  UpdateExtension;
End;

Procedure TEzSymbol.SaveToStream( Stream: TStream );
Var
  I, N: Integer;
  EntityID: TEzEntityID;
  TmpEnt: TEzEntity;
Begin
  N := FEntities.Count;
  With Stream Do
  Begin
    EzWriteStrToStream( FName, stream );
    Write( N, SizeOf( Integer ) );
    For I := 0 To N - 1 Do
    Begin
      TmpEnt := TEzEntity( FEntities[I] );
      EntityID := TmpEnt.EntityID;
      Write( EntityID, SizeOf( TEzEntityID ) );
      TmpEnt.SaveToStream( Stream );
    End;
    FInsertionPoint:= FCentroid;
    Write( FInsertionPoint, sizeof( TEzPoint ) );
  End;
End;

Procedure TEzSymbol.Clear;
Var
  I: Integer;
Begin
  If FEntities.Count = 0 Then Exit;
  For I := 0 To FEntities.Count - 1 Do
    TEzEntity( FEntities[I] ).Free;
  FEntities.Clear;
  If Not FDestroying Then
    UpdateExtension;
End;

Function TEzSymbol.Count: Integer;
Begin
  Result := FEntities.Count;
End;

Procedure TEzSymbol.Insert( Index: Integer; Item: TEzEntity );
Begin
  ConfigureSpecialItems( Item );
  If Item = Nil Then Exit;
  FEntities.Insert( Index, Item );
  UpdateExtension;
End;

Function TEzSymbol.Add( Item: TEzEntity ): Integer;
Begin
  Result := -1;
  ConfigureSpecialItems( Item );
  If Item = Nil Then Exit;
  Result := FEntities.Add( Item );
  UpdateExtension;
End;

Procedure TEzSymbol.ConfigureSpecialItems( Item: TEzEntity );
Begin
  With Item Do
    If EntityID = idPolygon Then
    Begin
      If Points.Parts.Count < 2 Then
      Begin
        If Not EzLib.EqualPoint2D( Points[0], Points[Points.Count - 1] ) Then
          Points.Add( Points[0] );
      End
      Else
      Begin
        // It is assumed only simple polygons will be added
      End;
    End;
End;

Procedure TEzSymbol.Delete( Index: Integer );
Begin
  If ( Index < 0 ) Or ( Index > FEntities.Count - 1 ) Then
    EzGisError( SEntityOutOfBound );
  TEzEntity( FEntities[Index] ).Free;
  FEntities.Delete( Index );
  UpdateExtension;
End;

Function TEzSymbol.IndexOf( Item: TEzEntity ): Integer;
Begin
  Result := FEntities.IndexOf( Item );
End;

Procedure TEzSymbol.Exchange( Index1, Index2: Integer );
Begin
  FEntities.Exchange( Index1, Index2 );
End;

Function TEzSymbol.Get( Index: Integer ): TEzEntity;
Begin
  If ( Index < 0 ) Or ( Index > FEntities.Count - 1 ) Then
    EzGisError( SEntityOutOfBound );
  Result := TEzEntity( FEntities[Index] );
End;

Procedure TEzSymbol.UpdateExtension;
Var
  I, N: Integer;
  Item: TEzRect;
  OldExtents: TEzRect;
  OldCentroid: TEzPoint;
  FirstY, LeftMostX: Double;
Begin
  OldExtents := FExtension;
  OldCentroid := FCentroid;
  FExtension := INVALID_EXTENSION;
  FillChar( FCentroid, SizeOf( TEzPoint ), 0 );
  N := FEntities.Count;
  LeftMostX := MAXCOORD;
  FirstY := 0;
  For I := 0 To N - 1 Do
  Begin
    Item := TEzEntity( FEntities[I] ).Points.Extension;
    MaxBound( FExtension.Emax, Item.Emax );
    MinBound( FExtension.Emin, Item.Emin );
    If ( FSymbols <> Nil ) And FSymbols.FIsLineType And ( Item.X1 < LeftMostX ) Then
    Begin
      FirstY := Item.Y1;
      LeftMostX := Item.X1;
    End;
  End;
  If N > 0 Then
  Begin
    FCentroid.X := FExtension.Emin.X + ( FExtension.Emax.X - FExtension.Emin.X ) / 2;
    If ( FSymbols <> Nil ) And FSymbols.FIsLineType Then
      FCentroid.Y := FirstY
    Else
      FCentroid.Y := FExtension.Emin.Y + ( FExtension.Emax.Y - FExtension.Emin.Y ) / 2;
  End;
  If (FSymbols <> Nil) And Assigned( FSymbols.OnChange ) And
     ( ( EqualRect2D( OldExtents, FExtension ) = false ) Or
       ( CompareMem( @OldCentroid, @FCentroid, SizeOf( TEzPoint ) ) = false ) ) Then
    FSymbols.OnChange( FSymbols );
End;

{$IFDEF BCB}
Procedure TEzSymbol.DrawDefault( Grapher: TEzGrapher; Canvas: TCanvas; Const Clip: TEzRect;
  DrawMode: TEzDrawMode );
begin
  Draw( Grapher, Canvas, Clip, IDENTITY_MATRIX2D, DrawMode );
end;
{$ENDIF}

Procedure TEzSymbol.Draw( Grapher: TEzGrapher;
                          Canvas: TCanvas;
                          Const Clip: TEzRect;
                          Const Matrix: TEzMatrix;
                          DrawMode: TEzDrawMode; Data: Pointer = Nil );
Var
  Entity: TEzEntity;
  OldBox: TEzRect;
  I: Integer;
Begin
  For I := 0 To FEntities.Count - 1 Do
  Begin
    Entity := TEzEntity( FEntities[I] );
    OldBox := Entity.FBox;
    Entity.SetTransformMatrix( Matrix );
    if Entity.EntityID = idPersistBitmap then
      with TEzPersistBitmap(Entity) do
      begin
        Transparent:= true;
      end;

    Entity.Draw( Grapher, Canvas, Clip, DrawMode );

    { restore original }
    Entity.SetTransformMatrix( IDENTITY_MATRIX2D );
    Entity.FBox := OldBox;
  End;
End;

{$IFDEF BCB}
Procedure TEzSymbol.DrawVectorDefault( V: TEzVector;
  Const PenStyle: TEzPenStyle; Grapher: TEzGrapher;
  Canvas: TCanvas; Const Clip: TEzRect; DrawMode: TEzDrawMode );
Begin
  DrawVector( V, Penstyle, Grapher, Canvas, Clip, IDENTITY_MATRIX2D, DrawMode);
End;
{$ENDIF}

Procedure TEzSymbol.DrawVector( V: TEzVector;
                                Const PenStyle: TEzPenStyle;
                                Grapher: TEzGrapher;
                                Canvas: TCanvas;
                                Const Clip: TEzRect;
                                Const Matrix: TEzMatrix;
                                DrawMode: TEzDrawMode );
Var
  I, J, N, Idx1, Idx2: Integer;
  Box: TEzRect;
  SymbolWidth, Scale, AcumX: Double;
  SegmDist, SegmAngle, ResidualDist: Double;
  p1, p2, TmpPt1, TmpPt2: TEzPoint;
  TmpV: TEzVector;
  M, M1, M2: TEzMatrix;
  Entity: TEzEntity;
  APenStyle: TEzPenStyle;
Begin
  n := 0;
  If V.Parts.Count < 2 Then
  Begin
    Idx1 := 0;
    Idx2 := V.Count - 1;