Club Builder

[nacho]

¿Como puedo crear mis propios eventos, "señalarlos", etc ... para despues poder responder a ellos en cualquier componente que yo haya creado y necesite responder a tal evento?.
En particular, debo crear un evento que se produzca cuando llegue un paquete de información de una red (estoy usando una API de programación en redes)

[joseluisbz]

Yo no sé mucho de eso, si aprendes me haces el favor y me enseñas...
pero por el momento, ya que yo estoy en otra cosa que me tiene super ocupado puedes consultar esta página si te sirve..
http://www.midnightbeach.com/jon/pubs/MsgWaits/MsgWaits.html.

joseluisbz@bigfoot.com

[nacho]

Gracias por el enlace.
A simple vista parece interesante aunque aún no lo he leido con detenimiento. Cuando lo lea con un poco de paciencia te mandaré un correo a tu dirección.
teixoeira@terra.es

[joseluisbz]

Fíjate también en el ejemplo que viene con c++ Builder o Delphi de Ipcdemos... creo que en el archivo ipcthrd hay algo relacionado...

[nacho]

Otra cosa. Arriba hago referencia a la API Win32. Se puede encontrar una referencia completa en: http://home1.swipnet.se/~w-10159/files/win32hlpfiles/
No se si está actualizada pero no creo que haya muchas diferencias con una hipotética última versión.

[nacho]

Un programita en el que consigo parte de los objetivos que me propongo alcanzar.

En Unit1 creo un formulario con un TMemo en el que pongo lineas de texto.
Esas líneas de texto las produce aleatoriamente (en el tiempo, como si se tratase de paquetes de información que llegan de una red) un TThead al que yo he llamado "TFio" (fio=hilo), que recibe un parámetro del tipo HWND, que es un handle a una ventana. Ventana a la que irán dirigidos algunos mensages.

¿Como lo hace? Creando un mensage como los que Windows produce con:

#define WM_Fin_Random (WM_USER + 0)

¡Esta macro o constante solo identifica al mensage!
Para lanzar el mensage uso una función de la API Win32:

BOOL PostMessage(
HWND hWnd, // handle of destination window
UINT Msg, // message to post
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
);

En el formulario se puede recoger este mensage con alguno de los métodos:

void __fastcall WndProc(Messages::TMessage &Message); //Método 1

virtual void __fastcall DefaultHandler(void* Message); //Método 2

virtual void __fastcall Dispatch(void *Message); //Método 3

void __fastcall ChegameMsx(TMessage &Message); //Método 4
BEGIN_MESSAGE_MAP
MESSAGE_HANDLER(WM_Fin_Random, TMessage, ChegameMsx)
END_MESSAGE_MAP(TControl)

...
Pero lo que yo pretendo es poder crear un formulario y durante el diseño poder asignar código a un nuevo evento al que se le podría llamar "onDatagramReceive".

Este es en código del programa "Random".
(Es necesario crear de nuevo el formulario para despues añadirle este código).

......Mandad críticas y/o sugerencias.......
¡Gracias!

/*Random.cpp*/

//-------------------------------------------#include <vcl.h>
#pragma hdrstop
USERES("random.res");
USEFORM("Unit1.cpp", Formulario);
USEUNIT("Unit2.cpp");
//-------------------------------------------WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
try
{
Application->Initialize();
Application->CreateForm(__classid(TFormulario), &Formulario);
Application->Run();
}
catch (Exception &exception)
{
Application->ShowException(&exception);
}
return 0;
}
//-------------------------------------------

/*Unit1.h*/

//-------------------------------------------#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>

#include "Unit2.h"
//-------------------------------------------class TFormulario : public TForm
{
__published: // IDE-managed Components
TMemo *Memo;
void __fastcall FormCreate(TObject *Sender);
void __fastcall FormDestroy(TObject *Sender);
private: // User declarations
int orde;
TFio *Fio;

// void __fastcall WndProc(Messages::TMessage &Message); //Método 1
void __fastcall ChegameMsx(TMessage &Message); //Método 4
BEGIN_MESSAGE_MAP
MESSAGE_HANDLER(WM_Fin_Random, TMessage, ChegameMsx)
END_MESSAGE_MAP(TControl)

public: // User declarations
__fastcall TFormulario(TComponent* Owner);

// virtual void __fastcall DefaultHandler(void* Message); //Método 2
// virtual void __fastcall Dispatch(void *Message); //Método 3
};
//-------------------------------------------extern PACKAGE TFormulario *Formulario;
//-------------------------------------------#endif

/*Unit1.cpp*/

//-------------------------------------------#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//-------------------------------------------#pragma package(smart_init)
#pragma resource "*.dfm"
TFormulario *Formulario;
//-------------------------------------------__fastcall TFormulario::TFormulario(TComponent* Owner)
: TForm(Owner)
{
}
//-------------------------------------------void __fastcall TFormulario::FormCreate(TObject *Sender)
{
orde=0;
Fio=new TFio(Handle);
}
//-------------------------------------------void __fastcall TFormulario::FormDestroy(TObject *Sender)
{
Fio->Terminate();
delete(Fio);
}
//----------------------------- Método 1 ----/*
void __fastcall TFormulario::WndProc(Messages::TMessage &Message)
{
if(Message.Msg==WM_Fin_Random)
{
if(orde==Message.WParam)
{
Memo->Lines->Add(*(AnsiString *)Message.LParam);
orde++;
}
else
Memo->Lines->Add(AnsiString("Erro: Perda da orde."));
}
TForm::WndProc(Message);
}
*/

//------------------------ Método 2 ---------/*
void __fastcall TFormulario::DefaultHandler(void* Message)
{
if(((PMessage)Message)->Msg==WM_Fin_Random)
{
if(orde==((PMessage)Message)->WParam)
{
Memo->Lines->Add(*(AnsiString *)((PMessage)Message)->LParam);
orde++;
}
else
Memo->Lines->Add(AnsiString("Erro: Perda da orde."));
}
else
TForm::DefaultHandler(Message);
}
*/
//------------------------ Método 3 ---------/*
void __fastcall TFormulario::Dispatch(void *Message)
{
if(((PMessage)Message)->Msg==WM_Fin_Random)
{
if(orde==((PMessage)Message)->WParam)
{
Memo->Lines->Add(*(AnsiString *)((PMessage)Message)->LParam);
orde++;
}
else
Memo->Lines->Add(AnsiString("Erro: Perda da orde."));
}
else
TForm::Dispatch(Message);
}
*/
//------------------------- Método 4 --------
void __fastcall TFormulario::ChegameMsx(TMessage &Message)

{
if(orde==Message.WParam)
{
Memo->Lines->Add(*(AnsiString *)Message.LParam);
orde++;
}
else
Memo->Lines->Add(AnsiString("Erro: Perda da orde."));

//TForm::WndProc(Message);
//TForm::DefaultHandler((void *)&Message);
TForm::Dispatch((void *)&Message);
}

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

/*Unit2.h*/

//-------------------------------------------#ifndef Unit2H
#define Unit2H
//-------------------------------------------#include <Classes.hpp>
#include <winuser.h>

#define WM_Fin_Random (WM_USER + 0)

//-------------------------------------------class TFio : public TThread
{
private:
HWND hXanela;
protected:
void __fastcall Execute();
public:
__fastcall TFio(HWND hXanela);
__fastcall ~TFio(){}
};
//-------------------------------------------#endif

//-------------------------------------------#include <vcl.h>
#pragma hdrstop

#include <stdlib.h>
#include <stdio.h>
#include "Unit2.h"
#pragma package(smart_init)
//-------------------------------------------__fastcall TFio::TFio(HWND hXanela): TThread(false)
{
this->hXanela=hXanela;
}
//-------------------------------------------void __fastcall TFio::Execute()
{
int i=0;
AnsiString Cad, Aux;
LONG tempo;

Aux=". Tempo : ";
randomize();

do
{
tempo=(LONG)random(500);
Sleep((int)tempo);
/*
BOOL PostMessage(
HWND hWnd, // handle of destination window
UINT Msg, // message to post
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
);
*/
Cad=AnsiString(i)+Aux+AnsiString((int)tempo);
//¿Que é mellor? ¿PostMessage ou SendMessage?
PostMessage(hXanela,WM_Fin_Random, (LONG)i, (LONG)&Cad);
i++;
}
while(!Terminated);
}
//-------------------------------------------

[nacho]

¡Ups! Lo siento. Parece que no ha quedado muy bien en pantalla el código.
De todas formas no parece muy difícil reconstruirlo.