Icons mit Delphi erstellen

[xaromz]

Hallo,

Zitat von Martin K:

1. Frage:
Wie bekomme ich aus TLogPalette ein array[0..255] of TColor ?

In einer TLogPalette ist ja ein Array of TPaletteEntry drin. Mit einer Schleife kannst Du Dir da ein Array basteln:

Delphi-Quellcode:

var
  Farben: array[0..255] of TColor;
  Palette: TLogPalette;
begin
  for C := 0 to 255 do
    Farben[C] := RGB(Palette.palPalEntry[C].peRed, Palette.palPalEntry[C].peGreen, Palette.palPalEntry[C].peBlue);

Zitat von Martin K:

2. Frage:
In dieser Zeile wird also die Palette geladen:

Delphi-Quellcode:

    lpPal^.palNumEntries := 
      GetSystemPaletteEntries(dc, 
      0, 
      256, 
      lpPal^.palPalEntry);

Es wird allerdings die Systempalette geladen.
Wie kann ich hier die Palette aus einem Stream (Datei) laden?
GetPaletteEntries... und dann?

Du musst mit CreatePalette eine Palette erstellen, eine TLogPalette mit den Werten füllen, die Du aus dem Stream geladen hast (das Format kennst Du hoffentlich), dann mit SetPaletteEntries die Palette füllen und schließlich mit SelectPalette die Palette in einen DC laden.

Gruß
xaromz

[Martin K]

So, hab jetzt mal ein bisschen rumgebastelt.

Delphi-Quellcode:

var
  MyArray: array[0..255] of TColor;  // Farbpalette als Array
  lpPal: PLOGPALETTE;     // Farbpalette
{...}

procedure TForm1.FormCreate(Sender: TObject);
var i: byte;
begin
  For i:=0 to 255 do
    MyArray[i] := RGB(i,i,i);  // Array mit 256 Grauwerten, also 8 Bit Graustufung
end;

procedure TForm1.Button1Click(Sender: TObject);
var i: byte;
begin
  GetMem(lpPal, SizeOf(TLOGPALETTE) +(255 * SizeOf(TPALETTEENTRY)));
  FillChar(lpPal^, SizeOf(TLOGPALETTE) +(255 * SizeOf(TPALETTEENTRY)),#0);
  lpPal^.palVersion := $300;
  lpPal^.palNumEntries := 256;
  for i:=0 to 255 do
  begin                      // erstelle die Farbpalette aus MyArray
    lpPal^.palPalEntry[i].peRed  := GetRValue(ColorToRGB(MyArray[i]));
    lpPal^.palPalEntry[i].peGreen:= GetGValue(ColorToRGB(MyArray[i]));
    lpPal^.palPalEntry[i].peBlue := GetBValue(ColorToRGB(MyArray[i]));
  end;
  CreatePalette(lpPal^);
  FreeMem(lpPal, SizeOf(TLOGPALETTE) +(255 * SizeOf(TPALETTEENTRY)));
end;

procedure TForm1.Button2Click(Sender: TObject);
var STREAM: TStream;
begin   // Palette in Datei speichern
  STREAM := TFileStream.Create('C:\test.dat', fmCreate or fmOpenWrite);
  STREAM.Write(lpPal^, SizeOf(TLOGPALETTE) +(255 * SizeOf(TPALETTEENTRY)));
  STREAM.Free;
end;

Ich erstelle also eine 8 Bit Farbpalette mit allen Grauwerten.
Wenn ich mir dann die Palette in der fertige Datei anschaue (hab ein Programm, mit dem man Farbpaletten editieren kann, diese werden dann in *.dat Dateien gespeichert), kommt das bei raus: (Bild im Anhang).

Merkwürdig sind die ersten 5 Farben, der Rest sieht eigentlich ganz gut aus.

Hat jemand eine Idee, woran das liegen könnte?


//Edit:
Die Dateien vom Programm sind alle 1024 Byte groß, meine Datei ist 1028 Byte groß.
Hat das damit evtl. was zu tun?

Außerdem ist der letzte Farbwert nicht reines Weiß, sondern einer niederiger:
254, 254, 254
Warum?

[xaromz]

Hallo,

Du erstellst in der einen Methode eine Palette und zerstörst diese wieder. In der anderen Methode speicherst Du die Palette, die aber gar nicht mehr existiert.

Übrigens legst Du mit CreatePalette ein Paletten-Objekt an, speicherst das Handle aber nicht. Erstens musst Du zum Speichern einer Palette kein Paletten.Objekt erstellen (das brauchst Du nur, wenn Du die Palette für eine Graphik verwenden willst), und zweitens erzeugst Du damit ein Speicherleck.

Versuchs mal so:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject); 
var 
  I: Byte; 
  STREAM: TStream; 
begin 
  // Speicher anfordern
  GetMem(lpPal, SizeOf(TLOGPALETTE) +(255 * SizeOf(TPALETTEENTRY))); 

  // Palette füllen
  lpPal^.palVersion := $300; 
  lpPal^.palNumEntries := 256; 
  for i:=0 to 255 do 
  begin                      // erstelle die Farbpalette aus MyArray 
    lpPal^.palPalEntry[i].peRed  := GetRValue(ColorToRGB(MyArray[i])); 
    lpPal^.palPalEntry[i].peGreen:= GetGValue(ColorToRGB(MyArray[i])); 
    lpPal^.palPalEntry[i].peBlue := GetBValue(ColorToRGB(MyArray[i])); 
  end; 

  // Palette speichern
  STREAM := TFileStream.Create('C:\test.dat', fmCreate or fmOpenWrite); 
  STREAM.Write(lpPal^, SizeOf(TLOGPALETTE) +(255 * SizeOf(TPALETTEENTRY))); 
  STREAM.Free; 

  // Speicher freigeben
  FreeMem(lpPal, SizeOf(TLOGPALETTE) +(255 * SizeOf(TPALETTEENTRY))); 
end;

Zu Deinem Edit:
Das Programm möchte anscheinend nur die Palettendaten, Du speicherst aber ja vorne noch Verwaltungsinformationan (Palettenversion...).
Speichere doch einfach nur die Paletteneinträge:
STREAM.Write(lpPal^.palPalEntry[0], (256 * SizeOf(TPALETTEENTRY))); Gruß
xaromz

[Martin K]

Danke, super jetzt klappts!!!! 1A

Vielen Dank, xaromz !!!


So, das war das Speichern einer Palette.
Und jetzt drehen wir den Spieß rum:
Palette aus Datei in Array laden.

Da hast du mir ja schon einiges in Beitrag #11 geschrieben, werd mich jetzt mal dran machen...

[Martin K]

Zitat von xaromz:

Du musst mit CreatePalette eine Palette erstellen, eine TLogPalette mit den Werten füllen, die Du aus dem Stream geladen hast (das Format kennst Du hoffentlich), dann mit SetPaletteEntries die Palette füllen und schließlich mit SelectPalette die Palette in einen DC laden.

Kannst du mir das näher erläutern?
Evtl. mit ein wenig Code?
Wäre echt super...

Ich bekomme es irgendwie nicht gebacken, aus dem TStream in die PLOGPALETTE zu laden...

[Martin K]

Irgendwie bekomme ich das Laden der Palette nicht hin.

Verwende jetzt diesen Code:

Palette^ ist ein Zeiger auf ein array of TColor

Delphi-Quellcode:

procedure LoadPalette;
var i: Byte; Stream: TStream; lpPal: PLogPalette; hPal: HPalette;
begin
  GetMem(lpPal,SizeOf(TLogPalette)+High(Palette^)*SizeOf(TPaletteEntry));
  lpPal^.palVersion:=$300;
  hPal:=CreatePalette(lpPal^);
  Stream:=TFileStream.Create('C:\test.dat', fmCreate or fmOpenWrite);
  Stream.Read(lpPal^,Length(Palette^)*SizeOf(TPaletteEntry));
  Stream.Free;
  for i:=0 to High(Palette^) do
  begin
    Palette^[i]:=RGB(lpPal^.palPalEntry[i].peRed,lpPal^.palPalEntry[i].peGreen,lpPal^.palPalEntry[i].peBlue);
  end;
  FreeMem(lpPal,SizeOf(TLogPalette)+High(Palette^)*SizeOf(TPaletteEntry));
end;

Nach dem Laden ist die Datei merkwürdigerweise immmer leer (0 Byte groß), obwohl ich sie doch nur lese...
Ich verstehe es nicht...

Wäre für jede Hilfe dankbar!

[xaromz]

Hallo,

jetzt hatte ich einen so schönen Beitrag verfasst, und dann schließ ich Idiot den Browser .
Egal, auf ein Neues:

Zitat von Martin K:

Irgendwie bekomme ich das Laden der Palette nicht hin.

Nach dem Laden ist die Datei merkwürdigerweise immmer leer (0 Byte groß), obwohl ich sie doch nur lese...
Ich verstehe es nicht...

Du erstellst ja eine neue Datei mit fmCreate or fmOpenWrite. Nimm lieber fmOpenRead.

Du liest die Einträge übrigens in eine TLogPalette-Struktur ein, aber Du brauchst ja nur die Einträge.

Außerdem erstellst Du mit CreatePalette ein Palettenobjekt, das Du nie verwendest.

Und zu guter Letzt solltest Du auch nur so viele Einträge einlesen, wie tatsächlich vorhanden sind.

Ich hab die Prozedur mal verbessert und mit Anmerkungen versehen:

Delphi-Quellcode:

procedure LoadPalette;
var
  i: Byte;
  Stream: TStream;
  lpPal: PLogPalette;
  Count: Integer;
begin
  // Stream öffnen
  Stream := TFileStream.Create('C:\test.dat', fmOpenRead);

  // Anzahl der Einträge ermitteln
  Count := Stream.Size div SizeOf(TPaletteEntry);

  // Speicher reservieren
  GetMem(lpPal, SizeOf(TLogPalette) + (Count - 1) * SizeOf(TPaletteEntry));

  // Palette vorbereiten
  lpPal^.palVersion := $300;
  lpPal^.palNumEntries := Count;

  // Einträge einlesen
  Stream.Read(lpPal^.palPalEntry[0], Count * SizeOf(TPaletteEntry));
  Stream.Free;

  // Einträge in Array kopieren
  for i := 0 to Count - 1 do
    Palette^[i] := RGB(lpPal^.palPalEntry[i].peRed,
      lpPal^.palPalEntry[i].peGreen, lpPal^.palPalEntry[i].peBlue);

  FreeMem(lpPal);
end;

Gruß
xaromz

[Martin K]

Hi xaromz, vielen Dank für deinen Code!!!

Ich hab halt vorher noch nie mit Streams und sowas gearbeitet und hatte nicht wirklich viel Ahnung davon.
Aber jetzt funzt's, Danke nochmal!

Kurze Frage noch:
Was macht das eigentlich für einen Unterschied, ob ich schreibe:
  FreeMem(lpPal); oder:
  FreeMem(lpPal, SizeOf(TLogPalette) + (Count-1) * SizeOf(TPaletteEntry)); Ist das das gleiche?
Kann ich beim Speichern auch einfach nur FreeMem(lpPal); schreiben?

[xaromz]

Hallo,

Zitat von Martin K:

Kurze Frage noch:
Was macht das eigentlich für einen Unterschied, ob ich schreibe:
  FreeMem(lpPal); oder:
  FreeMem(lpPal, SizeOf(TLogPalette) + (Count-1) * SizeOf(TPaletteEntry)); Ist das das gleiche?
Kann ich beim Speichern auch einfach nur FreeMem(lpPal); schreiben?

Früher (zu DOS-Zeiten) musste man immer angeben, wie viel Speicher wierder freigegeben werden soll. In Delphi erledigt das der Memory-Manager. Deshalb kann man die Größe einfach weglassen. Damit spart man sich außerdem eine mögliche Fehlerquelle.

Gruß
xaromz

[Martin K]

Danke.

Hab grad was sehr merkwürdiges festgestellt und ich habe keine Ahnung warum das so ist:

Irgendwie müssen die Rot- und Blauwerte vertauscht sein.
Hab einfach mal ein paar Farben eingetragen und in die Palette gespeichert.
Dann mit meinem anderen Programm die Palette angeschaut - und:
Aus blau wurde rot und aus rot wurde blau.
Das Grün hat immer gestimmt, nur eben Rot und blau war immer vertauscht.

Beispiel:
Aus der Farbe RGB(64,128,255) im Quellcode wurde RGB(255,128,64) im Programm.

Den Fehler zu beheben ist ja sehr einfach, ich frage mich nur woher er kommt...

Diese beiden Teile müssten ja dafür verantwortlich sein:

Delphi-Quellcode:

//Speichern:
  for i := 0 to High(Palette^) do
  begin
    lpPal^.palPalEntry[i].peRed  := GetRValue(ColorToRGB(Palette^[i]));
    lpPal^.palPalEntry[i].peGreen:= GetGValue(ColorToRGB(Palette^[i]));
    lpPal^.palPalEntry[i].peBlue := GetBValue(ColorToRGB(Palette^[i]));
  end;

//Laden:
  for i := 0 to Count-1 do 
    Palette^[i] := RGB(lpPal^.palPalEntry[i].peRed, 
      lpPal^.palPalEntry[i].peGreen, lpPal^.palPalEntry[i].peBlue);