Komponentenentwicklung für Fortgeschrittene

[Trantor]

Hallo alle miteinander,

ich weiss nicht ob ich in diesem Forum richtig bin , aber da meine Frage mit Komponenten zu tun hat dachte ich ich poste mal hier.


Mein konkretes Problem :

Für eine Anwendung brauche ich eine Image Komponente (Jpg Bilder), um die ich einen gut sichtbaren farbigen Rahmen (Farbe auch zur Laufzeit änderbar) habe.

Im Augeblick habe ich es durch eine TShape gelöst auf der ich das TImage plaziert habe.Das Problem dabei
ich will diese Indikatorkomponente auch zur Laufzeit erstellen können, und ausserdem brauche ich ziemlich viele davon was das ganze relativ groß aufbläht.

Meine Frage:

Hat wer eine bessere Idee wie das zu lösen sein könnte?

weiss jemand gute Tutorials zur Komponentenerstellung(Delphi source,Torryund die Doberenz Bücher gehen nicht gut genug darauf ein) in denen mal beschrieben ist wie man aus 2 Komponenten eine macht oder kann mich hier mal kurz auf die richtige Spur führen?


danke schonmal

grüßle aus dem Süden

Trantor

[_Sebastian_]

Kannst du den Rahmen nicht einfach selber zeichnen?
[edit]
Komponententutorial von Delphigl.com
Kennst du das Tut schon?

[Trantor]

ja das hab ich gestern schon mal gelesen,

der canvas ist ja dann der canvas der abgeleiteten timage - wenn ich darauf zeichne und danach ein bild einfüge ist doch der rahmen weg - oder wie meinst du das?

Trantor

[mkinzler]

Erst Bild einfügen, dann Rahmen zeichnen.

[Trantor]

es sind jpegs die sich zur laufzeit auch ändern - auf jpg bilder kann ich doch nicht zeichnen oder?.

[mkinzler]

Man zeichnet auch nicht auf dem Bild, sondern auf dem Canvas. Mit welcher komponenet lädst du die Jpegs? Noramlerwesie ist das nur ein Importfilter, welcher Jpegs in ein Bitmap lädt.
Du mußt sicherstellen, das bei jedem Neuzeichen auch der Rahemn neu gezeichnet wird.

[Trantor]

ich lade die Bilder über die .picture Property des Timage .
Kann ich von TImage nicht ne Komponente ableiten die das Bild einfach etwas kleiner einfügt als der Canvas des Timage ist? Wenn ja wie geht sowas bzw wo find ich ein tutorial wie sowas geht.

Oder muss ich den Canvas von Timage nach jeder Änderung neu zeichnen ( Rahmen und Bild ändern sich unabhängig voneinander)


ich steh grade irgendwie voll auf dem Schlauch

Trantor

[Alter Mann]

Hallo Trantor,

kleine Anregung, Änderungen erwünscht:

Delphi-Quellcode:

unit Unit2;

...

type
  TBorderImage = class(TCustomControl)
  private
     FFileName : String;
     FImage    : TImage;
     procedure SetFileName(Value : String);
  protected
     procedure Paint; override;
  public
     constructor Create(AOwner: TComponent); override;
     destructor  Destroy;                    override;
  published
     property FileName : String read FFileName write SetFileName;
  end;

implementation

constructor TBorderImage.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  Width          := 130;
  Height         := 100;
  Visible        := True;
  FFileName      := '';
  FImage         := TImage.Create(self);
  with FImage do
  begin
    AutoSize     := False;
    Center       := True;
    Proportional := True;
    Picture      := TPicture.Create;
    Left         := 2;
    Top          := 2;
  end;
  InsertControl(FImage);
  FImage.Width  := Width - 4;
  FImage.Height := Height - 4;
end;

destructor  TBorderImage.Destroy;
begin
  if FImage <> nil then FImage.Free;
  inherited Destroy;
end;

procedure TBorderImage.SetFileName(Value : String);
begin
  if (Value <> FFileName) and FileExists(Value) then
  begin
    FFileName   := Value;
    FImage.Picture.LoadFromFile(FFileName);
  end;
end;

procedure TBorderImage.Paint;
var
  PaintRect: TRect;
begin
  PaintRect := GetClientRect;
  inherited Paint;
  Canvas.Pen.Color := clBlue;
  Canvas.Rectangle(0, 0, PaintRect.Right, PaintRect.Bottom);
end;

Und verwendet wird es wie folgt:

Delphi-Quellcode:

unit Unit1;
...
implementation

uses unit2;

var
  BI : TBorderImage;

procedure TForm1.Button1Click(Sender: TObject);
begin
  if OpenDialog1.Execute then
  begin
    BI.FileName := OpenDialog1.FileName;
  end;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  BI := TBorderImage.Create(Form1);
  Form1.InsertControl(BI);
  BI.Left := 10;
  BI.Top  := 10;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  BI.Free;
end;

[MaBuSE]

Zitat von Alter Mann:

Hallo Trantor,
kleine Anregung, Änderungen erwünscht:

Hallo Trantor,
hallo Alter Mann,

ich würde das etwas anders machen.

Alter Man erzeugt eine Komponente und packt in diese Komponente das original TImage.

Ich würde eine grafische Komponente erzeugen und dort ein TPicture einfügen, das dann in Paint angezeigt wird. Das ist etwas resourcenschonender und auch nicht so viel komplizierter.
Die meisten Zeilen gehen für das Zuweisen der Eigenschaften drauf
Ich habe das mal kurz "runtergeschrieben":

Delphi-Quellcode:

////////////////////////////////////////////////////////////////////////////////
// TMyImage v1.0
//
// Beispielkomponente um zu zeigen wie in einer grafischen Komponente
// (TGraphicControl) auf den Bildschirm gezeichnet werden kann.
//
// Die Komponente zeigt das Bild das TPicture zugewiesen wird an.
// Um dieses Bild wird ein Rahmen gezeichnet. Das Aussehen des Rahmens kann
// mit den Eigenschaften Border* bestimmt werden.
// Es wurden nur die Basis Funktionalitäten von TImage nachgebaut.
// Das ist ein Programmierbeispiel, keine erinsatzfähige Komponente.
//
// Das Beispiel entstand im Rahmen folgenden Beitrags aus [url]www.delphipraxis.net:[/url]
// [url]http://www.delphipraxis.net/topic95229_komponentenentwicklung+fuer+fortgeschrittene.html[/url]
//
////////////////////////////////////////////////////////////////////////////////
// Die Komponente ist Freeware und darf beliebig benutzt und erweitert werden.
// Es wäre nett, wenn dann auch der geänderte Quelltext in obiges URL-Adresse
// gesendet wird. Dann haben alle was davon.
// Es wäre auch nett wenn mein (unser) Name in den Dateien enthalten bleibt.
// Die Komponente wird von Ihnen auf eigenes Risiko eingesetzt. Ich übernehme
// keine Haftung für Schäden die durch die Komponente oder die Benutzung der
// Komponente entstanden sind bzw. entstehen.
////////////////////////////////////////////////////////////////////////////////
// (C) 2006, MaBuSE, member of DelphiPraxis.net
////////////////////////////////////////////////////////////////////////////////
// ReleaseNotes:
// v1.0 - 26.10.2006 - MaBuSE:      Erste Version war in 15 min programmiert
////////////////////////////////////////////////////////////////////////////////
unit MyImage;

interface

uses
  SysUtils, Classes, Controls, ExtCtrls, Graphics, Types;

type
  TMyImage = class(TGraphicControl)
  private
    { Private-Deklarationen }
    FBorderColor: TColor;
    FBorderStyle: TPenStyle;
    FBorderVisible: Boolean;
    FBorderWidth: Integer;
    FPicture: TPicture;
    FStretch: Boolean;
    function DestRect: TRect;
    procedure PictureChanged(Sender: TObject);
    procedure SetBorderColor(const Value: TColor);
    procedure SetBorderStyle(const Value: TPenStyle);
    procedure SetBorderVisible(const Value: Boolean);
    procedure SetBorderWidth(const Value: Integer);
    procedure SetPicture(const Value: TPicture);
    procedure SetStretch(const Value: Boolean);
  protected
    { Protected-Deklarationen }
    procedure Paint; override;
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property BorderColor: TColor read FBorderColor write SetBorderColor;
    property BorderStyle: TPenStyle read FBorderStyle write SetBorderStyle;
    property BorderVisible: Boolean read FBorderVisible write SetBorderVisible;
    property BorderWith: Integer read FBorderWidth write SetBorderWidth;
    property Picture: TPicture read FPicture write SetPicture;
    property Stretch: Boolean read FStretch write SetStretch;
    property OnClick;
    property OnDblClick;
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('Beispiele', [TMyImage]);
end;


{ TMyImage }

// Der Konstruktor erzeugt ein TPicture, dass das Bild beinhalten wird.
// TPicture hat ein OnChange Ereignis, dass uns benachichtigt, wenn sich das
// Bild geändert hat. Es wird dann PictureChanges aufgerufen.
constructor TMyImage.Create(AOwner: TComponent);
begin
  inherited;
  FPicture := TPicture.Create;
  FPicture.OnChange := PictureChanged;
  Height := 105;
  Width := 105;
  FBorderColor := clRed;
  FBorderStyle := psSolid;
  FBorderVisible := True;
  FBorderWidth := 1;
  FStretch := False;
end;

// Hier wird das Rechteck festgelegt, in das das Bild geszeichnet wird.
// Es ist ein "einfaches" Stretch programmiert
//   Stretch := True  -> Das Rechteck hat die Maße der Komponente
//   Stretch := False -> Das Rechteck hat die Maße der Grafik
// Natürlich könnte man da noch Propertional und Center berücksichtigen ;-)
function TMyImage.DestRect: TRect;
begin
  with Result do
  begin
    Left := 0;
    Top := 0;
    if FStretch then
    begin
      Right := ClientWidth;
      Bottom := ClientHeight;
    end
    else
    begin
      Right := Picture.Width;
      Bottom := Picture.Height;
    end;
  end;
end;

destructor TMyImage.Destroy;
begin
  FPicture.Free;
  inherited;
end;

// Diese Methode zeichnet die Komponente
// zuerst wird das Bild gezeichnet, danach der Rahmen
procedure TMyImage.Paint;
begin
  try
    with Canvas do
    begin
      StretchDraw(DestRect, Picture.Graphic);
    end;
  except
  end;

  if FBorderVisible then
  with Canvas do
  begin
    Pen.Color := FBorderColor;
    Pen.Style := FBorderStyle;
    Pen.Width := FBorderWidth;
    Brush.Style := bsClear;
    Rectangle(0, 0, Width, Height);
  end;
end;

// Diese Methode sorgt dafür, dass die Komponente neu gezeichnet wird.
// Hier können später noch Anweisungen rein, die bei jeder Bildänderung
// durchgeführt werden sollen.
procedure TMyImage.PictureChanged(Sender: TObject);
begin
  Invalidate;
end;

// Alle Eigenschaften haben eine Methode zum Setzen des Wertes
// Diese Methode wird nur benötigt, da PictureChaged aufgerufen werden soll,
// damit die Komponente sich neuzeichnet.

procedure TMyImage.SetBorderColor(const Value: TColor);
begin
  FBorderColor := Value;
  PictureChanged(self);
end;

procedure TMyImage.SetBorderStyle(const Value: TPenStyle);
begin
  FBorderStyle := Value;
  PictureChanged(self);
end;

procedure TMyImage.SetBorderVisible(const Value: Boolean);
begin
  FBorderVisible := Value;
  PictureChanged(self);
end;

procedure TMyImage.SetBorderWidth(const Value: Integer);
begin
  FBorderWidth := Value;
  PictureChanged(self);
end;

procedure TMyImage.SetPicture(const Value: TPicture);
begin
  FPicture.Assign(Value);
end;

procedure TMyImage.SetStretch(const Value: Boolean);
begin
  FStretch := Value;
  PictureChanged(self);
end;

end.

[Trantor]

Hallo Alter Mann
Hallo Mabuse,

@alter Mann danke , deine Lösung hat mich mal auf die richtige Richtung geführt - und mir den weg gezeigt.

@mabuse,

ok jetzt bin ich neidisch und dankbar - (kniefall) - das ist genau die Kompo die ich seit nem halben Jahr suche.
Leider bin ich nicht so fit das in 15 Minuten zu programmieren- ich hätte jetzt sicher noch einiges länger gebraucht .

Jetzt jetzt muss ich nur ncoh ein onclick einfügen und es ist genau das wa sich brauch.

supervielen dank.

Trantor