C++ wxSocketEvent类代码示例

void FaceView::OnSocketEvent(wxSocketEvent& event)
{
	wxSocketBase *sock = event.GetSocket();
	static int test = 0;
	// Now we process the event
	switch(event.GetSocketEvent())
	{
		case wxSOCKET_INPUT:
		{
			wxString msg;
			msg.sprintf(_T("input id: %d"), ++test);
			sock->SaveState();
//			sock->SetNotify(wxSOCKET_LOST_FLAG);
			wxLogStatus(msg, 0);
			ServerThread* pThread = new ServerThread(/*this, */m_pApp, sock);
			pThread->Create();
			pThread->Run();
			sock->RestoreState();

			//sock->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_INPUT_FLAG);
			break;
		}
		case wxSOCKET_LOST:
		{
			if(!m_SocketIdHash.erase(sock))
			{
				//sth weird going on, LOG IT!
			}
			sock->Destroy();
			wxLogStatus(wxT("Remote client connection closed."));
			break;
		}
		default: ;
	}
}

// Handle Commands from debugger (and lost connections)
void wxLuaDebuggerwxSocketServer::OnSocketEvent(wxSocketEvent& event)
{
    wxSocketBase *sock = event.GetSocket();

    // Now we process the event
    switch(event.GetSocketEvent())
    {
        case wxSOCKET_INPUT:
        {
            // We disable input events, so that the test doesn't trigger
            // wxSocketEvent again.
            sock->SetNotify(wxSOCKET_LOST_FLAG);

            unsigned char debugEvent = 0; // wxLuaDebuggeeEvents_Type
            if (m_acceptedSocket->ReadCmd(debugEvent))
                HandleDebuggeeEvent(debugEvent);

            // Enable input events again.
            sock->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_INPUT_FLAG);
            break;
        }
        case wxSOCKET_LOST:
        {
            m_acceptedSocket->Destroy();
            delete m_acceptedSocket;
            m_acceptedSocket = NULL;
            break;
        }
        default:
            // Error
            break;
    }
}

void CRealControlSocket::OnSocketEvent(wxSocketEvent &event)
{
	if (!m_pBackend)
		return;

	if (event.GetId() != m_pBackend->GetId())
		return;

	switch (event.GetSocketEvent())
	{
	case wxSOCKET_CONNECTION:
		m_onConnectCalled = true;
		OnConnect();
		break;
	case wxSOCKET_INPUT:
		if (!m_onConnectCalled)
		{
			m_onConnectCalled = true;
			OnConnect();
		}
		OnReceive();
		break;
	case wxSOCKET_OUTPUT:
		OnSend();
		break;
	case wxSOCKET_LOST:
		OnClose();
		break;
	}
}

void WinEDA_DrawFrame::OnSockRequest(wxSocketEvent& evt)
/********************************************************/
/* Fonction appelee a chaque demande d'un client
*/
{
    size_t len;
    wxSocketBase *sock = evt.GetSocket();

    switch (evt.GetSocketEvent())
    {
    case wxSOCKET_INPUT:
        sock->Read(server_ipc_buffer,1);
        len = sock->Read(server_ipc_buffer+1,IPC_BUF_SIZE-2).LastCount();
        server_ipc_buffer[len+1] = 0;
        if(RemoteFct ) RemoteFct(server_ipc_buffer);
        break;

    case wxSOCKET_LOST:
        return;
        break;

    default:
        wxPrintf( wxT("WinEDA_DrawFrame::OnSockRequest() error: Invalid event !"));
        break;
    }
}

/* Function called on every client request.
 */
void EDA_DRAW_FRAME::OnSockRequest( wxSocketEvent& evt )
{
    size_t        len;
    wxSocketBase* sock = evt.GetSocket();

    switch( evt.GetSocketEvent() )
    {
    case wxSOCKET_INPUT:
        sock->Read( client_ipc_buffer, 1 );

        if( sock->LastCount() == 0 )
            break;                    // No data, occurs on opening connection

        sock->Read( client_ipc_buffer + 1, IPC_BUF_SIZE - 2 );
        len = 1 + sock->LastCount();
        client_ipc_buffer[len] = 0;
        ExecuteRemoteCommand( client_ipc_buffer );
        break;

    case wxSOCKET_LOST:
        return;
        break;

    default:
        wxPrintf( wxT( "EDA_DRAW_FRAME::OnSockRequest() error: Invalid event !" ) );
        break;
    }
}

void CProxyEventHandler::ProxySocketHandler(wxSocketEvent& event)
{
	CProxySocket *sock = dynamic_cast<CProxySocket *>(event.GetSocket());
	if (sock) {
		sock->m_proxyStateMachine->Schedule(event.GetSocketEvent());
	} else {
		// we're doomed :)
	}
	sock->m_proxyStateMachine->Clock();
}

void wxMainFrame::OnSocketEvent(wxSocketEvent& event)
{
  if (event.GetSocketEvent()==wxSOCKET_INPUT)
  {
//    m_TEDProtocol->GetSocketData();
  }
  else if (event.GetSocketEvent()==wxSOCKET_LOST)
  {
    ::wxMessageBox(_("Se perdió la conexión con el servidor.\nEl cliente se cerrará."));
    Close();
  }
}

void wxScopeServerDialog::OnSocketEvent(wxSocketEvent& event)
{
  wxString s = _("OnSocketEvent: ");
  wxSocketBase *sock = event.GetSocket();
/*
  // First, print a message
  switch(event.GetSocketEvent())
  {
    case wxSOCKET_INPUT : s.Append(_("wxSOCKET_INPUT\n")); break;
    case wxSOCKET_LOST  : s.Append(_("wxSOCKET_LOST\n")); break;
    default             : s.Append(_("Unexpected event !\n")); break;
  }
  Tx_ServerLog->AppendText(s);
*/

  // Now we process the event
  switch(event.GetSocketEvent())
  {
    case wxSOCKET_INPUT:
    {
      // We disable input events, so that the test doesn't trigger
      // wxSocketEvent again.
      sock->SetNotify(wxSOCKET_LOST_FLAG);

      if (!m_server->HandleINPUT(sock)) // delegate input handling to class
         Tx_ServerLog->AppendText(_("HandleINPUT failed\n"));

      // Enable input events again.
      sock->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_INPUT_FLAG);
      break;
    }
    case wxSOCKET_LOST:
    {
      m_numClients--;

      // Destroy() should be used instead of delete wherever possible,
      // due to the fact that wxSocket uses 'delayed events' (see the
      // documentation for wxPostEvent) and we don't want an event to
      // arrive to the event handler (the frame, here) after the socket
      // has been deleted. Also, we might be doing some other thing with
      // the socket at the same time; for example, we might be in the
      // middle of a test or something. Destroy() takes care of all
      // this for us.

      Tx_ServerLog->AppendText(_("Closing socket.\n\n"));
      sock->Notify(false);
      sock->Destroy();
      break;
    }
    default: ;
  }

}

void tracelogApp::OnSocketEvent(wxSocketEvent& event)
{
    wxSocketBase *sock = event.GetSocket();
    if (wxSOCKET_LOST == event.GetSocketEvent()) {
        sock->Notify(false);
        std::map<wxSocketBase *, wxSocketOutputStream *>::iterator it = m_mClients.find(sock);
        if (m_mClients.end() != it) {
            delete it->second;
            m_mClients.erase(it);
        }
        sock->Destroy();
    }
}

void CTlsSocket::OnSocketEvent(wxSocketEvent& event)
{
	wxASSERT(m_pSocket);
	if (!m_session)
		return;

	if (event.GetId() != m_pSocketBackend->GetId())
		return;

	switch (event.GetSocketEvent())
	{
	case wxSOCKET_INPUT:
		OnRead();
		break;
	case wxSOCKET_OUTPUT:
		OnSend();
		break;
	case wxSOCKET_LOST:
		{
			m_canCheckCloseSocket = true;
			char tmp[100];
			m_pSocketBackend->Peek(&tmp, 100);
			if (!m_pSocketBackend->Error())
			{
				int lastCount = m_pSocketBackend->LastCount();

				if (lastCount)
					m_pOwner->LogMessage(Debug_Verbose, _T("CTlsSocket::OnSocketEvent(): pending data, postponing wxSOCKET_LOST"));
				else
					m_socketClosed = true;
				OnRead();

				if (lastCount)
					return;
			}

			m_pOwner->LogMessage(Debug_Info, _T("CTlsSocket::OnSocketEvent(): wxSOCKET_LOST received"));

			//Uninit();
			wxSocketEvent evt(GetId());
			evt.m_event = wxSOCKET_LOST;
			wxPostEvent(m_pEvtHandler, evt);
		}
		break;
	default:
		break;
	}
}

void CslUDP::OnSocketEvent(wxSocketEvent& event)
{
    if (event.GetSocketEvent()!=wxSOCKET_INPUT)
        return;

    wxIPV4address addr;
    wxUint32 size;
    CslUDPPacket *packet=new CslUDPPacket(CSL_MAX_PACKET_SIZE);

    m_socket->RecvFrom(addr,packet->Data(),CSL_MAX_PACKET_SIZE);

    if (m_socket->Error())
    {
        packet->FreeData();
#ifndef __WXMSW__
        LOG_DEBUG("Error receiving packet: %s\n",U2A(GetSocketError(m_socket->LastError())));
#endif
    }

    size=m_socket->LastCount();
    packet->SetAddr(addr);
    packet->SetSize(size);
    m_bytesIn+=size;
    m_packetsIn++;

    wxCommandEvent evt(wxCSL_EVT_PING);
    evt.SetClientData(packet);
    wxPostEvent(m_evtHandler,evt);
}

void FaceView::OnServerEvent(wxSocketEvent& event)
{
    wxString s;
    wxSocketBase *sock = 0;

    if(event.GetSocketEvent() != wxSOCKET_CONNECTION)
        return;

    // Accept new connection if there is one in the pending
    // connections queue, else exit. We use Accept(FALSE) for
    // non-blocking accept (although if we got here, there
    // should ALWAYS be a pending connection).
    sock = m_pServer->Accept(false);

    if (sock)
    {
        wxLogStatus(_T("New client connection accepted"), 0);
        m_SocketIdHash[sock] = ++m_clientCount; // add socket to map of connected clients

        // Notify the client
        Notification note("CONNECTION_OK", m_clientCount);
        fireNotification(note);
    }
    else
        return;

    sock->SetEventHandler(*this, Socket_event);
    sock->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
    sock->Notify(TRUE);
}

void CslUDP::OnSocketEvent(wxSocketEvent& event)
{
    if (event.GetSocketEvent()!=wxSOCKET_INPUT)
        return;

    wxInt32 read;
    wxIPV4address addr;
    CslNetPacket *packet = CslNetPacket::Create();
    packet->Alloc(CSL_MAX_PACKET_SIZE);

    if (m_socket->RecvFrom(addr, packet->Data(), CSL_MAX_PACKET_SIZE).Error())
    {
#ifndef __WXMSW__
        CSL_LOG_DEBUG("error RecvFrom() failed. (%s)\n",
                      U2C(GetSocketError(m_socket->LastError())));
#endif
        CslNetPacket::Destroy(packet, true);
        return;
    }

    if ((read = m_socket->LastCount())==0)
    {
        CslNetPacket::Destroy(packet, true);
        return;
    }

    packet->SetAddr(addr);
    packet->SetSize(read);

    m_bytesIn += read;
    m_packetsIn++;

    CslPingEvent evt(packet);
    wxPostEvent(m_evtHandler, evt);
}

void SocketEvents::OnSocketEvent(wxSocketEvent& event)
{
	Socket* sock = (Socket*)event.GetClientData();
	if (sock == NULL) {
		m_net_class.OnError(_T("sock = 0"));
		return;
	}

	if ( event.GetSocketEvent() == wxSOCKET_INPUT ) {
		m_net_class.OnDataReceived( *sock );
	} else if ( event.GetSocketEvent() == wxSOCKET_LOST ) {
		m_net_class.OnDisconnected( *sock );
	} else if ( event.GetSocketEvent() == wxSOCKET_CONNECTION ) {
		m_net_class.OnConnected( *sock );
	} else {
		m_net_class.OnError(_T("Unknown socket event."));
	}
}

void kitchenFrame::OnSocketEvent(wxSocketEvent& event)
{
    wxSocketBase *sock = event.GetSocket();
    switch(event.GetSocketEvent())
    {
    case wxSOCKET_CONNECTION:
    {
//    wxMessageBox(_("Connected!"));
        break;
    }

    case wxSOCKET_INPUT:
    {

        sock->SetNotify(wxSOCKET_LOST_FLAG);

        unsigned char c;
        sock->Read(&c, 1);

        switch (c)
        {
        case 0xBE:
            readFromDining(sock);
            break; //this means we are receiving something from dining room f.e. new order
            //  case 0xCE: Test2(sock); break;
            //  case 0xDE: Test3(sock); break;
        }

        sock->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_INPUT_FLAG);
        break;
    }
    case wxSOCKET_LOST:
    {

//      wxMessageBox(_("DisConnected!"));
        StatusBar1->SetStatusText(_("Lost connection."),1);
//      sock->Destroy();
        sock->Close();
        break;
    }
    default:
        ;
    }
}