ksskinsource.pas

来自「小区水费管理系统源代码水费收费管理系统 水费收费管理系统」· PAS 代码 · 共 874 行 · 第 1/2 页

  Index := FBitmaps.IndexOf(Source);

  if Index <> -1 then
  begin
    FBitmaps.Delete(Index);
    FBitmaps.Insert(Index, Dest);

    for i := 0 to Count - 1 do
      Objects[i].AfterLoad;

    Source.Free;
    Source := nil;
  end;
end;

{ Properties ==================================================================}

function TSeSkinSource.GetObject(index: integer): TSeSkinObject;
begin
  if (index >= 0) and (index < FObjects.Count) and (not FIsChanging) then
    Result := TSeSkinObject(FObjects[index])
  else
    Result := nil;
end;

function TSeSkinSource.GetCount: integer;
begin
  Result := FObjects.Count
end;

procedure TSeSkinSource.SetDeltaHue(const Value: integer);
var
  i: integer;
begin
  if FDeltaHue <> Value then
  begin
    FDeltaHue := Value;
    FBitmapHue := FDeltaHue - FBitmapHue;

    { Change Bitmaps Hue }
    for i := 0 to FBitmaps.Count - 1 do
      Bitmaps[i].ChangeBitmapHue(FBitmapHue);
    { Change Objects Hue }
    for i := 0 to FObjects.Count - 1 do
      Objects[i].ChangeHue(FBitmapHue);

    FBitmapHue := FDeltaHue;
  end;
end;

{ TSeSkinFilter ===============================================================}

constructor TSeSkinFilter.Create;
begin
  inherited;
end;

destructor TSeSkinFilter.Destroy;
begin
  inherited;
end;

class function TSeSkinFilter.GetFileExtension: string;
begin
end;

class function TSeSkinFilter.GetFilterName: string;
begin
end;

procedure TSeSkinFilter.ReadSkin(Stream: TStream);
begin
end;

procedure TSeSkinFilter.WriteSkin(Stream: TStream);
begin
end;

procedure TSeSkinFilter.ReadSkinSource(Stream: TStream);
var
  i, ACount: integer;
  SkinObject: TSeSkinObject;
  B: TSeBitmap;
begin
  if FSkinSource = nil then Exit;
  
  with FSkinSource do
  begin
    Clear;

    { Load SourceInfo }
    FSkinName := ReadString(Stream);
    FSkinVersion := ReadString(Stream);
    FAuthor := ReadString(Stream);
    FAuthorEMail := ReadString(Stream);
    FAuthorURL := ReadString(Stream);
    { Load Count }
    Stream.Read(ACount, SizeOf(Integer));
    { Load Images }
    for i := 0 to ACount-1 do
    begin
      B := TSeBitmap.Create;
      B.LoadFromStream(Stream);
      B.PerformTransparent(KColor(255, 0, 255, 0));
      B.DDBNeed;
      FBitmaps.Add(B);
    end;
    { Load Count }
    Stream.Read(ACount, SizeOf(Integer));
    { Load Objects }
    for i := 0 to ACount-1 do
    begin
      SkinObject := LoadSkinObject(Stream, nil);
      if SkinObject <> nil then
        FObjects.Add(SkinObject);
      SkinObject.Bitmaps := FBitmaps;
      SkinObject.AfterLoad;
    end;
  end;
end;

procedure TSeSkinFilter.WriteSkinSource(Stream: TStream);
var
  i: integer;
begin
  if FSkinSource = nil then Exit;

  with FSkinSource do
  begin
    WriteString(Stream, FSkinName);
    WriteString(Stream, FSkinVersion);
    WriteString(Stream, FAuthor);
    WriteString(Stream, FAuthorEMail);
    WriteString(Stream, FAuthorURL);
    { Save Image Count }
    Stream.Write(FBitmaps.Count, SizeOf(Integer));
    { Save Images }
    for i := 0 to FBitmaps.Count-1 do
      FBitmaps[i].SaveToStream(Stream);
    { Save Object Count }
    Stream.Write(FObjects.Count, SizeOf(Integer));
    { Save Objects }
    for i := 0 to FObjects.Count-1 do
      SaveSkinObject(Stream, Objects[i]);
  end;
end;

{ Properties }

procedure TSeSkinFilter.SetSkinSource(const Value: TSeSkinSource);
begin
  FSkinSource := Value;
end;

{ TSeSkinFilterUncompressed =====================================================}

constructor TSeSkinFilterUncompressed.Create;
begin
  inherited Create;
end;

class function TSeSkinFilterUncompressed.GetFileExtension: string;
begin
  Result := 'uskn';
end;

class function TSeSkinFilterUncompressed.GetFilterName: string;
begin
  Result := 'Uncompressed Skin';
end;

procedure TSeSkinFilterUncompressed.ReadSkin(Stream: TStream);
begin
  { Read skin from stream }
  ReadSkinSource(Stream);
end;

procedure TSeSkinFilterUncompressed.WriteSkin(Stream: TStream);
begin
  { Save skin to stream }
  WriteSkinSource(Stream);
end;

{ TSeSkinFilterCompressed ===================================================}

constructor TSeSkinFilterCompressed.Create;
begin
  inherited;
end;

class function TSeSkinFilterCompressed.GetFileExtension: string;
begin
  Result := 'kskn';
end;

class function TSeSkinFilterCompressed.GetFilterName: string;
begin
  Result := 'Compressed Skin';
end;

procedure TSeSkinFilterCompressed.ReadSkin(Stream: TStream);
var
  DStream: TDecompressionStream;
  S: array [0..3] of Char;
begin
  { Read sign }
  Stream.Read(S, SizeOf(KsZSign));

  { Read skin }
  DStream := TDecompressionStream.Create(Stream);
  try
    ReadSkinSource(DStream);
  finally
    DStream.Free;
  end;
end;

procedure TSeSkinFilterCompressed.WriteSkin(Stream: TStream);
var
  CStream: TCompressionStream;
begin
  { Write sign }
  Stream.Write(KsZSign, SizeOf(KsZSign));
  { Write skin }
  CStream := TCompressionStream.Create(clFastest, Stream);
  try
    WriteSkinSource(CStream);
  finally
    CStream.Free;
  end;
end;

{ TSeSkinFilterUltraCompressed ===================================================}

constructor TSeSkinFilterUltraCompressed.Create;
begin
  inherited;
end;

class function TSeSkinFilterUltraCompressed.GetFileExtension: string;
begin
  Result := 'xskn';
end;

class function TSeSkinFilterUltraCompressed.GetFilterName: string;
begin
  Result := 'Ultra Compressed Skin';
end;

procedure TSeSkinFilterUltraCompressed.ReadSkin(Stream: TStream);
var
  DStream: TDecompressionStream;
  S: array [0..3] of Char;
begin
  { Read sign }
  Stream.Read(S, SizeOf(KsZSign));
  { Read skin }
  DStream := TDecompressionStream.Create(Stream);
  try
    ReadSkinSource(DStream);
  finally
    DStream.Free;
  end;
end;

procedure TSeSkinFilterUltraCompressed.WriteSkin(Stream: TStream);
var
  CStream: TCompressionStream;
begin
  { Write sign }
  Stream.Write(KsZSign, SizeOf(KsZSign));
  { Write skin }
  CStream := TCompressionStream.Create(clMax, Stream);
  try
    WriteSkinSource(CStream);
  finally
    CStream.Free;
  end;
end;


{ TSeSkinFilterMaxCompression }

constructor TSeSkinFilterMaxCompression.Create;
begin
  inherited;

end;

class function TSeSkinFilterMaxCompression.GetFileExtension: string;
begin
  Result := 'mskn';
end;

class function TSeSkinFilterMaxCompression.GetFilterName: string;
begin
  Result := 'Maximum Compressed';
end;

procedure TSeSkinFilterMaxCompression.ReadSkinSource(Stream: TStream);
var
  i, ACount: integer;
  SkinObject: TSeSkinObject;
  B: TSeBitmap;
  Bmp: TBitmap;
  S: string;
  MemStream: TMemoryStream;
  Size: Cardinal;
begin
  if FSkinSource = nil then Exit;

  with FSkinSource do
  begin
    Clear;

    { Load SourceInfo }
    FSkinName := ReadString(Stream);
    FSkinVersion := ReadString(Stream);
    FAuthor := ReadString(Stream);
    FAuthorEMail := ReadString(Stream);
    FAuthorURL := ReadString(Stream);
    { Load Count }
    Stream.Read(ACount, SizeOf(Integer));
    { Load Images }
    for i := 0 to ACount-1 do
    begin
      { Write name }
      S := ReadString(Stream);

      { Read bitmap }
      Bmp := TBitmap.Create;

      MemStream := TMemoryStream.Create;

      Stream.ReadBuffer(Size, SizeOf(Size));
      MemStream.SetSize(Size);
      Stream.ReadBuffer(MemStream.Memory^, Size);

      MemStream.Position := 0;
      Bmp.LoadFromStream(MemStream);
      MemStream.Free;

      B := TSeBitmap.Create;
      B.Assign(Bmp);
      B.PerformTransparent(ckTransparent);
      B.Name := S;
      B.DDBNeed;
      FBitmaps.Add(B);

      Bmp.Free;
    end;
    { Load Count }
    Stream.Read(ACount, SizeOf(Integer));
    { Load Objects }
    for i := 0 to ACount-1 do
    begin
      SkinObject := LoadSkinObjectBinary(Stream, nil);
      if SkinObject <> nil then
        FObjects.Add(SkinObject);
      SkinObject.Bitmaps := FBitmaps;
      SkinObject.AfterLoad;
    end;
  end;
end;

procedure TSeSkinFilterMaxCompression.WriteSkinSource(Stream: TStream);
var
  i: integer;
  Size: Cardinal;
  B: TBitmap;
  MemStream: TMemoryStream;
begin
  if FSkinSource = nil then Exit;

  with FSkinSource do
  begin
    WriteString(Stream, FSkinName);
    WriteString(Stream, FSkinVersion);
    WriteString(Stream, FAuthor);
    WriteString(Stream, FAuthorEMail);
    WriteString(Stream, FAuthorURL);
    { Save Image Count }
    Stream.Write(FBitmaps.Count, SizeOf(Integer));
    { Save Images }
    for i := 0 to FBitmaps.Count-1 do
    begin
      { Write name }
      WriteString(Stream, FBitmaps[i].Name);

      { Write bitmap }
      MemStream := TMemoryStream.Create;
      try
        B := TBitmap.Create;
        B.HandleType := bmDIB;
        B.PixelFormat := pf16bit;
        B.Width := FBitmaps[i].Width;
        B.Height := FBitmaps[i].Height;
        FBitmaps[i].Draw(B.Canvas, 0, 0);
        B.SaveToStream(MemStream);
        B.Free;

        Size := MemStream.Size;
        Stream.WriteBuffer(Size, SizeOf(Size));
        Stream.WriteBuffer(MemStream.Memory^, MemStream.Size);
      finally
        MemStream.Free;
      end;
    end;
    { Save Object Count }
    Stream.Write(FObjects.Count, SizeOf(Integer));
    { Save Objects }
    for i := 0 to FObjects.Count-1 do
      SaveSkinObjectBinary(Stream, Objects[i]);
  end;
end;

initialization
  Filters := TList.Create;
  RegisterSkinFilter(TSeSkinFilterUncompressed);
  RegisterSkinFilter(TSeSkinFilterCompressed);
  RegisterSkinFilter(TSeSkinFilterUltraCompressed);
  RegisterSkinFilter(TSeSkinFilterMaxCompression);
finalization
  UnregisterSkinFilter(TSeSkinFilterMaxCompression);
  UnregisterSkinFilter(TSeSkinFilterUltraCompressed);
  UnregisterSkinFilter(TSeSkinFilterCompressed);
  UnregisterSkinFilter(TSeSkinFilterUncompressed);
  Filters.Free;
end.