Polygon von Delphi nach C++ umschreiben



  • Hallo,

    kann mir vielleicht jemand nen Tipp geben?

    Wie kann man folgenden Delphi-Code nach Borland C++ umschreiben?

    Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + Z,X3)]); //  a
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2-X3,X6)]); //  b
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3-Z)]); //  c
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3-Z,X1)]); //  d
          Polygon([Point(0,X5),Point(X3,X7),Point(X3,X1-X3-Z),Point(0,X1-Z)]); //  e
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f
    

    ... ich habe es folgendermaßen probiert:

    TPoint points[4];
          points[0] = Point(Z,0);
          points[1] = Point(X2-Z,0);
          points[2] = Point(X2-X3-Z,X3);
          points[3] = Point(X3 + Z,X3);
          Canvas->Polygon(points,3);
    

    wie kann ich denn auf ein polygon am einfachsten zugreifen um das in c++ zu schreiben, hoffentlich hat jemand nen Tipp.

    Wäre super!

    Vielen Dank für Anregungen!

    Franky



  • Franky_als_Gast schrieb:

    [...]
    ... ich habe es folgendermaßen probiert:

    TPoint points[4];
          points[0] = Point(Z,0);
          points[1] = Point(X2-Z,0);
          points[2] = Point(X2-X3-Z,X3);
          points[3] = Point(X3 + Z,X3);
          Canvas->Polygon(points,3);
    

    [...]

    und das hat nicht funktioniert, oder nicht wie du wolltest?



  • ja, das hat leider nicht funktioniert.
    Weiß auch net, kann man einem polygon wie in delphi mehrere Werte übergeben oder muss man als Zeiger und die Anzahl?

    wer kennt sich da aus?



  • Du kannst ein Array auf jeden Fall per Initialisierungsliste füllen:

    TPoint points[]={TPoint(Z,0),TPoint(X2-Z,0),...};
    

    Ansonsten (ohne direkte Kenntnis der verwendeten Strukturen) sieht es für mich etwas seltsam aus, daß du ein TPoint-Objekt mit einem Point()-Konstruktor füllst und woher der Parameterwert "3" stammen soll.



  • ich werde später mal die delphi - Datei hochladen, die ich nach c++ konvertieren will.



  • **************************************************************************}
    unit JDLed;
    
    {$mode objfpc}
    
    interface
    
    uses
      SysUtils, Classes, Controls, Graphics, Dialogs,
      LMessages, LResources, Forms, StdCtrls;
    
    type
      TJDLed = class(TGraphicControl)
      private
        procedure SetLedDigit(value : integer);
        procedure SetLedThick(value: integer);
        { Private declarations }
      protected
        FDigit       : integer;
        FThick       : integer;
        procedure   Paint; override;
        { Protected declarations }
      public
        constructor Create(AOwner: TComponent); override;
        destructor  Destroy; override;
        { Public declarations }
      published
        property Digit      : integer read FDigit  write SetLedDigit;
        property Thick      : integer read FThick  write SetLedThick;
        { Published declarations }
      end;
    
    implementation
    
    constructor TJDLed.Create(AOwner: TComponent);
    begin
      inherited Create(AOwner);  { always call the inherited constructor }
      FDigit  := 1;
      FThick  := 5;
      Height  := 90;
      Width   := 50;
      with Constraints do
      begin
        MinHeight := 30;
        MinWidth  := 15;
      end;
    end;
    
    destructor TJDLed.Destroy;
    begin
      inherited Destroy;
    end;
    
    procedure TJDLed.Paint;
    var
      X1,X2,X3,X4,X5,X6,X7,Z,Z1 : integer;
    begin
      X1 := self.Height;
      X2 := self.Width;
      X3 := self.FThick;
      Z := abs(X3 div 2);
      Z1 := abs(self.Height div 2);
      X4 := Z1 - Z;
      X5 := Z1 + Z;
      X6 := Z1 - X3 - Z;
      X7 := Z1 + X3 + Z;
    
      inherited;
      with Canvas do
      begin
        Refresh;
        Brush.Color := clBlack;
        Pen.Color := clBlack;
        Refresh;
    
        Rectangle(0,0,self.Width,self.Height);
        Brush.Color := clRed;
        Pen.Color := clRed; 
        Refresh;
        case FDigit of
    
        0:
        begin
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2-
    X3,X6)]); //  b
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3-
    Z)]); //  c
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3-
    Z,X1)]); //  d
          Polygon([Point(0,X5),Point(X3,X7),Point(X3,X1-X3-Z),Point(0,X1-Z)]); //  e
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f
        end;
        1:
        begin
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2-
    X3,X6)]); //  b
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3-
    Z)]); //  c
        end;
        2:
        begin
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2-
    X3,X6)]); //  b
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3-
    Z,X1)]); //  d
          Polygon([Point(0,X5),Point(X3,X7),Point(X3,X1-X3-Z),Point(0,X1-Z)]); //  e
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 4)),Point
    (X2-X3-Z,Z1-Z - abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 4)),Point
    (X2-X3-Z,Z1+Z + abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2
        end;
        3:
        begin
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2-
    X3,X6)]); //  b
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3-
    Z)]); //  c
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3-
    Z,X1)]); //  d
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 4)),Point
    (X2-X3-Z,Z1-Z - abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 4)),Point
    (X2-X3-Z,Z1+Z + abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2
        end;
        4:
        begin
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2-
    X3,X6)]); //  b
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3-
    Z)]); //  c
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 2)),Point
    (X2-X3-Z,Z1-Z - abs(Z div 2)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 2)),Point
    (X2-X3-Z,Z1+Z + abs(Z div 2)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2
        end;
        5:
        begin
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3-
    Z)]); //  c
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3-
    Z,X1)]); //  d
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 4)),Point
    (X2-X3-Z,Z1-Z - abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 4)),Point
    (X2-X3-Z,Z1+Z + abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2
        end;
        6:
        begin
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3-
    Z)]); //  c
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3-
    Z,X1)]); //  d
          Polygon([Point(0,X5),Point(X3,X7),Point(X3,X1-X3-Z),Point(0,X1-Z)]); //  e
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 4)),Point
    (X2-X3-Z,Z1-Z - abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 4)),Point
    (X2-X3-Z,Z1+Z + abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2
        end;
        7:
        begin
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2-
    X3,X6)]); //  b
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3-
    Z)]); //  c
        end;
        8:
        begin
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2-
    X3,X6)]); //  b
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3-
    Z)]); //  c
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3-
    Z,X1)]); //  d
          Polygon([Point(0,X5),Point(X3,X7),Point(X3,X1-X3-Z),Point(0,X1-Z)]); //  e
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f
           Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 
    4)),Point(X2-X3-Z,Z1-Z - abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 4)),Point
    (X2-X3-Z,Z1+Z + abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2
        end;
        9:
        begin
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2-
    X3,X6)]); //  b
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3-
    Z)]); //  c
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3-
    Z,X1)]); //  d
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 4)),Point
    (X2-X3-Z,Z1-Z - abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 4)),Point
    (X2-X3-Z,Z1+Z + abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2
        end;
       end;
       Refresh;    
      end;
    
    end;
    
    procedure TJDLed.SetLedDigit(value: integer);
    begin
      if (value >= 0) and (value <= 9) then
      begin
        FDigit := value;
        Paint;
      end;
    end;
    
    procedure TJDLed.SetLedThick(value: integer);
    begin
      if (value > 2) then
      begin
        FThick := Value;
        Paint;
      end;
    end;
    
    initialization
     {$I jdledicon.lrs}
    
    end.
    

    Also das hier ist der Code der Delphi-Komponente, den ich als C++ - Komponente umsetzen will.



  • Polygon ist einfach die Funktion Polygon aus TCanvas. Das Beispiel hast Du ja schon gefunden. Was genau funktioniert denn nicht?



  • ich denke ich hab einfach probleme beim umschreiben, hab schon in der Borland hilfe geschaut, aber die obige lösung hat ja net geklappt..

    Leider..



  • Ja, aber WAS hat nicht geklappt? Wie äußert sich dieses nicht klappen? Gibt es eine Fehlermeldung? Wird einfach nichts gezeichnet? Worin versuchst Du zu zeichnen? Verwendest Du den richtigen Canvas? Machst Du das in der passenden Paint-Funktion?



  • Nur zur Klarheit: Wie genau äußert sich dieses "hat nicht geklappt"?

    (wenn ich mein Wissen über typische C-Bibliotheken zusammenkrame, gibst du denen im Ernstfall die Anzahl der bearbeiteten Objekte auf den Weg - deshalb hatte ich mich auch über die 3 bei deinem Polygon()-Aufruf gewundert, da du ein 4-Punkt-Polygon erstellen wolltest)



  • die 3 ist schon richtig bei einem 4 punkte polygon. da der parameter in Polygon() (der die anzahl der punkte angibt) immer um eins kleiner sein muss als die tatsächliche anzahl.

    keine ahnung warum das hier so komisch implementiert wurde.



  • Hab die genauen Fehlermeldungen leider nicht parat.

    Aber vielleicht etwas prinzipielles:
    Hatte Probleme dabei die delphi-komponente im cbuilder einzubinden.

    Hatte die FAQ-Hilfe schon gelesen.

    Also die Delphi-Pas-Datei hab ich anstatt der *.cpp - Datei includiert.
    dann muss man aber ein package auswählen, bzw. ein neues Package generieren.

    Was muss man dabei beachten?

    Sobald ich die Pas-Datei includiert hab, und compiliert hab, wird ja die entsprechende *.hpp - Datei generiert.
    wie muss ich diese denn verheiraten?



  • - bcb öffnne und alles was geöffnet wird wieder schliessen
    - menü komponente - komponente installieren
    - deine pascal-unit auswählen
    - package auswählen (sollte std-mässig: dclusr.bpk sein)
    - 'okay' klicken
    - im jetzt offenen fenster der package auf 'compilieren' klicken
    - dann sollte 'installieren' aktiviert sein
    - dort drauf klicken
    - du bekommst ne meldung ob die komponente installiert wurde oder nicht

    p.s. compilieren klappt natürlich nur, wenn die komponente keine zusätzlichen units benötigt die der bcb nicht kennt.



  • Ok,

    danke Sunday, werde es heute mittag mal ausprobieren,
    ich denke aber, dass ich es auch so gemacht hab, also standardmäßig in die dclusr.bpk gepackt hab.

    aber gut, probiere es nochmal aus.

    vielleicht noch eine prinzipielle frage:

    wie wird das icon für die komponente generiert?



  • entweder ist bei der komponente eins dabei oder es wird ein standard-icon verwendet.



  • Hi,

    also habe es geschafft die pas-Datei zu compilieren und habe es in einem neuen package installiert.
    scheint alles erfolgreich gelaufen zu sein, aber es erscheint kein symbol in der komponentenleiste.

    Weiß jemand was?



  • Guten Morgen, kann mir vielleicht jemand die delphi komponente in eine c++ - komponente umwandeln??

    bei mir klappt es leider nicht , wenn ich in das standard - package installiere.

    Die pas-Datei ist oben als code versehen.

    Wäre echt klasse, wenn jemand das konvertieren könnte!!



  • das ist diese pas-Datei.
    Wäre echt super!!

    **************************************************************************} 
    unit JDLed; 
    
    {$mode objfpc} 
    
    interface 
    
    uses 
      SysUtils, Classes, Controls, Graphics, Dialogs, 
      LMessages, LResources, Forms, StdCtrls; 
    
    type 
      TJDLed = class(TGraphicControl) 
      private 
        procedure SetLedDigit(value : integer); 
        procedure SetLedThick(value: integer); 
        { Private declarations } 
      protected 
        FDigit       : integer; 
        FThick       : integer; 
        procedure   Paint; override; 
        { Protected declarations } 
      public 
        constructor Create(AOwner: TComponent); override; 
        destructor  Destroy; override; 
        { Public declarations } 
      published 
        property Digit      : integer read FDigit  write SetLedDigit; 
        property Thick      : integer read FThick  write SetLedThick; 
        { Published declarations } 
      end; 
    
    implementation 
    
    constructor TJDLed.Create(AOwner: TComponent); 
    begin 
      inherited Create(AOwner);  { always call the inherited constructor } 
      FDigit  := 1; 
      FThick  := 5; 
      Height  := 90; 
      Width   := 50; 
      with Constraints do 
      begin 
        MinHeight := 30; 
        MinWidth  := 15; 
      end; 
    end; 
    
    destructor TJDLed.Destroy; 
    begin 
      inherited Destroy; 
    end; 
    
    procedure TJDLed.Paint; 
    var 
      X1,X2,X3,X4,X5,X6,X7,Z,Z1 : integer; 
    begin 
      X1 := self.Height; 
      X2 := self.Width; 
      X3 := self.FThick; 
      Z := abs(X3 div 2); 
      Z1 := abs(self.Height div 2); 
      X4 := Z1 - Z; 
      X5 := Z1 + Z; 
      X6 := Z1 - X3 - Z; 
      X7 := Z1 + X3 + Z; 
    
      inherited; 
      with Canvas do 
      begin 
        Refresh; 
        Brush.Color := clBlack; 
        Pen.Color := clBlack; 
        Refresh; 
    
        Rectangle(0,0,self.Width,self.Height); 
        Brush.Color := clRed; 
        Pen.Color := clRed; 
        Refresh; 
        case FDigit of 
    
        0: 
        begin 
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a 
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2- 
    X3,X6)]); //  b 
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3- 
    Z)]); //  c 
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3- 
    Z,X1)]); //  d 
          Polygon([Point(0,X5),Point(X3,X7),Point(X3,X1-X3-Z),Point(0,X1-Z)]); //  e 
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f 
        end; 
        1: 
        begin 
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2- 
    X3,X6)]); //  b 
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3- 
    Z)]); //  c 
        end; 
        2: 
        begin 
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a 
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2- 
    X3,X6)]); //  b 
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3- 
    Z,X1)]); //  d 
          Polygon([Point(0,X5),Point(X3,X7),Point(X3,X1-X3-Z),Point(0,X1-Z)]); //  e 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 4)),Point 
    (X2-X3-Z,Z1-Z - abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 4)),Point 
    (X2-X3-Z,Z1+Z + abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2 
        end; 
        3: 
        begin 
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a 
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2- 
    X3,X6)]); //  b 
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3- 
    Z)]); //  c 
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3- 
    Z,X1)]); //  d 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 4)),Point 
    (X2-X3-Z,Z1-Z - abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 4)),Point 
    (X2-X3-Z,Z1+Z + abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2 
        end; 
        4: 
        begin 
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2- 
    X3,X6)]); //  b 
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3- 
    Z)]); //  c 
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 2)),Point 
    (X2-X3-Z,Z1-Z - abs(Z div 2)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 2)),Point 
    (X2-X3-Z,Z1+Z + abs(Z div 2)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2 
        end; 
        5: 
        begin 
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a 
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3- 
    Z)]); //  c 
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3- 
    Z,X1)]); //  d 
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 4)),Point 
    (X2-X3-Z,Z1-Z - abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 4)),Point 
    (X2-X3-Z,Z1+Z + abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2 
        end; 
        6: 
        begin 
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a 
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3- 
    Z)]); //  c 
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3- 
    Z,X1)]); //  d 
          Polygon([Point(0,X5),Point(X3,X7),Point(X3,X1-X3-Z),Point(0,X1-Z)]); //  e 
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 4)),Point 
    (X2-X3-Z,Z1-Z - abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 4)),Point 
    (X2-X3-Z,Z1+Z + abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2 
        end; 
        7: 
        begin 
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a 
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2- 
    X3,X6)]); //  b 
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3- 
    Z)]); //  c 
        end; 
        8: 
        begin 
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a 
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2- 
    X3,X6)]); //  b 
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3- 
    Z)]); //  c 
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3- 
    Z,X1)]); //  d 
          Polygon([Point(0,X5),Point(X3,X7),Point(X3,X1-X3-Z),Point(0,X1-Z)]); //  e 
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f 
           Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 
    4)),Point(X2-X3-Z,Z1-Z - abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 4)),Point 
    (X2-X3-Z,Z1+Z + abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2 
        end; 
        9: 
        begin 
          Polygon([Point(Z,0),Point(X2-Z,0),Point(X2-X3-Z,X3),Point(X3 + 
    Z,X3)]); //  a 
          Polygon([Point(X2-X3,X3+Z),Point(X2,Z),Point(X2,X4),Point(X2- 
    X3,X6)]); //  b 
          Polygon([Point(X2-X3,X7),Point(X2,X5),Point(X2,X1-Z),Point(X2-X3,X1-X3- 
    Z)]); //  c 
          Polygon([Point(X3+Z,X1-X3),Point(X2-X3-Z,X1-X3),Point(X2-Z,X1),Point(X3- 
    Z,X1)]); //  d 
          Polygon([Point(0,Z),Point(X3,X3+Z),Point(X3,X6),Point(0,X4)]); //  f 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1-Z - abs(Z div 4)),Point 
    (X2-X3-Z,Z1-Z - abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g1 
          Polygon([Point(X3 - abs(Z div 2),Z1),Point(X3+Z,Z1+Z + abs(Z div 4)),Point 
    (X2-X3-Z,Z1+Z + abs(Z div 4)),Point(X2-X3 + abs(Z div 2),Z1)]); //  g2 
        end; 
       end; 
       Refresh;     
      end; 
    
    end; 
    
    procedure TJDLed.SetLedDigit(value: integer); 
    begin 
      if (value >= 0) and (value <= 9) then 
      begin 
        FDigit := value; 
        Paint; 
      end; 
    end; 
    
    procedure TJDLed.SetLedThick(value: integer); 
    begin 
      if (value > 2) then 
      begin 
        FThick := Value; 
        Paint; 
      end; 
    end; 
    
    initialization 
     {$I jdledicon.lrs} 
    
    end.
    

    Gruß Franky



  • schon mal auf die idee gekommen google zu verwenden und die komplette komponente runterzuladen?! dann klappts auch mit dem installieren.

    http://codecentral.borland.com/Item.aspx?id=19462



  • Hi,

    natürlich!
    Ich habe ja auch alle Dateien davon, aber ich hab es einfach nicht hinbekommen, die C++ - Komponente zu erzeugen.

    ich habe Fehlermeldungen bekommen, sofern ich das Standard-Package ausgewählt hab.

    das is ja leider das Problem.

    Mein Problem ist, dass das Konvertieren nicht funktioniert.
    Die Header-Datei kann ich ja erzeugen durch Kompilieren der *.pas - Datei.


Anmelden zum Antworten