wollte mal fragen, ob es ohne Probleme möglich wäre einen vorhandenen Delphi-Code in C/C++ umzusetzen?

Ich bin auf der Suche nach Baloontips. Habe zu Delphi tausende von Inhalten gefunden, jedoch nichts zum Builder, weder unter Suchmaschinen, noch hier im Forum.

Fall jemand eine Freeware Komponente hätte würde mir die auch reichen, ansonsten wollte ich mal fragen, ob das hier jemand schafft zu übersetzen?

{....}

uses Commctrl;

{....}

const
  TTS_BALLOON    = $40;
  TTM_SETTITLE = (WM_USER + 32);

var
  hTooltip: Cardinal;
  ti: TToolInfo;
  buffer : array[0..255] of char;

{....}

procedure CreateToolTips(hWnd: Cardinal);
begin
  hToolTip := CreateWindowEx(0, 'Tooltips_Class32', nil, TTS_ALWAYSTIP or TTS_BALLOON,
    Integer(CW_USEDEFAULT), Integer(CW_USEDEFAULT), Integer(CW_USEDEFAULT),
    Integer(CW_USEDEFAULT), hWnd, 0, hInstance, nil);
  if hToolTip <> 0 then
  begin
    SetWindowPos(hToolTip, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE or
      SWP_NOSIZE or SWP_NOACTIVATE);
    ti.cbSize := SizeOf(TToolInfo);
    ti.uFlags := TTF_SUBCLASS;
    ti.hInst  := hInstance;
  end;
end;

procedure AddToolTip(hwnd: DWORD; lpti: PToolInfo; IconType: Integer;
  Text, Title: PChar);
var
  Item: THandle;
  Rect: TRect;
begin
  Item := hWnd;
  if (Item <> 0) and (GetClientRect(Item, Rect)) then
  begin
    lpti.hwnd := Item;
    lpti.Rect := Rect;
    lpti.lpszText := Text;
    SendMessage(hToolTip, TTM_ADDTOOL, 0, Integer(lpti));
    FillChar(buffer, SizeOf(buffer), #0);
    lstrcpy(buffer, Title);
    if (IconType > 3) or (IconType < 0) then IconType := 0;
    SendMessage(hToolTip, TTM_SETTITLE, IconType, Integer(@buffer));
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  CreateToolTips(Form1.Handle);
  AddToolTip(Memo1.Handle, @ti, 1, 'Tooltip text', 'Title');
end;

{
IconType can be:

 0 - No icon
 1 - Information
 2 - Warning
 3 - Error
}

Danke im voraus und Gruß Gerd

http://www.c-plusplus.net/forum/viewtopic-var-t-is-113829-and-highlight-is-balloon.html

nachtrag: ich glaub ich hab das jetzt verwechselt, naja macht nix, vlei hilft dir der link ja trotzdem...

Das ganze ist auch ein bisschen schwerer und auch nicht wirklich Borland sprezifisch. Das tendiert also eher Richtung WinAPI.

Ich hab aber in einem Projekt mal für den Borland Balloontips verwendet. Ich packe hier mal den Code rein, vielleicht hilfts dir!

// In der Header
BEGIN_MESSAGE_MAP  // needed for tray icon (messages)
MESSAGE_HANDLER(WM_DRAWITEM, TMessage,DrawItem)
//MESSAGE_HANDLER(MYWM_NOTIFY,TMessage,MyNotify)
END_MESSAGE_MAP(TForm)

// In der cpp
LRESULT IconDrawItem(LPDRAWITEMSTRUCT lpdi)
{
   HICON hIcon;

   hIcon = (HICON)LoadImage(g_hinst, MAKEINTRESOURCE(lpdi->CtlID), IMAGE_ICON,
		16, 16, 0);
   if (!hIcon)
      return(FALSE);

   DrawIconEx(lpdi->hDC, lpdi->rcItem.left, lpdi->rcItem.top, hIcon,
		16, 16, 0, NULL, DI_NORMAL);

   return(TRUE);
}
//---------------------------------------------------------------------------

void __fastcall TMainForm::DrawItem(TMessage& Msg)
{
     IconDrawItem((LPDRAWITEMSTRUCT)Msg.LParam);
     TForm::Dispatch(&Msg);
}
//---------------------------------------------------------------------------

bool __fastcall TMainForm::BalloonTip(AnsiString title, AnsiString text)
{
   NOTIFYICONDATA tnd;

   tnd.cbSize           = sizeof(NOTIFYICONDATA);
   tnd.hWnd             = Handle;
   tnd.uID              = IDC_MYICON;
   tnd.uFlags           = NIF_INFO;
   tnd.dwInfoFlags      = NIIF_INFO;
   tnd.uCallbackMessage	= MYWM_NOTIFY;
   tnd.uTimeout = 1000; // in milliseconds *10?

   lstrcpyn(tnd.szTip, "Der 'mit-der-Maus-drüberfahr-Text' muss hier rein", sizeof(tnd.szTip));
   lstrcpyn(tnd.szInfoTitle, title.c_str(), sizeof(tnd.szInfoTitle));

   tnd.hIcon		= Application->Icon->Handle;// oder irgend ein anderer Icon

   lstrcpyn(tnd.szInfo, text.c_str(), sizeof(tnd.szInfo));

   return (Shell_NotifyIcon(NIM_MODIFY, &tnd));
}
//---------------------------------------------------------------------------

bool __fastcall TMainForm::TrayMessage(DWORD dwMessage)
{
   NOTIFYICONDATA tnd;

   tnd.cbSize           = sizeof(NOTIFYICONDATA);
   tnd.hWnd             = Handle;
   tnd.uID              = IDC_MYICON;
   tnd.uFlags           = NIF_MESSAGE | NIF_ICON | NIF_TIP;
   tnd.uCallbackMessage	= MYWM_NOTIFY;

   if (dwMessage == NIM_MODIFY)
    {
        tnd.hIcon	= Application->Icon->Handle; // oder irgend ein anderer Icon
        lstrcpyn(tnd.szTip, "Der 'mit-der-Maus-drüberfahr-Text' muss hier rein", sizeof(tnd.szTip));
    }
   else
    {
        tnd.hIcon = NULL;
        tnd.szTip[0] = '\0';
    }

   return (Shell_NotifyIcon(dwMessage, &tnd));
}
//---------------------------------------------------------------------------

// Im Konstruktor von deinem Haupt-Formular
TrayMessage(NIM_ADD);  // TrayIcon hinzufügen
TrayMessage(NIM_MODIFY);

// Im Destruktor von deinem Haupt-Formular
TrayMessage(NIM_DELETE);

// Von egal wo
BalloonTip("Ich bin der Titel", "Und ich bin der fette Text in der Mitte");

Wie gesagt, hoffe es hilft.
Das sieht so erstmal ziemlich mächtig aus, aber keine Angst! Im wesentlichen musste nur die 3 Aufrufe im Konstruktor und Destruktor plazieren und dann kannste mit der BalloonTip()-Funktion deine Texte absetzen.
In der Header-Dateihab ich noch eine Notify()-Callbackfunktion deklariert (die auskommentierte Zeile), die mir die Mausklicks auf den TryIcon signalisiert.

Viel Spass damit

gruß gerd

hallo,

ich habe versucht deinen code in mein projekt einzubinden. jedoch ohne erfolge.
er mosert beim kompilieren rum, dass er DrawItem nicht kennt:

habe dies in der header im public bereich reinkopiert:

public:
    [...]
    // In der Header
    BEGIN_MESSAGE_MAP  // needed for tray icon (messages)
    MESSAGE_HANDLER(WM_DRAWITEM, TMessage,DrawItem)
    //MESSAGE_HANDLER(MYWM_NOTIFY,TMessage,MyNotify)
    END_MESSAGE_MAP(TForm)

er kennt allerdings kein g_inst, IDC_MYICON vieleicht auch weitere

fehlen da eventuell noch einige konstanten? muss da dringend noch etwas inkludiert werden?

achja, ist es jetzt so, dass der ballon weggeklickt werden kann, wäre nämlich von Vorteil.

gruß gerd

public:	[...]
        void __fastcall DrawItem(TMessage& Msg);
        void __fastcall MyNotify(TMessage& Msg);
        bool __fastcall TrayMessage(DWORD dwMessage);
        bool __fastcall BalloonTip(AnsiString title, AnsiString text);

Und in der gleichen Headerdatei ganz oben müssen noch ein paar andere Geschichten definiert werden:

#define MYWM_NOTIFY (WM_APP+100)    
#define IDC_MYICON 1006 
extern HINSTANCE g_hinst;                    
LRESULT IconDrawItem(LPDRAWITEMSTRUCT lpdi); ///< Callback function

Dann sollte das gehen, sofern ich nicht nochwas übersehen hab...

hallo,

habe es jetzt ergänzt, funktioniert auch soweit prima. hatte zwar schon selber die f-prototypen drin, nur leider den nicht von DrawItem.

allerdings bekomme ich das fenster immer nur im tray, ich hätte es allerdings gern so:

http://www.swissdelphicenter.ch/de/showcode.php?id=1555

haste da noch ne möglichkeit es dort hinzubekommen, als beim entsprechenden control?

achja: funktioniert das ganze auch unter 2000 und 98?

gruß gerd

Ich denke, das geht nur unter xp... Vielleicht noch 2000, aber ich meine nicht, na und 98 auf gar keinen Fall

@el Clio:

ist es vielleicht auch möglich das icon der TTrayIcon komponente dafür zu nutzen? oder aber eventuell ein popup menu auf das icon zu setzen? ich habe schon etwas versucht zu fummeln, leider ohne erfolg. da reichen meine winapi kenntnisse nicht aus. (schade eigentlich)

kannst du da eventuell nochmal nen tipp geben, sodass ich auf das ergebnis komme?

vielen dank und gruß im voraus

gerd

Mit dem PopUp-Menü geht auf jeden Fall. Den genauen Code kann ich dir allerdings nicht geben, weil mein Laptop momentan zur Reparatur ist und ich deshalb nicht an den Quellcode kommen.

Der erste Schritt ist aber eine "Notify"-Routine die über die auskommentierte Messagemap (in meinen letzten Beiträgen) zugewiesen wird:

MESSAGE_HANDLER(MYWM_NOTIFY,TMessage,MyNotify)

im Code:

public:
    [...]
    // In der Header
    BEGIN_MESSAGE_MAP  // needed for tray icon (messages)
    [...]
    MESSAGE_HANDLER(MYWM_NOTIFY,TMessage,MyNotify)
    END_MESSAGE_MAP(TForm)

Die dazugehörige Funktion sieht so aus:

public:    [...]
        void __fastcall MyNotify(TMessage& Msg);

Die Funktion wird aufgerufen, wenn irgendwas (egal was) mit dem Icon passiert.
In "Msg" steht dann auch drin, obs ein linker oder rechter Mausklick war.
Dann kannste einfach ein PopUp-Menü öffnen...

Genauer gehts im Moment leider nicht... Vielleicht mal nach "MyNotify(TMessage& Msg)" googlen...

Viel Erfolg!

Falls es nicht klappt un ich meinen Lappi wieder habe guck ich auch nochmal nach!!!

gruß gerd

habe etwas gefunden, funzt auch prima, nur müsste ich jetzt noch ein bestimmtes icon dafür haben, nicht unbedingt das application icon.

kann ich auch icons nehmen, welche in einer imagelist als bmps drin sind?

gruß gerd

ps: hier die lösung:

void __fastcall TForm1::MyNotify(TMessage& Msg)
{
    POINT MousePos;

    switch(Msg.LParam)
    {
        case WM_RBUTTONUP:
            if (GetCursorPos(&MousePos))
            {
                PopupMenu1->PopupComponent = Form1;
                SetForegroundWindow(Handle);
                PopupMenu1->Popup(MousePos.x, MousePos.y);
            }
            else
                Show();
            break;
        case WM_LBUTTONUP:
            ToggleState();
            break;
        default:
            break;
    }
    TForm::Dispatch(&Msg);

Welches Icon du nimmst ist egal musste halt anpassen in:

bool __fastcall TMainForm::TrayMessage(DWORD dwMessage)
{
   [...]
        tnd.hIcon    = Application->Icon->Handle; // oder irgend ein anderer Icon
   [...]
}
//---------------------------------------------------------------------------

Die Imagelist-Bilder sollten ja auch kein Problem darstellen. Gibts da nicht ne Funktion GetIcon() oder so, die direkt ein Icon von nem Bitmap zurückgibt...

Du schaffst das!

Wenn das alles fertig ist würd ich übrigens gerne mal deine komplettlösung sehen

werde wenn alles fertig alles posten!

gruß gerd

eine frage stellt sich mir, wie bekomme ich einen message handler hin, der mir beim minimze die möglichkeit gibt, darauf zu reagieren?

ps: mit dem Icon muss ich noch etwas testen.

du hattest recht, TImageList hat die möglichkeit ein icon zu liefern:

TIcon *ic = new TIcon();
ImageList1->GetIcon(0,ic);

nur fehlt mir jetzt noch der handle auf ic.

vielleicht muss ich es aber dann, da mir das oberste vielleicht doch probleme bereitet auf eine ressource zurückgreifen, welche ich einlinke.

gruß gerd

ok, hatte (so dachte ich) die möglichkeit gefunden, funzt nur leider nicht so, wie gedacht:

eine eigene memberfunktion ins formular rein, und über:

Application->OnMinimize = Eigene_Memberfunktion

zuweisen:

dann in dieser funktion einfach nur ein:

Hide();

einbringen. Klappt anfangs sehr schön, aber nach einiger Zeit nicht mehr. Vielleicht mache ich auch nur etwas falsch. natürlich habe ich noch beim abfangen von MyNotify ein :

Show();
Application->Restore();

drin, aber irgendwie ist das kein richtiger ansatz, siehe oben beschriebenes Problem.

naja, war nur zur info.

gruß gerd

*derweiteraufdersucheist*

Hide();

wenn man nämlich statt dem einfach die API-Funktion:

ShowWindow(Application->Handle, SW_HIDE);

aufruft, spinnt es nicht mehr herum.

*hoffentlich liege ich richtig*

gruß gerd

vielleicht nicht die elegantesten lösungen, aber es erfüllt alles seinen zweck. Wer etwas zu verbessern hat, soll es ruhig dazu beitragen, damit ich fehler erkenne! Danke.

hier nochmal als einfachstes beispiel, damit nur code kopieren, und routinen implementieren, damit man auch sieht, was man alles braucht:

Headerdatei:

//---------------------------------------------------------------------------

#ifndef mainH
#define mainH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ImgList.hpp>
#include <Menus.hpp>
#define MYWM_NOTIFY WM_USER
#define IDC_MYICON 1006

//---------------------------------------------------------------------------
class TfrmMain : public TForm
{
__published:	// Von der IDE verwaltete Komponenten
    TPopupMenu *TrayPop;
    TMenuItem *Wiederherstellen1;
    TImageList *ImageList1;
    void __fastcall FormCreate(TObject *Sender);
    void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
    void __fastcall FormClick(TObject *Sender);
private:	// Anwender-Deklarationen
public:		// Anwender-Deklarationen
    __fastcall TfrmMain(TComponent* Owner);
    TIcon* ic;
    BEGIN_MESSAGE_MAP  // needed for tray icon (messages)
    MESSAGE_HANDLER(WM_DRAWITEM, TMessage,DrawItem);
    MESSAGE_HANDLER(MYWM_NOTIFY,TMessage,MyNotify);
    END_MESSAGE_MAP(TForm)
    void __fastcall DrawItem(TMessage& Msg);
    // MySize: wenn die Anwenung minimiert wird
    void __fastcall MySize(TObject *Sender);
    void __fastcall MyNotify(TMessage& Msg);
    bool __fastcall TrayMessage(DWORD dwMessage);
    bool __fastcall BalloonTip(AnsiString title, AnsiString text,int flag);
    // flag bitte mit (NIIF_ERROR,NIIF_WARNING,NIIF_INFO...) füttern
};
//---------------------------------------------------------------------------
extern PACKAGE TfrmMain *frmMain;
//---------------------------------------------------------------------------
#endif

Quelldatei:

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "main.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TfrmMain *frmMain;
HINSTANCE g_hinst; 
LRESULT IconDrawItem(LPDRAWITEMSTRUCT lpdi); ///< Callback function 
//--------------------------------------------------------------------------- 
LRESULT IconDrawItem(LPDRAWITEMSTRUCT lpdi) 
{ 
   HICON hIcon; 
   hIcon = (HICON)LoadImage(g_hinst, MAKEINTRESOURCE(lpdi->CtlID), IMAGE_ICON, 
        16, 16, 0); 
   if (!hIcon) 
      return(FALSE); 

   DrawIconEx(lpdi->hDC, lpdi->rcItem.left, lpdi->rcItem.top, hIcon, 
        16, 16, 0, NULL, DI_NORMAL); 

   return(TRUE); 
} 
//--------------------------------------------------------------------------- 

void __fastcall TfrmMain::DrawItem(TMessage& Msg) 
{ 
     IconDrawItem((LPDRAWITEMSTRUCT)Msg.LParam); 
     TForm::Dispatch(&Msg); 
} 

//---------------------------------------------------------------------------
void __fastcall TfrmMain::MySize(TObject *Sender)
{
    ShowWindow(Application->Handle, SW_HIDE);
}
//--------------------------------------------------------------------------- 
void __fastcall TfrmMain::MyNotify(TMessage& Msg) 
{ 
    POINT MousePos; 
    switch(Msg.LParam) 
    { 
        case WM_RBUTTONUP: 
            if (GetCursorPos(&MousePos)) 
            { 
                TrayPop->PopupComponent = frmMain;
                SetForegroundWindow(Handle); 
                TrayPop->Popup(MousePos.x, MousePos.y); 
            } 
            else
                Show();
            break;
        case WM_LBUTTONUP:
            //TrayMessage(NIM_MODIFY);
            break;
        case WM_LBUTTONDBLCLK:
            Application->Restore();//TrayMessage(NIM_MODIFY);
            Show();
            frmMain->SetFocus();
            break; 
        default: 
            break; 
    } 
    TForm::Dispatch(&Msg); 
} 
//--------------------------------------------------------------------------- 
bool __fastcall TfrmMain::BalloonTip(AnsiString title, AnsiString text,int flag) 
{ 
    TIcon * ic = new TIcon(); 
    ImageList1->GetIcon(0,ic);
    NOTIFYICONDATA tnd; 

    tnd.cbSize           = sizeof(NOTIFYICONDATA); 
    tnd.hWnd             = Handle; 
    tnd.uID              = IDC_MYICON; 
    tnd.uFlags           = NIF_INFO; 
    tnd.dwInfoFlags      = flag; 
    tnd.uCallbackMessage    = MYWM_NOTIFY; 
    tnd.uTimeout = 1000; // in milliseconds *10? 

    lstrcpyn(tnd.szTip, "was auch immer", sizeof(tnd.szTip)); 
    lstrcpyn(tnd.szInfoTitle, title.c_str(), sizeof(tnd.szInfoTitle)); 
    tnd.hIcon        = ic->Handle;
    lstrcpyn(tnd.szInfo, text.c_str(), sizeof(tnd.szInfo)); 
    return (Shell_NotifyIcon(NIM_MODIFY, &tnd)); 
} 
//--------------------------------------------------------------------------- 
bool __fastcall TfrmMain::TrayMessage(DWORD dwMessage) 
{ 
    TIcon * ic = new TIcon(); 
    ImageList1->GetIcon(0,ic);
    NOTIFYICONDATA tnd; 

    tnd.cbSize           = sizeof(NOTIFYICONDATA); 
    tnd.hWnd             = Handle; 
    tnd.uID              = IDC_MYICON; 
    tnd.uFlags           = NIF_MESSAGE | NIF_ICON | NIF_TIP; 
    tnd.uCallbackMessage    = MYWM_NOTIFY; 

    if (dwMessage == NIM_MODIFY) 
    { 
        tnd.hIcon    =  ic->Handle;//Application->Icon->Handle;// oder irgend ein anderer Icon 
        lstrcpyn(tnd.szTip, "was auch immer", sizeof(tnd.szTip)); 
    } 
    else 
    { 
        tnd.hIcon = NULL; 
        tnd.szTip[0] = '\0';
    }
    return (Shell_NotifyIcon(dwMessage, &tnd));
}
//---------------------------------------------------------------------------
__fastcall TfrmMain::TfrmMain(TComponent* Owner)
    : TForm(Owner)
{
    TrayMessage(NIM_ADD);  // TrayIcon hinzufügen
    TrayMessage(NIM_MODIFY); 
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::FormCreate(TObject *Sender)
{
    Application->OnMinimize = MySize;
    TIcon* ic=new TIcon();
    ic = NULL;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::FormClose(TObject *Sender, TCloseAction &Action)
{
    Action = caFree;
    TrayMessage(NIM_DELETE);
    delete ic;
}
//---------------------------------------------------------------------------
void __fastcall TfrmMain::FormClick(TObject *Sender)
{
    BalloonTip("Überschrift","Ein kleiner Text.\nAuch mit Umbruch",NIIF_INFO);
}
//---------------------------------------------------------------------------

viel spass, gruß gerd
(dank an el clio)

Allerding denke ich, dass du dir das Hide() (oder ShowWindow()) und das Show() sparen kannst.
Das OnMinimize wird ja beim bzw. vor dem minimieren aufgerufen, somit "verschwindet" deine Anwendung ja sowieso danach, oder? Entsprechend wird die dann auch mit Restore() wieder hergestellt - ohne Show().

Ach so und nochwas - wohlgemerkt völlig egal, aber ich sags trotzdem mal - die Prototypendeklaration für die CallBack-Funktion

LRESULT IconDrawItem(LPDRAWITEMSTRUCT lpdi); ///< Callback function

kannste dir glaub ich sparen, weil deine Callback ja eh ganz oben steht und so ja auch in allen anderen Funktionen bekannt sein sollte...

Ansonsten: TOP!!!

Ach noch ne Ergänzung fällt mir grad ein:
Die TrayMessage() könnte man noch um einen Parameter (z.B. int index = 0) erweitern, um so den Icon dynamisch zu machen, also anhand des indexes ein anderes Bild aus der Imagelist verwenden.
(Evtl. sinnvoll für "animierte"-TrayIcons)

in der Header:

public:
    [...]
    bool __fastcall TrayMessage(DWORD dwMessage, int index = 0);
    [...]

in der cpp:

bool __fastcall TfrmMain::TrayMessage(DWORD dwMessage, int index)
{
    [...]
    ImageList1->GetIcon(index, ic);
    [...]
}
//---------------------------------------------------------------------------

das mit dem index ist auch ne gute idee, werde ich noch einfügen.

zum hide(), dass kann man nicht weglassen, da sonst die anwendung nur minimiert wird.

aber das Show() kann weg, da restore ebenfalls das formular hoch bringt.

gruß gerd

ps: wen es stört, dass das fenster nach dem restore nur wiederhergestellt wird, aber nicht im vordergrund liegt ruft einfach nach dem

Application->Restore();

noch diese funktion auf:

SetForegroundWindow(Handle);