In HintWindowClass eigenes Form verwenden

[taaktaak]

Moin, Moin,
hier https://www.delphipraxis.net/94518-k...-anzeigen.html hat Sirius vor vielen Jahren einen Weg aufgezeigt, wie in einem Hint auch ein eigenes Bitmap angezeigt werden kann. In abgewandelter Form nutze ich das seit langer Zeit. Nun bin ich ein wenig am basteln und mich stört, das mein neu definiertes Hintwindow weder eigene Methoden noch Properties veröffentlichen kann. Ich hätte gern so etwas...

Delphi-Quellcode:

type TrzHintWindow = class(THintWindow)                       // by sirius [DelphiPraxis] "Kleines Icon bei Hint anzeigen"
                     private                                  // :-)                      Juni 2007

                      FText                    : String;
                      FGutter,Dh,
                      FMaxWH,FDrawW,FDrawH     : Integer;
                      FHintBitmap              : TBitmap;

                     protected

                      procedure   Paint;                                                                  override;

                     public

                      // -----------------------------------------------------------------------------------------
                      property    HintBitmap   : TBitmap read FHintBitmap write FHintBitmap; // funktioniert nicht
                      // -----------------------------------------------------------------------------------------

                      function    CalcHintRect (MaxWidth:Integer;const AHint:String;AData:Pointer):TRect; override;
                      constructor Create       (AOwner:TComponent);                                       override;
                     end;

var  HintBMP       : TBitmap; // "Schnittstelle" zu TrzHintWindow nur über GLOBALE Variable möglich

Derzeit kann ich das individuelle Bitmap nur via globaler Variable übergeben.
Das funktioniert zwar - aber schön ist das ja nicht.
Gibt es einen "richtigen" Weg?

[Olli73]

Wirklich Delphi 7?

Also bei neuerem Delphi und wenn du innerhalb der Applikation immer das gleiche Bitmap anzeigen willst, würde ich eine Class var / property machen.

Sollten es unterschiedliche Bitmaps sein, könntest du Application.OnShowHint verwenden und THintInfo.HintData nutzen:

https://docwiki.embarcadero.com/Code...wHint_(Delphi)
https://docwiki.embarcadero.com/Libr...rols.THintInfo

[taaktaak]

Moin, Moin,
vielen Dank für die Antwort.

Ja, ich bin ein alter Starrkopf und nutze immer noch Delphi 7

Die möglich Übergabe des anzuzeigenden Bitmps via THintInfo.HintData ist für mich kaum besser als die globale Variable zu nutzen. Ich hatte gedacht, dass es vielleicht möglich ist, wie mit einer "normalen" Klasse zu arbeiten. Aber ich lebe jetzt schon so viele Jahre mit der globalen Variable, das geht auch noch länger.

Mein "Weltbild" ist folgendes
So wie ich die Situation verstehe, wird in der "sirius-Lösung" der bereits laufenden HintWindow-Instanz einfach ein anderes Codegerüst untergeschoben. Da das gar nicht vom Nutzer (VCL?) bemerkt wird, ist natürlich ein verändertes Interface nicht nutzbar. Man müsste also die bereits laufende Instanz beenden und die neue Klasse (durch VCL?) neu starten lassen können.

Meine Vermutungen sind vermutlich entweder völlig falsch oder nur die halbe Wahrheit...

[Olli73]

So wie ich das verstehe, sagst du Delphi, welche (abgeleitete) Klasse du für Hints benutzen möchtest. Delphi erzeugt dann jedes Mal, wenn ein Hint angezeigt werden soll, eine Instanz genau dieser Klasse.

Innerhalb der Instanz kannst du dann z.B. ein Bitmap zeichnen.

[Gausi]

Das mit dem HintData ist aber der Weg, den Windows da vorgibt. Dafür braucht man dann auch keine globalen Variablen o.ä.. Wenn der Hint angezeigt werden soll, werden über das HitInfo-Konstrukt die Daten übergeben, die die HintWindow-Klasse (bzw. die gerade erzeugt Instanz) zum Zeichnen benötigt.

Das lässt sich natürlich auch in eigene (oder fremde) Controls auslagern, so dass man nicht immer das Application-Objekt dafür heranziehen muss. Das geht dann aber afaik nicht direkt mit TForm.

Ich hab z.B. für meinen Player neulich die Hints im VirtualStringTrees ein wenig erweitert. Der VST bietet da ja ein solides Grundgerüst, um das Hintfenster komplett selbst zu malen.

Da läuft das im Prinzip so, dass in procedure CMHintShow(var Message: TCMHintShow); message CM_HINTSHOW; des VirtualStringTree die HintWindow-Klasse bestimmt wird (eben die vom VST definierte zum Selbermalen, nicht die Standard-Klasse), und dann das HintData-Konstrukt mit allen Infos gefüllt wird, die hinterher im Paint nützlich sein können - u.a. der Tree , der den Hint anzeigen soll, und dazu Infos zum Knoten, Spalte etc. pp.
Im Paint des HintWindow wird dann im Wesentlichen HintData.Tree.OnDrawHint(...) aufgerufen, so dass die Anwendung sich in dem Eventhandler um das Zeichnen des Hints kümmern kann - inkl. aller Daten, Bitmaps, sonstwas, die an dem Knoten hängen, der im HintData verknüpft ist.

Alternativ könnte man in dem OnDrawHint-Event einer eigenen Komponente natürlich auch diverse Var-Parameter mitgeben (u.a. ein Bitmap?) welche dann von der Paint-Methode des HintWindow verarbeitet und passend an eine vordefinierte Stelle gezeichnet werden.

Oder eben im OnShowHint der Application alles mitgeben, was du zum Zeichnen brauchst - das könnte ja auch ein fertiges Bitmap sein (inkl. Hinttext und allem), das das HintWindow nur noch auf sein Canvas kopiert.

[taaktaak]

Moin, Moin,
interessante Aspekte. Habe jetzt einmal den Weg ausprobiert das Bitmap über HintInfo.HintData zu übergeben. Das funktioniert und ich benötige die globale Variable nicht mehr. Da sind aber noch Macken, bin daher nicht überzeugt von diesem "offiziellen" Weg.

Gausi schreibt ...

Zitat:

Alternativ könnte man in dem OnDrawHint-Event einer eigenen Komponente natürlich auch diverse Var-Parameter mitgeben (

Das ist ja eigentlich das, was ich möchte. Aber wie sorge ich dafür, dass die neue Komponente die Aufgabe des HintWindow übernimmt?

[Gausi]

Wirklich konkret kann ich da nicht werden. Schau mal in den Code von VirtualTreeView rein, wie da das Konzept läuft.
Es muss halt irgendwas geben, was der HintWindow-Klasse bekannt ist und auch der Komponente (oder Application), die dieses HintFenster benutzen soll. Beim VST ist das der VST selbst.

Evtl. klappt es, wenn man im Application.OnShowHint dem THintInfo.HintData einen Methodenzeiger mit einer passenden Signatur übergibt, der dann im Paint des Hints aufgerufen wird.

[taaktaak]

Moin, Moin,
vielen Dank für die Anregungen - 'mal schauen, was ich davon realisieren werde.