[Delphi] Message versturen met een record met info

[Verwijderd]

Ik wil een windows message versturen met daarin bepaalde info.

Ik heb het volgende record:

code:

  WM_STARTSEARCH = WM_USER + 4;

type
  TSearchDirection = (sdDown, sdUp);

  TWMStartSearch = record
    SearchItem: String;
    SearchArea: Integer;
    CompleteWord: Boolean;
    CaseSensitive: Boolean;
    SearchDirection: TSearchDirection;
  end;

Normaal kan je met Perform een message versturen. Maar hoe kan ik nu deze info meegeven?

[Verwijderd]

Dus je hebt deze functie die de message ontvangt:

code:

    procedure WMStartSearch(var Msg: TWMStartSearch); message WM_STARTSEARCH;

en Msg bevat dus dan alle informatie.


Maar als ik dus de message wil versturen:

code:

  Perform(WM_STARTSEARCH, 0, 0);

kan ik hier dus niet aangeven dat hij dat record met informatie moet mee sturen. Hoe doe ik dat?

[Verwijderd]

Is er niemand die dit weet??

[Eegee]

In plaats van 0, 0 bij de perform moet je daar de gewenste parameters doorgeven (een pointer naar je record).

Volgens mij staan er wel een aantal voorbeelden in de help of de sourcecode van de Delphi units (zoek anders ook op SendMessage of PostMessage)

Perform fills a message record (of type TMessage) with the message ID passed in the Msg parameter, the message parameters passed in WParam and LParam, and a result field of zero. Perform then passes the message record to the WindowProc method for processing.

Misschien dat bepaalde tips op www.swissdelphicenter.ch ook gebruik maken van pointers in lparam/wparam, of anders is er misschien wat met groups.google.com te vinden.

[Tomatoman]

Je haalt een paar dingen door elkaar en daardoor zal je code niet werken. Geen nood, GoT helpt je wel op het rechte pad.

Zoek eerst in de Delphi help naar 'TMessage'. TMessage.Msg is slechts een identifier, een Longint, die aangeeft welke message het betreft. In jouw geval is dat WM_STARTSEARCH. De betekenis van TMessage.WParam en TMessage.LParam is message-afhankelijk en kun je bij zelf-gedefinieerde messages gebruiken om extra informatie te versturen. Zij zijn allebei van het type Longint.

Een Longint is natuurlijk niet genoeg om een complete record in op te slaan en de combinatie van WParam en LParam is eveneens te klein. Maar je kunt een truc gebruiken. Verstuur in WParam niet plaats van de complete record, maar een pointer naar de record (dus het geheugenadres van de record). Een pointer is 32 bits groot, precies evenveel als een Longint. Je verstuurt dan niet de record zelf, maar slechts een verwijzing ernaartoe.

code:

unit MijnMessages;

interface

uses
  Windows, Messages, SysUtils; // en misschien nog een paar

type
  TSearchDirection = (sdDown, sdUp);

{ De info die we willen versturen }
  PSearchInfo = ^TSearchInfo;
  TSearchInfo = record
    SearchItem: string;
    SearchArea: Integer;
    CompleteWord: Boolean;
    CaseSensitive: Boolean;
    SearchDirection: TSearchDirection;
  end;

const
  WM_STARTSEARCH = WM_USER + 4;  // zelf gedefinieerde message constante
type
{ Ter info, een message ziet er (ongeveer) als volgt uit: }
{ TMessage = packed record
    Msg: Cardinal;
    WParam: Longint;
    LParam: Longint;
    Result: Longint;
  end;    }

{ Nu gaan we onze eigen message maken, waarbij we de betekenis
van WParam en LParam gaan veranderen, maar wel zodanig dat zij
precies evenveel bits beslaan als is TMessage. }
  TWMStartSearch = packed record
    Msg: Cardinal;
    SearchInfo: PSearchInfo; // even groot als een Longint
    Ongebruikt: Longint;     // even groot als een Longint
    Result: Longint;
  end;

implementation

end.

Nu willen we in ons form verstuurde WMStartSearch messages afvangen. Daarvoor moeten we met de hand een paar regels aan de code van ons form toevoegen.

code:

uses
  MijnMessages;  { <-- toevoegen aan uses clausule }

  TForm1 = class(TForm)
  private
    procedure WMStartSearch(var Msg: TWMStartSearch); message WM_STARTSEARCH;
    ...

implementation

procedure TForm1.WMStartSearch(var Msg: TWMStartSearch);
var
  InfoPtr: PSearchInfo;
  Info: TSearchInfo;
begin
{ Een beetje omslachtig, maar het laat goed zien wat er gebeurt }
  InfoPtr := Msg.SearchInfo;
  Info := InfoPtr^;
  
{ Nu iets met de info doen }
  ShowMessage(Info.SearchItem);
end;

Een message versturen gaat zo:

code:

var
  Info: TSearchInfo;
  InfoPtr: PSearchInfo;
  WParam: Longint;
begin
{ Eerst de Info record vullen }
  with Info do
  begin
    SearchItem := 'klooien met messages';
    SearchArea := 1000;
    CompleteWord := False;
    CaseSensitive := True;
    SearchDirection := sdDown;
  end;

{ Nu versturen, voor de duidelijkheid met wat onnodig lange code }
  InfoPtr := @Info;
  WParam := Longint(InfoPtr); // WParam is even groot als InfoPtr
  Perform(WM_STARTSEARCH, WParam, 0);
end;

Dit werkt trouwens alleen binnen één applicatie! Je verwijst immers naar een stuk geheugen binnen een applicatie (namelijk een TSearchInfo record) en daar heeft een andere applicatie geen toegang toe.

Wil je meer over dit onderwerp weten, zoek dan een naar 'message crackers' of 'message cracking'.

[Verwijderd]

Perform fills a message record (of type TMessage)

Mijn message info is dus geen TMessage type. Dus dat gaat niet werken.

[Verwijderd]

het gaat iig niet werken, omdat de pointer niet geldig is in de adress-space van het ontvangende programma.

je kan het wel doen met: WM_COPYDATA

[Tomatoman]

Het gaat iig wél werken als je message binnen een programma wilt versturen. En dat is nou precies wat je doet met Perform.

[Eegee]

Ksnap niet wat er nou allemaal moeilijk wordt uitgelegd, een eigen message maken en zo...
Gewoon een TMessage gebruiken, en dan een pointer in de lparam meegeven naar je eigen data record structuur dingetje.

Ja en inderdaad geldt zo'n pointer dan niet in een ander programma, maar tokkie heeft niet gezegd dat ie een msg naar een ander programma wil sturen, dus ga ik er van uit dat het een message binnen hetzelfde programma is.

Zie ook hier waarom je niet goed een eigen message kan sturen

[Verwijderd]

Tomatoman,

Bedankt voor je uitgebreide uitleg. Het werkt en dit is precies wat ik wilde hebben!

[Tomatoman]

Eegee, gefeliciteerd dat je zo'n gave vent bent. Misschien dat jij alle Delphi-kennis al bij je geboorte bezat, maar de meeste mensen moeten zoiets eerst LEREN*. En we zitten hier bij GoT om elkaar te HELPEN*.
___
* Zie hier voor uitleg van deze woorden.

[Guillome]

Op zondag 19 mei 2002 14:15 schreef tomatoman het volgende:
Eegee, gefeliciteerd dat je zo'n gave vent bent. Misschien dat jij alle Delphi-kennis al bij je geboorte bezat, maar de meeste mensen moeten zoiets eerst LEREN*. En we zitten hier bij GoT om elkaar te HELPEN*.
___
* Zie hier voor uitleg van deze woorden.

Volledig mee eens!!!!
Die mensen die altijd denken alles beter te weten

[Verwijderd]

Heb ik ook nog een vraag:

Hier gaat het allemaal over messages versturen binnen 1 app
Nu wil ik dus een msg versturen buiten m'n eigen app

Situatie:
Ik ben bezig met een soort van media player voor 'n ander formaat (vqa). Extensie is geassocieerd met mijn app, dus een dubbelklik op een VQA opent de player en speelt 'm af

Nu wil ik dus maar 1 window tegelijk toestaan. Als de app open staat en de user dubbelklikt nogmaals op een vqa, wordt er nu geen 2e player geopent. Maar ik wil er dus wel voor zorgen dat de filename die de user dubbelklikt naar m'n al spelende player gestuurd wordt zodat deze 'm afspeelt...

[Guillome]

Zoek eens naar het component Just1 of JustOne
Op delphipages.com ofzo

[Tomatoman]

Zie ook dit topic om maar één instantie van je programma te laten runnen.

Onderwerpen hieronder:
1. message versturen naar andere applicatie
2. meerdere instanties van een applicatie voorkomen

Hopelijk kun je kaas maken van de volgende code . Het is een gestript programma, alle 'echte' functionaliteit ontbreekt. Zodra er een tweede instantie wordt gestart, wordt aan alle draaiende processen een TSMRemsrv message verstuurd (met Command = SMC_NOCOMMAND en Info = SMI_NEWINSTANCEKILLED). Alleen mijn eigen pogramma herkent deze message. De message geeft aan de al draaiende instantie van het programma door dat er een nieuwe instantie is gestart en dat deze nu zal worden beëindigd.

Ter illustratie van het principe kun je het programma (dat Remsrv heet) vanaf de commandoregel starten (Start - Uitvoeren) met als parameter '/close'. 'Remsrv /close' sluit het programma.

code:

unit UnitRemsrv;

interface


type
  TSMRemsrv = packed record
    Msg: Cardinal;
    Command: Word;
    Info: Word;
    Data: Longint;
    Result: Longint;
  end;

  TServer = class(TForm)
    procedure FormDestroy(Sender: TObject);
  public
    procedure WndProc(var Message: TMessage); override;
    procedure RemsrvMessage(Message: TSMRemsrv);
  end;

var
  { The RemsrvMsg message is registered at runtime. }
  RemsrvMsg: Cardinal;
const
  { RemsrvMsg WParam and LParam constants. Nonzero Command constants(SMC_xxx)
    indicate commands (Info should be 0). Nonzero Info constants (SMI_xxx)
    indicate information messages (Command should be 0). The meaning of Data
    depends on the value of Command/Info. }
  // commands
  SMC_NOCOMMAND    = 0;    // message doesn't contain a command
  SMC_CLOSESESSION  = 1;    // close the current process
  // information messages
  SMI_NOINFO        = 0;    // message doesn't contain information
  SMI_NEWINSTANCEKILLED = 1;    // new process instance terminates at startup
  SMI_TERMINATING    = 2;    // current process is terminating

const
  SC_HIDE = WM_USER + 1;
var
  Server: TServer;
  i: Integer;
  Mutex: THandle;

implementation

{$R *.DFM}

procedure TServer.WndProc(var Message: TMessage);
begin
  if Message.Msg = RemsrvMsg then
  begin
    Message.Result := 0; // the message was handled
    RemsrvMessage(TSMRemsrv(Message));
  end
  else
    inherited WndProc(Message);
end;

procedure TServer.RemsrvMessage(Message: TSMRemsrv);
begin
  with Message do
    if Command <> SMC_NOCOMMAND then
    begin
    if  Command = SMC_CLOSESESSION then Application.Terminate;
    end
    else if Info <> SMI_NOINFO then
    begin
    if Info = SMI_NEWINSTANCEKILLED then
    begin
      {Tell the application to restore, let it restore the form}
      SendMessage(Application.Handle, WM_SYSCOMMAND, SC_RESTORE, 0);
      SetForegroundWindow(Application.Handle);
    end;
    end;
end;

procedure TServer.FormDestroy(Sender: TObject);
begin
  {De volgende regel is slechts ter illustratie.}

  {broadcast system status}
  SendMessage(HWND_BROADCAST, RemsrvMsg, SMI_TERMINATING shl 16, 0);
end;

initialization
  RemsrvMsg := RegisterWindowMessage('Remsrv');

  {Tell Delphi to hide it's hidden application window for now to avoid
  a "flash" on the taskbar if the application halts due to another
  instance.}
  Application.ShowMainForm := False;

  {Attempt to create a named mutex}
  Mutex := CreateMutex(nil, False, 'Remsrv');
  {if it failed then there is another instance}
  if GetLastError = ERROR_ALREADY_EXISTS then
  begin
    {Send all windows a custom message - only another instance will
     recognize it and restore itself.}
    for i := 1 to ParamCount do
    begin
    S := LowerCase(ParamStr(i));
    if S = '/close' then
      SendMessage(HWND_BROADCAST, RemsrvMsg, SMC_CLOSESESSION, 0);
    end;
  { "SMI_NEWINSTANCEKILLED shl 16" betekent hetzelfde als
    Command = SMC_NOCOMMAND en Info = SMI_NEWINSTANCEKILLED }
    SendMessage(HWND_BROADCAST, RemsrvMsg, SMI_NEWINSTANCEKILLED shl 16, 0);
    Halt(0);
  end;

  {Tell Delphi to un-hide it's hidden application window. This allows the
   instance to have an icon on the task bar}
  Application.ShowMainForm := True;
finalization
  ReleaseMutex(Mutex);
end.

[Verwijderd]

Het toestaan van maar 1 instance van mijn programma had ik al voor elkaar, was ook m'n vraag niet (misschien een beetje ongelukkig uitgelegd hierboven)

tomatoman: In jouw voorbeeld stuur je vooraf gedefigneerde msgs (SMC_CLOSESESSION, SMI_NEWINSTANCEKILLED, etc) die inderdaad in de Msg (cardinal) parameter van SendMessage() passen. Wat ik wil is dat er een volledig bestandsnaam (wat dus van alles kan zijn) naar m'n app verstuurd wordt zodat deze weet welk bestand er geopend en afgespeeld moet worden.

[Eegee]

Op zondag 19 mei 2002 14:15 schreef tomatoman het volgende:
Eegee, gefeliciteerd dat je zo'n gave vent bent. Misschien dat jij alle Delphi-kennis al bij je geboorte bezat, maar de meeste mensen moeten zoiets eerst LEREN*. En we zitten hier bij GoT om elkaar te HELPEN*.

Ik bezit niet alle Delphi kennis. Ik wil de topicstarter HELPEN. Ik zie dat er een oplossing wordt gegeven, die mijns inziens wat uitgebreid is. Ik geef daarom aan hoe het volgens mij simpeler kan. Vervolgens gaat niemand in op mijn oplossing. Ik vermoed dat men te moeilijk aan het denken is en probeer daarom nogmaals mijn oplossing naar voren te brengen. Vervolgens word ik min of meer afgekraakt. Bedankt voor het begrip.

[Tomatoman]

Op zondag 19 mei 2002 20:44 schreef Eegee het volgende:
Ik bezit niet alle Delphi kennis. Ik wil de topicstarter HELPEN. Ik zie dat er een oplossing wordt gegeven, die mijns inziens wat uitgebreid is. Ik geef daarom aan hoe het volgens mij simpeler kan. Vervolgens gaat niemand in op mijn oplossing. Ik vermoed dat men te moeilijk aan het denken is en probeer daarom nogmaals mijn oplossing naar voren te brengen. Vervolgens word ik min of meer afgekraakt. Bedankt voor het begrip.

Eegee, sorry dat ik zo reageerde, blijkbaar schatte ik je reactie niet goed in.

[Tomatoman]

Op zondag 19 mei 2002 18:42 schreef Lynx666 het volgende:
[...] Wat ik wil is dat er een volledig bestandsnaam (wat dus van alles kan zijn) naar m'n app verstuurd wordt zodat deze weet welk bestand er geopend en afgespeeld moet worden.

Twee applicaties, SendApp en ReceiveApp, waarvan de ene via messages tekst verstuurt en de andere de tekst ontvangt. Unit die door beide applicaties wordt gebruikt:

code:

unit CommonUnit;

interface

type
  TSharedMessage = packed record
    Msg: Cardinal;
    Command: Longint;    // maps to WParam of TMessage
    Data: Longint;   // maps to LParam of TMessage
    Result: Longint;
  end;

const
  { Message constants for TSharedMessage.Command. The meaning of
    TSharedMessage.Data depends on the value of Command. }
  SM_READYTOSEND = 0;  { Ready to send. Value of Data is ignored. }
  SM_APPHANDLE = 1;    { Application handle of receiving application.
                 Handle is sent in Data. }

{
type
  // The following structure is predefined in the Messages unit.
  TWMCopyData = record
    Msg: Cardinal;            // the message identifier
    From: HWND;              // handle of the sender
    CopyDataStruct: PCopyDataStruct;  // a pointer to the data being sent
    Result: Longint;            // returns 1 if handled
  end;

  // The following structures are predefined in the Windows unit.
  PCopyDataStruct = ^TCopyDataStruct;
  TCopyDataStruct = packed record
    dwData: DWORD;            // a 32-bit data value
    cbData: DWORD;            // the size of the lpData buffer
    lpData: Pointer;            // a pointer to additional data
  end; }

const
  { User defined values for TCopyDataStruct.dwData to indicate what is being
    sent. }
  DW_MEMOTEXT = 1000;            // memo text

const
  ShareApp = 'ShareApp';

implementation

end.

Main unit van SendApp. Op het form staan een TMemo en een TButton. Als op de button wordt geklikt, wordt de tekst in de memo via een message verstuurd.

code:

unit SendUnit;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TSendForm = class(TForm)
    MemoSend: TMemo;
    ButtonSend: TButton;
    procedure ButtonSendClick(Sender: TObject);
  private
    procedure SendData(AppHandle: THandle);
  public
    procedure WndProc(var Message: TMessage); override;
  end;

var
  SendForm: TSendForm;
  SharedMsg: Cardinal;

implementation

uses CommonUnit;

{$R *.dfm}

procedure TSendForm.SendData(AppHandle: THandle);
var
  CopyDataStruct: TCopyDataStruct;
  Txt: PChar;
begin
  { The memo text will be sent as a PChar. }
  Txt := PChar(MemoSend.Text);
  with CopyDataStruct do
  begin
    dwData := DW_MEMOTEXT;
    cbData := Length(Txt);
    lpData := Txt;
  end;
  { Send the data via a WM_COPYDATA message. }
  SendMessage(AppHandle, WM_COPYDATA, Application.Handle,
    Integer(@CopyDataStruct));
end;

procedure TSendForm.WndProc(var Message: TMessage);
begin
  if Message.Msg = SharedMsg then
  begin
    Message.Result := 1; // the message was handled
    if TSharedMessage(Message).Command = SM_APPHANDLE then
    { Some application wants to receive our data, so send it to that app. }
    SendData(TSharedMessage(Message).Data);
  end
  else
    inherited WndProc(Message);
end;

procedure TSendForm.ButtonSendClick(Sender: TObject);
begin
{ Broadcast a message that we are ready to send and need a window handle of an
  application that wants to receive our data. }
  SendMessage(HWND_BROADCAST, SharedMsg, SM_READYTOSEND, 0);
end;

initialization
  SharedMsg := RegisterWindowMessage(ShareApp);
end.

Main unit van ReceiveApp. Ontvangen tekst wordt in een TMemo weergegeven.

code:

unit ReceiveUnit;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TReceiveForm = class(TForm)
    MemoReceive: TMemo;
  private
    procedure WMCopyData(var CopyData: TWMCopyData); message WM_COPYDATA;
  public
    procedure WndProc(var Message: TMessage); override;
  end;

var
  ReceiveForm: TReceiveForm;
  SharedMsg: Cardinal;

implementation

uses CommonUnit;

{$R *.dfm}

procedure TReceiveForm.WMCopyData(var CopyData: TWMCopyData);
var
  NewText: string;
begin
  with CopyData.CopyDataStruct^ do
    { Find out if the data structure contains memo text }
    if dwData = DW_MEMOTEXT then
    begin
    { Copy the string data (formatted as a PChar) from the buffer into
      NewText. }
    NewText := Copy(PChar(lpData), 1, cbData);

    MemoReceive.Lines.Add('--- NEW TEXT RECEIVED ---');
    MemoReceive.Lines.Add(NewText);
    CopyData.Result := 1; // the message was handled
    end;
end;

procedure TReceiveForm.WndProc(var Message: TMessage);
begin
  if Message.Msg = SharedMsg then
  begin
    Message.Result := 1; // the message was handled
    if TSharedMessage(Message).Command = SM_READYTOSEND then
    { The sending application is ready to send data. Return a message that we
      wish to receive the information. Send a window handle in the LParam
      parameter. }
    SendMessage(HWND_BROADCAST, SharedMsg, SM_APPHANDLE, Handle);
  end
  else
    inherited WndProc(Message);
end;

initialization
  SharedMsg := RegisterWindowMessage(ShareApp);
end.

Werking
1. SendApp verstuurt een custom message (SharedMsg).
2. ReceiveApp ontvangt deze message en stuurt een message terug (ook SharedMsg) met daarbij een window handle waar de tekst heengestuurd moet worden.
3. SendApp ontvangt de message met de window handle en reageert door tekst te sturen middels een WM_COPYDATA message.
4. ReceiveApp ontvangt de WM_COPYDATA message en geeft de ontvangen tekst weer.

(Sorry dat de code zo lang is, maar het kon niet veel korter zonder onduidelijk te worden.)

[Verwijderd]

Thnx! Precies de info die ik nodig heb
Programmatjes werken perfect

[.oisyn]

Op zondag 19 mei 2002 11:00 schreef tokkie het volgende:
[..knip..]

Op zondag 19 mei 2002 13:24 schreef tokkie het volgende:
Is er niemand die dit weet??

Uit de FAQ:

Wacht minstens 6 uur voor je je topic omhoog schopt. Doe dit dan ook alleen met een zinnige opmerking en dus niet met "Waarom antwoord er nou niemand" nadat je 5 minuten geen antwoord hebt gehad. Sommigen van ons hebben een leven

niet meer zo snel schoppen dus