Code für eigenständigen Messenger

maxal · Aug 11, 2004

Hi,
Möchte einen eigenen Messenger programieren,der am Besten per P2P läuft.Nun suche ich ein paar Starthilfen.Möglichst in C++ oder PHP/Cgi(wenn möglich)

mfg.
maxal

muhkuh · Aug 13, 2004

was kannste denn schon?

lastwebpage · Aug 13, 2004

Hallo,
was verstehst du unter Messenger?
Schau dich mal bei Miranda um das ist Open Source,und du kannst für dein spezielles Problem ja ein Plugin machen.

Peter

Dawen · Aug 25, 2004

Hier hast du den Code

stdafx.h

Code:

// stdafx.h : Include-Datei für Standard-System-Include-Dateien,
//  oder projektspezifische Include-Dateien, die häufig benutzt, aber
//      in unregelmäßigen Abständen geändert werden.
//

#if !defined(AFX_STDAFX_H__128B1D25_23E8_11D6_89CA_B1DCB35AE679__INCLUDED_)
#define AFX_STDAFX_H__128B1D25_23E8_11D6_89CA_B1DCB35AE679__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#define VC_EXTRALEAN		// Selten verwendete Teile der Windows-Header nicht einbinden

#include <afxwin.h>         // MFC-Kern- und -Standardkomponenten
#include <afxext.h>         // MFC-Erweiterungen
#include <afxdisp.h>        // MFC Automatisierungsklassen
#include <afxdtctl.h>
#include <fstream.h>		// MFC-Unterstützung für allgemeine Steuerelemente von Internet Explorer 4
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h>			// MFC-Unterstützung für gängige Windows-Steuerelemente
#endif // _AFX_NO_AFXCMN_SUPPORT

#include <afxsock.h>		// MFC-Socket-Erweiterungen

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ fügt unmittelbar vor der vorhergehenden Zeile zusätzliche Deklarationen ein.

#endif // !defined(AFX_STDAFX_H__128B1D25_23E8_11D6_89CA_B1DCB35AE679__INCLUDED_)

IRCpp.clw

Code:

[General Info]
Version=1
LastClass=CIRCppDlg
LastTemplate=CAsyncSocket
NewFileInclude1=#include "stdafx.h"
NewFileInclude2=#include "IRCpp.h"

ClassCount=4
Class1=CIRCppApp
Class2=CIRCppDlg
Class3=CAboutDlg

ResourceCount=3
Resource1=IDD_ABOUTBOX
Resource2=IDR_MAINFRAME
Class4=CMySocket
Resource3=IDD_IRCPP_DIALOG

[CLS:CIRCppApp]
Type=0
HeaderFile=IRCpp.h
ImplementationFile=IRCpp.cpp
Filter=N

[CLS:CIRCppDlg]
Type=0
HeaderFile=IRCppDlg.h
ImplementationFile=IRCppDlg.cpp
Filter=D
LastObject=IDC_LRECVD
BaseClass=CDialog
VirtualFilter=dWC

[CLS:CAboutDlg]
Type=0
HeaderFile=IRCppDlg.h
ImplementationFile=IRCppDlg.cpp
Filter=D

[DLG:IDD_ABOUTBOX]
Type=1
Class=CAboutDlg
ControlCount=5
Control1=IDC_STATIC,static,1342177283
Control2=IDC_STATIC,static,1342308480
Control3=IDC_STATIC,static,1342308352
Control4=IDOK,button,1342373889
Control5=IDC_STATIC,static,1342308352

[DLG:IDD_IRCPP_DIALOG]
Type=1
Class=CIRCppDlg
ControlCount=16
Control1=IDC_STATICTYPE,button,1342177287
Control2=IDC_RCLIENT,button,1342308361
Control3=IDC_RSERVER,button,1342177289
Control4=IDC_STATICNAME,static,1342308352
Control5=IDC_ESERVNAME,edit,1350631552
Control6=IDC_ESERVPORT,edit,1350631552
Control7=IDC_STATICPORT,static,1342308352
Control8=IDC_BCONNECT,button,1342242816
Control9=IDC_BCLOSE,button,1476460544
Control10=IDC_STATICMSG,static,1476526080
Control11=IDC_EMSG,edit,1484849280
Control12=IDC_BSEND,button,1476460545
Control13=IDC_STATIC,static,1342308352
Control14=IDC_LSENT,listbox,1352683777
Control15=IDC_LRECVD,listbox,1352683777
Control16=IDC_STATIC,static,1342308352

[CLS:CMySocket]
Type=0
HeaderFile=MySocket.h
ImplementationFile=MySocket.cpp
BaseClass=CAsyncSocket
Filter=N

Code:

// IRCpp.cpp : Legt das Klassenverhalten für die Anwendung fest.
//

#include "stdafx.h"
#include "IRCpp.h"
#include "IRCppDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CIRCppApp

BEGIN_MESSAGE_MAP(CIRCppApp, CWinApp)
	//{{AFX_MSG_MAP(CIRCppApp)
	//}}AFX_MSG
	ON_COMMAND(ID_HELP, CWinApp::OnHelp)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CIRCppApp Konstruktion

CIRCppApp::CIRCppApp()
{
}

/////////////////////////////////////////////////////////////////////////////
// Das einzige CIRCppApp-Objekt

CIRCppApp theApp;

/////////////////////////////////////////////////////////////////////////////
// CIRCppApp Initialisierung

BOOL CIRCppApp::InitInstance()
{
	if (!AfxSocketInit())
	{
		AfxMessageBox(IDP_SOCKETS_INIT_FAILED);
		return FALSE;
	}

	AfxEnableControlContainer();

	// Standardinitialisierung

#ifdef _AFXDLL
	Enable3dControls();			// Diese Funktion bei Verwendung von MFC in gemeinsam genutzten DLLs aufrufen
#else
	Enable3dControlsStatic();	// Diese Funktion bei statischen MFC-Anbindungen aufrufen
#endif

	CIRCppDlg dlg;
	m_pMainWnd = &dlg;
	int nResponse = dlg.DoModal();
	if (nResponse == IDOK)
	{
	}
	else if (nResponse == IDCANCEL)
	{
	}

	// Da das Dialogfeld geschlossen wurde, FALSE zurückliefern, so dass wir die
	//  Anwendung verlassen, anstatt das Nachrichtensystem der Anwendung zu starten.
	return FALSE;
}

Code:

/ IRCppDlg.cpp : Implementierungsdatei
//

#include "stdafx.h"
#include "IRCpp.h"
#include "IRCppDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CAboutDlg-Dialogfeld für Anwendungsbefehl "Info"

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialogfelddaten
	//{{AFX_DATA(CAboutDlg)
	enum { IDD = IDD_ABOUTBOX };
	//}}AFX_DATA

	// Vom Klassenassistenten generierte Überladungen virtueller Funktionen
	//{{AFX_VIRTUAL(CAboutDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV-Unterstützung
	//}}AFX_VIRTUAL

// Implementierung
protected:
	//{{AFX_MSG(CAboutDlg)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
	//{{AFX_DATA_INIT(CAboutDlg)
	//}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAboutDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
	//{{AFX_MSG_MAP(CAboutDlg)
		// Keine Nachrichten-Handler
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CIRCppDlg Dialogfeld

CIRCppDlg::CIRCppDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CIRCppDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CIRCppDlg)
	m_strMessage = _T("");
	m_strName = _T("");
	m_iPort = 0;
	m_iType = -1;
	//}}AFX_DATA_INIT
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CIRCppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CIRCppDlg)
	DDX_Control(pDX, IDC_LSENT, m_ctlSent);
	DDX_Control(pDX, IDC_LRECVD, m_ctlRecvd);
	DDX_Control(pDX, IDC_BCONNECT, m_ctlConnect);
	DDX_Text(pDX, IDC_EMSG, m_strMessage);
	DDX_Text(pDX, IDC_ESERVNAME, m_strName);
	DDX_Text(pDX, IDC_ESERVPORT, m_iPort);
	DDX_Radio(pDX, IDC_RCLIENT, m_iType);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CIRCppDlg, CDialog)
	//{{AFX_MSG_MAP(CIRCppDlg)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_RCLIENT, OnRType)
	ON_BN_CLICKED(IDC_BCONNECT, OnBconnect)
	ON_BN_CLICKED(IDC_BSEND, OnBsend)
	ON_BN_CLICKED(IDC_RSERVER, OnRType)
	ON_BN_CLICKED(IDC_BCLOSE, OnBclose)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CIRCppDlg Nachrichten-Handler

BOOL CIRCppDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Hinzufügen des Menübefehls "Info..." zum Systemmenü.

	// IDM_ABOUTBOX muss sich im Bereich der Systembefehle befinden.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		CString strAboutMenu;
		strAboutMenu.LoadString(IDS_ABOUTBOX);
		if (!strAboutMenu.IsEmpty())
		{	
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	SetIcon(m_hIcon, TRUE);			// Großes Symbol verwenden
	SetIcon(m_hIcon, FALSE);		// Kleines Symbol verwenden
	
	// ZU ERLEDIGEN: Hier zusätzliche Initialisierung einfügen
// Steuerelementvariablen initialisieren
m_iType = 0;
// Steuerelemente aktualisieren
UpdateData(FALSE);
// Socket-Zeiger auf Dialogfeld setzen
m_sConnectSocket.SetParent(this);
m_sListenSocket.SetParent(this);
	
	return TRUE;  // Geben Sie TRUE zurück, außer ein Steuerelement soll den Fokus erhalten
}

void CIRCppDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

// Wollen Sie Ihrem Dialogfeld eine Schaltfläche "Minimieren" hinzufügen, benötigen Sie
//  den nachstehenden Code, um das Symbol zu zeichnen. Für MFC-Anwendungen, die das
//  Dokument/Ansicht-Modell verwenden, wird dies automatisch für Sie erledigt.

void CIRCppDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // Gerätekontext für Zeichnen

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Symbol in Client-Rechteck zentrieren
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Symbol zeichnen
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

HCURSOR CIRCppDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}

void CIRCppDlg::OnRType()
{
UpdateData(TRUE);
// Welcher Modus ist eingestellt?
if (m_iType == 0) // Entsprechenden Text auf der Schaltfläche festlegen
m_ctlConnect.SetWindowText("&Verbinden");
else
m_ctlConnect.SetWindowText("&Hören");
}
	ofstream out;
void CIRCppDlg::OnBconnect()
{
// Variablen mit Steuerelementen synchronisieren
UpdateData(TRUE);
// Steuerelemente für Verbindung und Typ deaktivieren
GetDlgItem(IDC_BCONNECT)->EnableWindow(FALSE);
GetDlgItem(IDC_ESERVNAME)->EnableWindow(FALSE);
GetDlgItem(IDC_ESERVPORT)->EnableWindow(FALSE);
GetDlgItem(IDC_STATICNAME)->EnableWindow(FALSE);
GetDlgItem(IDC_STATICPORT)->EnableWindow(FALSE);
GetDlgItem(IDC_RCLIENT)->EnableWindow(FALSE);
GetDlgItem(IDC_RSERVER)->EnableWindow(FALSE);
GetDlgItem(IDC_STATICTYPE)->EnableWindow(FALSE);
// Läuft Anwendung als Client oder Server?
if (m_iType == 0)
{
// Client, einen Standard-Socket erzeugen
m_sConnectSocket.Create();
// Verbindung zum Server öffnen
m_sConnectSocket.Connect(m_strName, m_iPort);
}
else
{
// Server, einen Socket für den angegebenen Anschluß erzeugen
m_sListenSocket.Create(m_iPort);
// Auf Verbindungsgesuche hören
m_sListenSocket.Listen();
}
}

void CIRCppDlg::OnAccept()
{
// Verbindungsanforderung annehmen
m_sListenSocket.Accept(m_sConnectSocket);
// Steuerelemente für Text und Nachrichten aktivieren
GetDlgItem(IDC_EMSG)->EnableWindow(TRUE);
GetDlgItem(IDC_BSEND)->EnableWindow(TRUE);
GetDlgItem(IDC_STATICMSG)->EnableWindow(TRUE);
}

void CIRCppDlg::OnConnect()
{
GetDlgItem(IDC_EMSG)->EnableWindow(TRUE);
GetDlgItem(IDC_BSEND)->EnableWindow(TRUE);
GetDlgItem(IDC_STATICMSG)->EnableWindow(TRUE);
GetDlgItem(IDC_BCLOSE)->EnableWindow(TRUE);
}

void CIRCppDlg::OnClose()
{
// Den verbundenen Socket schließen
m_sConnectSocket.Close();
// Steuerelemente zum Senden von Nachrichten deaktivieren
GetDlgItem(IDC_EMSG)->EnableWindow(FALSE);
GetDlgItem(IDC_BSEND)->EnableWindow(FALSE);
GetDlgItem(IDC_STATICMSG)->EnableWindow(FALSE);
GetDlgItem(IDC_BCLOSE)->EnableWindow(FALSE);
// Läuft Anwendung im Client-Modus?
if (m_iType == 0)
{
// Ja, Steuerelemente zum Konfigurieren der Verbindung aktivieren
GetDlgItem(IDC_BCONNECT)->EnableWindow(TRUE);
GetDlgItem(IDC_ESERVNAME)->EnableWindow(TRUE);
GetDlgItem(IDC_ESERVPORT)->EnableWindow(TRUE);
GetDlgItem(IDC_STATICNAME)->EnableWindow(TRUE);
GetDlgItem(IDC_STATICPORT)->EnableWindow(TRUE);
GetDlgItem(IDC_RCLIENT)->EnableWindow(TRUE);
GetDlgItem(IDC_RSERVER)->EnableWindow(TRUE);
GetDlgItem(IDC_STATICTYPE)->EnableWindow(TRUE);
}
}

void CIRCppDlg::OnReceive()
{
char *pBuf = new char[1025];
int iBufSize = 1024;
int iRcvd;
CString strRecvd;
// Nachricht empfangen
iRcvd = m_sConnectSocket.Receive(pBuf, iBufSize);
// Wurde etwas empfangen?
if (iRcvd == SOCKET_ERROR)
{
}
else
{
// Ende der Nachricht abschneiden
pBuf[iRcvd] = NULL;
// Nachricht in einen CString kopieren
strRecvd = pBuf;
// Nachricht in Listenfeld der empfangenen Nachrichten eintragen
m_ctlRecvd.AddString(strRecvd);
// Variablen mit den Steuerelementen synchronisieren
out.open("log.txt",ios::app);
if(m_iType)
out<<"Client: "<<strRecvd<<endl;
else if(m_iType==1)
out<<"Server: "<<strRecvd<<endl;
out.close();
UpdateData(FALSE);
}
}

void CIRCppDlg::OnSend()
{

}

void CIRCppDlg::OnBsend()
{
// TODO: Code für die Behandlungsroutine der Steuerelement- ÂBenachrichtigung hier einfügen
int iLen;
int iSent;
// Steuerelemente mit Variablen synchronisieren
UpdateData(TRUE);
// Zu sendende Nachricht vorhanden?
if (m_strMessage != "")
{
// Länge der Nachricht ermitteln
iLen = m_strMessage.GetLength();
// Nachricht senden
iSent = m_sConnectSocket.Send(m_strMessage, iLen);
// Konnte die Nachricht gesendet werden?
if (iSent == SOCKET_ERROR)
{
}
else
{
// Nachricht in Listenfeld hinzufügen.
m_ctlSent.AddString(m_strMessage);
out.open("log.txt",ios::app);
if(m_iType)
out<<"Client: "<<m_strMessage<<endl;
else if(m_iType==1)
out<<"Server: "<<m_strMessage<<endl;
out.close();
m_strMessage="";
// Variablen mit Steuerelementen synchronisieren
UpdateData(FALSE);
}
}
}

void CIRCppDlg::OnBclose() 
{
OnClose();
}

Code:

// IRCppDlg.h : Header-Datei
//

#if !defined(AFX_IRCPPDLG_H__128B1D23_23E8_11D6_89CA_B1DCB35AE679__INCLUDED_)
#define AFX_IRCPPDLG_H__128B1D23_23E8_11D6_89CA_B1DCB35AE679__INCLUDED_

#include "MySocket.h"	// Hinzugefügt von der Klassenansicht
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

/////////////////////////////////////////////////////////////////////////////
// CIRCppDlg Dialogfeld

class CIRCppDlg : public CDialog
{
// Konstruktion
public:
	void OnSend();
	void OnReceive();
	void OnClose();
	void OnAccept();
	void OnConnect();
	CIRCppDlg(CWnd* pParent = NULL);	// Standard-Konstruktor

// Dialogfelddaten
	//{{AFX_DATA(CIRCppDlg)
	enum { IDD = IDD_IRCPP_DIALOG };
	CListBox	m_ctlSent;
	CListBox	m_ctlRecvd;
	CButton	m_ctlConnect;
	CString	m_strMessage;
	CString	m_strName;
	int		m_iPort;
	int		m_iType;
	//}}AFX_DATA

	// Vom Klassenassistenten generierte Überladungen virtueller Funktionen
	//{{AFX_VIRTUAL(CIRCppDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV-Unterstützung
	//}}AFX_VIRTUAL

// Implementierung
protected:
	HICON m_hIcon;

	// Generierte Message-Map-Funktionen
	//{{AFX_MSG(CIRCppDlg)
	virtual BOOL OnInitDialog();
	afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	afx_msg void OnRType();
	afx_msg void OnBconnect();
	afx_msg void OnBsend();
	afx_msg void OnBclose();
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
private:
	CMySocket m_sConnectSocket;
	CMySocket m_sListenSocket;
};

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ fügt unmittelbar vor der vorhergehenden Zeile zusätzliche Deklarationen ein.

#endif // !defined(AFX_IRCPPDLG_H__128B1D23_23E8_11D6_89CA_B1DCB35AE679__INCLUDED_)

Code:

// IRCpp.h : Haupt-Header-Datei für die Anwendung IRCPP
//

#if !defined(AFX_IRCPP_H__128B1D21_23E8_11D6_89CA_B1DCB35AE679__INCLUDED_)
#define AFX_IRCPP_H__128B1D21_23E8_11D6_89CA_B1DCB35AE679__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#ifndef __AFXWIN_H__
	#error include 'stdafx.h' before including this file for PCH
#endif

#include "resource.h"		// Hauptsymbole

/////////////////////////////////////////////////////////////////////////////
// CIRCppApp:
// Siehe IRCpp.cpp für die Implementierung dieser Klasse
//

class CIRCppApp : public CWinApp
{
public:
	CIRCppApp();

// Überladungen
	// Vom Klassenassistenten generierte Überladungen virtueller Funktionen
	//{{AFX_VIRTUAL(CIRCppApp)
	public:
	virtual BOOL InitInstance();
	//}}AFX_VIRTUAL

// Implementierung

	//{{AFX_MSG(CIRCppApp)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};


/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ fügt unmittelbar vor der vorhergehenden Zeile zusätzliche Deklarationen ein.

#endif // !defined(AFX_IRCPP_H__128B1D21_23E8_11D6_89CA_B1DCB35AE679__INCLUDED_)

Code:

// MySocket.cpp: Implementierungsdatei
//

#include "stdafx.h"
#include "IRCpp.h"
#include "MySocket.h"
#include "IRCppDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CMySocket

CMySocket::CMySocket()
{
}

CMySocket::~CMySocket()
{
}


//Die folgenden Zeilen nicht bearbeiten. Sie werden vom Klassen-Assistenten benötigt.
#if 0
BEGIN_MESSAGE_MAP(CMySocket, CAsyncSocket)
	//{{AFX_MSG_MAP(CMySocket)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()
#endif	// 0

/////////////////////////////////////////////////////////////////////////////
// Member-Funktion CMySocket 

void CMySocket::SetParent(CDialog *pWnd)
{
	m_pWnd = pWnd;
}

void CMySocket::OnAccept(int nErrorCode)
{
// Sind Fehler aufgetreten?
if (nErrorCode == 0)
// Nein, OnAccept-Funktion des Dialogfelds aufrufen
((CIRCppDlg*)m_pWnd)->OnAccept();
}

void CMySocket::OnConnect(int nErrorCode)
{
if (nErrorCode == 0)
((CIRCppDlg*)m_pWnd)->OnConnect();
}

void CMySocket::OnClose(int nErrorCode)
{
if (nErrorCode == 0)
((CIRCppDlg*)m_pWnd)->OnClose();
}

void CMySocket::OnReceive(int nErrorCode)
{
if (nErrorCode == 0)
((CIRCppDlg*)m_pWnd)->OnReceive();
}

void CMySocket::OnSend(int nErrorCode)
{
if (nErrorCode == 0)
((CIRCppDlg*)m_pWnd)->OnSend();
}

mysocket.h

Code:

#if !defined(AFX_MYSOCKET_H__128B1D2B_23E8_11D6_89CA_B1DCB35AE679__INCLUDED_)
#define AFX_MYSOCKET_H__128B1D2B_23E8_11D6_89CA_B1DCB35AE679__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// MySocket.h : Header-Datei
//



/////////////////////////////////////////////////////////////////////////////
// Befehlsziel CMySocket

class CMySocket : public CAsyncSocket
{
// Attribute
public:

// Operationen
public:
	CMySocket();
	virtual ~CMySocket();

// Überschreibungen
public:
	void SetParent(CDialog* pWnd);
	// Vom Klassen-Assistenten generierte virtuelle Funktionsüberschreibungen
	//{{AFX_VIRTUAL(CMySocket)
	//}}AFX_VIRTUAL

	// Generierte Nachrichtenzuordnungsfunktionen
	//{{AFX_MSG(CMySocket)
		// HINWEIS - Der Klassen-Assistent fügt hier Member-Funktionen ein und entfernt diese.
	//}}AFX_MSG

// Implementierung
protected:
	virtual void OnSend(int nErrorCode);
	virtual void OnReceive(int nErrorCode);
	virtual void OnClose(int nErrorCode);
	virtual void OnConnect(int nErrorCode);
	virtual void OnAccept(int nErrorCode);
private:
	CDialog* m_pWnd;
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ fügt unmittelbar vor der vorhergehenden Zeile zusätzliche Deklarationen ein.

#endif // AFX_MYSOCKET_H__128B1D2B_23E8_11D6_89CA_B1DCB35AE679__INCLUDED_

resource.h

Code:

//{{NO_DEPENDENCIES}}
// Microsoft Developer Studio generated include file.
// Used by IRCpp.rc
//
#define IDM_ABOUTBOX                    0x0010
#define IDD_ABOUTBOX                    100
#define IDS_ABOUTBOX                    101
#define IDD_IRCPP_DIALOG                102
#define IDP_SOCKETS_INIT_FAILED         103
#define IDR_MAINFRAME                   128
#define IDC_STATICTYPE                  1000
#define IDC_RCLIENT                     1001
#define IDC_RSERVER                     1002
#define IDC_STATICNAME                  1003
#define IDC_ESERVNAME                   1004
#define IDC_ESERVPORT                   1005
#define IDC_STATICPORT                  1006
#define IDC_BCONNECT                    1007
#define IDC_BCLOSE                      1008
#define IDC_STATICMSG                   1009
#define IDC_EMSG                        1010
#define IDC_BSEND                       1011
#define IDC_LSENT                       1012
#define IDC_LRECVD                      1013

// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        132
#define _APS_NEXT_COMMAND_VALUE         40001
#define _APS_NEXT_CONTROL_VALUE         1014
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif

Viel spass damit....

Code für eigenständigen Messenger

maxal

0

muhkuh

0

lastwebpage

Guest

Dawen

0