kann Daten nicht an Rect übergeben

[EWeiss]

Warum ist das nicht möglich bzw.. was ist falsch

Delphi-Quellcode:

pData :PRgnData;
lpRect : PRect;

Delphi-Quellcode:

lpRect := sizeof(RgnDataHeader) + pData^.rdh;
lpRect := lpRect + sizeof(TRect);

gruss Emil

[Luckie]

Was kommt denn für eine Fehlermeldung? Und wo reservierst du Speicher für lpRect?

[EWeiss]

Zitat von Luckie:

Was kommt denn für eine Fehlermeldung? Und wo reservierst du Speicher für lpRect?

Speicher := lpRect := PRECT(@pData^.Buffer);

Zitat:

[Pascal Error] uSkin.pas(2462): E2015 Operator not applicable to this operand type

EDIT:
In PBasic schreib ich es so und hab kein problem damit

Delphi-Quellcode:

lpRect = LEN(RGNDATAHEADER) + rdh
lpRect = lpRect + LEN(RECT)

Sieht jetzt so aus
Leider durch das problem sind die ecken Magenta (vorher gesetzt)
werden aber nicht transparent geschaltet.

gruss Emil

[SirThornberry]

In delphi musst du casten. lpRect ist ein Pointer, sizeof ein Integer/Cardinal und rdh?
Einem Pointer kannst du nicht einfach einen Integer zuweisen da muss ein Cast hinn. Und Pointer kann man nicht einfach addieren, da muss auch ein Cast hinn.

das weiterrücken des rect geht so:

Delphi-Quellcode:

//lpRect := lpRect + sizeof(TRect);
inc(lpRect);

[EWeiss]

Zitat von SirThornberry:

In delphi musst du casten. lpRect ist ein Pointer, sizeof ein Integer/Cardinal und rdh?
Einem Pointer kannst du nicht einfach einen Integer zuweisen da muss ein Cast hinn. Und Pointer kann man nicht einfach addieren, da muss auch ein Cast hinn.

das weiterrücken des rect geht so:

Delphi-Quellcode:

//lpRect := lpRect + sizeof(TRect);
inc(lpRect);

versteh jetzt nich was du meinst + sizeof ist kein abzug von lpRect
Wie sieht denn der Cast aus ?

rdh =:

Delphi-Quellcode:

  PRgnData = ^TRgnData;
  {$EXTERNALSYM _RGNDATA}
  _RGNDATA = record
    rdh: TRgnDataHeader;
    Buffer: array[0..0] of CHAR;
    Reserved: array[0..2] of CHAR;
  end;

Grrmmm immer diese Typen umwandlungen.

gruss Emil

[EWeiss]

Kann mal bitte jemand drüberschaun?
Bekomme einfach meine Kanten nicht rund

Delphi-Quellcode:

procedure TSkinEngine.CreateFormRegion(TransColor: COLORREF);
var
  bm          : Bitmap;
  pData       : PRgnData;
  lpRect      : PRect;
  hRgn1       : HRGN;
  hRgn2       : HRGN;
  sRegionData : THANDLE;
  TT          : Integer;
  MaxRegions  : Integer;
  hDIB        : Cardinal;
  I, J, K, M  : Integer;
  IsSame      : Integer;
  bRedraw     : Boolean;
  Ar:  array of PRGBQuad;
begin

  hDIB := GetPaintBitmap(MainWindow(0));
  if hDIB = 0 then
    exit;

  MaxRegions := 4000;

  GetObject(hDIB, SIZEOF(bm), @bm);

    SetLength(Ar, integer(bm.bmBits));
    Ar := @bm.bmBits;

  if TransColor = 0 then
    TransColor  := Cardinal(Ar[(bm.bmHeight - 1) * bm.bmWidth]) and $FFFFFF;

    sRegionData := GlobalAlloc(GMEM_MOVEABLE, sizeof(RGNDATAHEADER) + (sizeof(TRECT) * MaxRegions));
    pData       := GlobalLock(sRegionData);
    pData^.rdh.nCount         := MaxRegions + 1;;
    pData^.rdh.dwSize         := sizeof(RGNDATAHEADER);
    pData^.rdh.iType          := RDH_RECTANGLES;
    pData^.rdh.rcBound.Left   := 0;
    pData^.rdh.rcBound.Top    := 0;
    pData^.rdh.rcBound.Right  := bm.bmWidth;
    pData^.rdh.rcBound.Bottom := bm.bmHeight;

    lpRect:= PRECT(@pData^.Buffer);

    for J := 0 TO bm.bmHeight - 1  do
    begin
      TT := bm.bmWidth * (bm.bmHeight - 1 - J);
      M := -1;
      for I := 0 TO bm.bmWidth do
      begin
        if I = bm.bmWidth then
          K := TransColor
          else K := Cardinal(@Ar[TT]) and $FFFFFF;
          TT := TT + 1;

          if K = integer(TransColor) then
            IsSame := -1
            else
              IsSame := 0;

            if IsSame = 0 then
               if M = -1 then
               M := I
            else if M >= 0 then
            begin
              if integer(pData^.rdh.nCount) >= MaxRegions then
              begin
                hRgn2 := ExtCreateRegion(nil, sizeof(RGNDATAHEADER) +
                  (sizeof(TRECT) * pData^.rdh.nCount), PRGNDATA(pData)^);
                if hRgn1 = 0 then
                begin
                  hRgn1 := hRgn2;
                end else
                begin
                  CombineRgn(hRgn1, hRgn1, hRgn2, RGN_OR);
                  zDeleteObject(hRgn2);
                end;

                pData^.rdh.nCount := 0;
              end;
              inc(pData^.rdh.nCount);
              lpRect.Left := M;
              lpRect.Right := I;
              lpRect.Top := J;
              lpRect.Bottom := J + 1;
              inc(lpRect);
              M := -1;
            end;
        end;
    end;
    hRgn2 := ExtCreateRegion(nil, sizeof(RGNDATAHEADER) +
      (sizeof(TRECT) * pData^.rdh.nCount), pData^);
    if hRgn1 = 0 then
    begin
       hRgn1 := hRgn2
    end else
    begin
      CombineRgn(hRgn1, hRgn1, hRgn2, RGN_OR);
      DeleteObject(hRgn2);
    end;

    if hRgn1 <> 0 then
    begin
       if IsWindowVisible(MainWindow(0)) then
         bRedraw := TRUE
       else
         bRedraw := FALSE;
       SetWindowRgn(MainWindow(0), hRgn1, bRedraw);
    end;

    SetLength(Ar, 0);

end;

gruss Emil

[Roachford]

Delphi-Quellcode:

    SetLength(Ar, integer(bm.bmBits));
    Ar := @bm.bmBits;

Wozu reservierst du Speicher bei dem Array, wenn du es dann einfach überschreibst bzw. die Adresse woanders hinzeigen lässt? Was soll das mit dem "Array of TRGBQuad" überhaupt?

bmBits gibt dir den Zeiger auf einen TRGBQuad zurück, sprich: bmBits ist eigentlich ein PRGBQuad. Alle nachfolgenden Pixel findest du dann nach dem diesem Pixel. Dazu (wurde schon beim PRect gesagt) einfach Inc() machen.

Also:

Delphi-Quellcode:

var
  lPixel: PRGBQuad;
begin
  lPixel := bm.bmBits;

  lPixel^ => 1. Pixel
  Inc(lPixel);
  lPixel^ => 2. Pixel
  etc

[EWeiss]

Zitat von Roachford:

Delphi-Quellcode:

    SetLength(Ar, integer(bm.bmBits));
    Ar := @bm.bmBits;

Wozu reservierst du Speicher bei dem Array, wenn du es dann einfach überschreibst bzw. die Adresse woanders hinzeigen lässt? Was soll das mit dem "Array of TRGBQuad" überhaupt?

bmBits gibt dir den Zeiger auf einen TRGBQuad zurück, sprich: bmBits ist eigentlich ein PRGBQuad. Alle nachfolgenden Pixel findest du dann nach dem diesem Pixel. Dazu (wurde schon beim PRect gesagt) einfach Inc() machen.

Also:

Delphi-Quellcode:

var
  lPixel: PRGBQuad;
begin
  lPixel := bm.bmBits;

  lPixel^ => 1. Pixel
  Inc(lPixel);
  lPixel^ => 2. Pixel
  etc

In PB dimensioniere ich mir ein Array das auf die Adresse bm.bmBits zeigt
REDIM Ar(0) AS LONG AT bm.bmBits
Da ist nichts mit Quads

Mein problem ist halt eine lösung für mich zu finden die Daten nach Delphi rüber zu bringen
will aber auch nicht meine Progr.. die anderen vielleicht noch von nutzen sein können
in die Tonne werfen nur weil ich jetzt nix mehr in basic mache.

Jo in Delphi ist der ersatz für 1 = 1 + 1 inc(1) hab ich schon verstanden.
Was ich auf jedenfall weis ist das mein PB Schnipsel funktioniert.

Danke für die Hilfe.

PS: Häng mal mein Org. mit an

Delphi-Quellcode:

SUB CreateFormRegion(BYVAL TransColor AS LONG)

//schnipp    
END SUB

[Roachford]

Zitat von EWeiss:

In PB dimensioniere ich mir ein Array das auf die Adresse bm.bmBits zeigt
REDIM Ar(0) AS LONG AT bm.bmBits

Das ist mir klar, von daher nochmal und anders formuliert:
Du hast ein dynamisches Array und das zeigt auf den reservierten Speicherbereich mit der in SetLength() angegebenen Grösse. Die deklarierte Variable deines Arrays ist dabei ein Zeiger, welcher durch SetLength(), wie zuvor beschrieben, initialisiert wurde. Mit deiner Zuweisung von dmBits auf die Array Variable lässt du die Variable (den Pointer im Endeffekt) nicht mehr auf das Array sondern auf deine Pixeldaten zeigen. Das reservierte Array liegt dann immernoch an seiner Original-reservierten Position im Speicher und ist verloren, da du mit der Zuweisung die letzte Zugriffsmöglichkeit zerschossen hast. Da die Dimensionierung aber vor dem Array im Speicher liegt, auf den der Zeiger mal original hingezeigt hat und dein Pixeldaten keine solche Informationen vor dem ersten Pixel hat, ist die Dimensionierung hinfällig. Ich hoffe du verstehst nun meine Einwände...

Zitat von EWeiss:

Da ist nichts mit Quads

Nein, richtig. Aber warum das Leben unnötig schwer machen? Du hast einen Zeiger auf die Pixeldaten. Diese liegen im 32 Bit (32bpp) Format vor. Anscheinend ja sogar (dank GDI+) im RGBA Format und nicht nur im RGBx Format. Ich könnte es genauso übernehmen wie du es hattest und den Zeiger als PLongWord deklarieren. Aber wozu? Ich weiss das ich eine Struktur mit 4 Elementen zu je einem Byte an der Stelle liegen habe. Also nutze ich doch einfach PRGBQuad und habe dann gleich Zugriff auf die Elemente, also den Rot-Anteil, den Grün-Anteil und den Blau-Anteil. Und abhängig vom Format auch gleich noch den Alpha-Wert. Alternativ kannst du gerne beim alten Code bleiben und ein LongWord haben und dir dann mit Shift-Operationen und ausmaskieren dir die nötigen Anteile rausholen. Aber wie gesagt: stures portieren oder gleich was verbessern? Die Lesbarkeit erhöhen? Ich weiss, es lief ja schon immer so - never change a running system...

Dein Weg:

Delphi-Quellcode:

var
  lPixel: PLongWord;
begin
  lPixel := bm.bmBits;

  Red := lPixel^ and $ff;
  Green := (lPixel^ shr 8) and $ff;
  Blue := (lPixel^ shr 16) and $ff;
  Alpha := (lPixel^ shr 24) and $ff;

Mein Vorschlag:

Delphi-Quellcode:

var
  lPixel: PRGBQuad;
begin
  lPixel := bm.bmBits;

  Red := lPixel^.rgbRed;
  Green := lPixel^.rgbGreen;
  Blue := lPixel^.rgbBlue;
  Alpha := lPixel^.rgbReserved;

Ich find mein Code lesbarer - aber Vorsicht: Subjektive Meinung!

Zitat von EWeiss:

Mein problem ist halt eine lösung für mich zu finden die Daten nach Delphi rüber zu bringen
will aber auch nicht meine Progr.. die anderen vielleicht noch von nutzen sein können
in die Tonne werfen nur weil ich jetzt nix mehr in basic mache.

Verlangt niemand von dir und ich finde es ehrlich gesagt auch wirklich gut, dass du sie portierst. Ich hoffe auch, dass du dabei auch dein Wissen erweiterst und die Möglichkeiten der neuen Sprache nutzt und vllt. auch lieben lernst.

Zitat von EWeiss:

Jo in Delphi ist der ersatz für 1 = 1 + 1 inc(1) hab ich schon verstanden.

Nein, anscheinend nicht richtig. Inc() kann mehr als das.

Inc() auf ordinale Typen macht das von dir beschriebene. Inc() auf typisierte Zeiger macht was anderes. Der macht auch mal +2 oder +x - abhängig vom Pointer.

Wenn der typisierte Pointer mit Inc() oder Dec() verändert wird, dann wird der Pointer jeweils um die Grösse des Typs verschoben.

Also (um auf dein Beispiel zurück zu kommen):

Delphi-Quellcode:

var
  lPixel: PLongWord;
begin
  lPixel := Addr($1000);
  Inc(lPixel);
  // hier ist lPixel ein Zeiger auf die Adresse $1004 !!!

  lPixel := Addr($1000);
  Inc(lPixel, 2);
  // hier ist lPixel ein Zeiger auf die Adresse $1008
end;

Und wenn wir uns das ganze nun nochmal mit einem PRGBQuad anschauen:

Delphi-Quellcode:

var
  lPixel: PRGBQuad;
begin
  lPixel := Addr($1000);
  Inc(lPixel);
  // hier ist lPixel ein Zeiger auf die Adresse $1004 !!!

  lPixel := Addr($1000);
  Inc(lPixel, 2);
  // hier ist lPixel ein Zeiger auf die Adresse $1008
end;

Kein Unterschied von dem Adresshandler, da der Typ, auf den der Zeiger zeigt, gleich gross ist.

Oder allgemein formuliert:

Bei Inc() und Dec() auf typisierte Zeiger gilt:

Inc/Dec(p, x):

p := p +/- x * sizeof(p^);

Aber egal, ich weiss nun, ich werde lieber nichts eigenmächtig verbessern oder ersetzen sollte in deinen Codes. Und ich hoffe du weisst nun, dass man dir nicht immer in die Suppe spucken will. Fremde Programmiersprachen zu lesen und zu verstehen ist nicht immer schwierig, da das Prinzip der meisten gleich ist, nur die Syntax ist anders.

[EWeiss]

Das ist wirklich eine sehr gute beschreibung meines problems.
Grundsätzlich bin ich immer dafür etwas zu vereinfachen wenn ich mir unnötige
zwischen berechnungen ersparen kann werd ich das natürlich tun.

Warum also nochmal konvertieren (berechnen) "shl" wenn die Daten schon im speicher bereit liegen.
Da sehe ich auch keinen sinn drin.

Würde dann auch lieber auf die lösung von dir zugreifen.

Delphi-Quellcode:

var 
  lPixel: PRGBQuad; 
begin 
  lPixel := bm.bmBits; 

  Red := lPixel^.rgbRed; 
  Green := lPixel^.rgbGreen; 
  Blue := lPixel^.rgbBlue; 
  Alpha := lPixel^.rgbReserved;

Ist was schwierig die ganze Funktionsbreite von Delphi auszunutzen.
Aber wird schon.

Zitat:

Und ich hoffe du weisst nun, dass man dir nicht immer in die Suppe spucken will.

Davon geh ich mit sicherheit nicht aus ansonsten würde ich hier keine Fragen stellen.
BIn immer froh wenn mir jemand hilft und ich das auch zurückgeben kann.

Danke gruss Emil