qtforum.de

Code: Alles auswählen

do {
   qApp->processEvents();
   sleep(1);
} while(!bFertig)

Code: Alles auswählen

#include <qapplication.h>
#include <qdom.h>
#include <qfile.h>
#include <qstring.h>
#include <qsocket.h>
#include <stdio.h>
#include "myClient.h"

void MySpecialHost::handleInput() {
	
	QTextStream ausgabe ( stdout, IO_WriteOnly);
	ausgabe << "handleInput!!!";
}

void MySpecialHost::connClosed() {
	QTextStream ausgabe ( stdout, IO_WriteOnly);
	ausgabe << "connClosed bzw error!!!";
}

void MySpecialHost::connOpen() {
	
	QTextStream ausgabe ( stdout, IO_WriteOnly);
	ausgabe << "Connection-OpenSignal.";
}

	
int main(int argc, char *argv[])
{
	QApplication myApp( argc, argv, FALSE ); // ohne GUI
	
	MySpecialHost MySpecialH;
	
	QTextStream ausgabe ( stdout, IO_WriteOnly);
	
	QString xml = "Nachricht an den Server!";
	
	ausgabe << "\n-----SOCKET AUFBAU-----------\n";
	
	MySpecialH.testSock->connectToHost ("localhost",8060);
	
	MySpecialH.testSock->writeBlock(xml,xml.length());
	MySpecialH.testSock->flush();
	
	ausgabe << "\n-----PROCESS EVENTS-----------\n";
	
	do { 
		myApp.processEvents(); 
		
	} while(1);  // bricht nie ab!! NUR zum Testen
	
	MySpecialH.testSock->close();
	
	return myApp.exec();
	
}

Code: Alles auswählen

#include <qapplication.h>
#include <qdom.h>
#include <qfile.h>
#include <qstring.h>
#include <qsocket.h>
#include <stdio.h>

class MySpecialHost : public QObject 
{
	Q_OBJECT

	public:
	
	MySpecialHost()
	{
		testSock = new QSocket(this);
	
		connect( testSock, SIGNAL(connected()),SLOT(connOpen()) );	
		connect( testSock, SIGNAL(readyRead()), SLOT(handleInput()) );
		connect( testSock, SIGNAL(connectionClosed()),SLOT(connClosed()) );
		connect( testSock, SIGNAL(delayedCloseFinished()), SLOT(connClosed()) );
		
		
	}
		
	QSocket* testSock;
	
	int main(int argc, char *argv[]);
	
	public slots:
	
	void handleInput();
	void connClosed();
	void connOpen();
	
	
};

Code: Alles auswählen

do { 
		MySpecialH.testSock->waitForMore(0);
		app.processEvents(); 
		int bAnew=MySpecialH.testSock->bytesAvailable();
		if (bAnew!=bA) {
			ausgabe << bAnew;
			bA=bAnew;
		}

		
	} while(1); 

Code: Alles auswählen

#include <qsocket.h>
#include <qserversocket.h>
#include <qapplication.h>
#include <qtextstream.h>

#include <stdlib.h>


/*
  The ClientSocket class provides a socket that is connected with a client.
  For every client that connects to the server, the server creates a new
  instance of this class.
*/
class ClientSocket : public QSocket
{
    Q_OBJECT
public:
    ClientSocket( int sock, QObject *parent=0, const char *name=0 ) :
        QSocket( parent, name )
    {
        line = 0;
        connect( this, SIGNAL(readyRead()),
                SLOT(readClient()) );
        connect( this, SIGNAL(connectionClosed()),
                SLOT(deleteLater()) );
        setSocket( sock );
    }

    ~ClientSocket()
    {
    }

signals:
    void logText( const QString& );

private slots:
    void readClient()
    {
        QTextStream ts( this );
        while ( canReadLine() ) {
            QString str = ts.readLine();
            emit logText( tr("Read: '%1'\n").arg(str) );

            ts << line << ": " << str << endl;
            emit logText( tr("Wrote: '%1: %2'\n").arg(line).arg(str) );

            line++;
        }
    }

private:
    int line;
};


/*
  The SimpleServer class handles new connections to the server. For every
  client that connects, it creates a new ClientSocket -- that instance is now
  responsible for the communication with that client.
*/
class SimpleServer : public QServerSocket
{
    Q_OBJECT
public:
    SimpleServer( QObject* parent=0 ) :
        QServerSocket( 8060, 1, parent )
    {
        if ( !ok() ) {
            qWarning("Failed to bind to port 4242");
            exit(1);
        }
    }

    ~SimpleServer()
    {
    }

    void newConnection( int socket )
    {
        ClientSocket *s = new ClientSocket( socket, this );
        emit newConnect( s );
    }

signals:
    void newConnect( ClientSocket* );
};


/*
  The ServerInfo class provides a small GUI for the server. It also creates the
  SimpleServer and as a result the server.
*/
class ServerInfo : public QObject
{
    Q_OBJECT
public:
    ServerInfo()
    {
        SimpleServer *server = new SimpleServer( this );

        connect( server, SIGNAL(newConnect(ClientSocket*)),
                SLOT(newConnect(ClientSocket*)) );
    }
    
    QSocket *clientSock;

    ~ServerInfo()
    {
    }

private slots:
    void newConnect( ClientSocket *s )
    {
	    QTextStream ausgabe ( stdout, IO_WriteOnly);
	    ausgabe << "\nnewConnect";
	    
	    clientSock=s;
	    
	    
       // infoText->append( tr("New connection\n") );
        //connect( s, SIGNAL(logText(const QString&)),
                //infoText, SLOT(append(const QString&)) );
        connect( s, SIGNAL(connectionClosed()),
                SLOT(connectionClosed()) );
	connect( s, SIGNAL(readyRead()),
                SLOT(connectionInput()) );
		
    }

    void connectionClosed()
    {
	    QTextStream ausgabe ( stdout, IO_WriteOnly);
	    ausgabe << "\nconnectionClosed";
    }
    
    void connectionInput( )
    {
	    QTextStream ausgabe ( stdout, IO_WriteOnly);
	    ausgabe << "\nconnectionInput";
	    int tempBytesAvailable =  clientSock->bytesAvailable(); 
	    ausgabe << "\nBytesAvailable:";
	    ausgabe << tempBytesAvailable;
	    ausgabe << "\nRead: ";
	    
	    char *inputData=new char[1000];
	    int bytesRead=clientSock->readBlock(inputData, tempBytesAvailable);
	    ausgabe << inputData;
	    
	    ausgabe << "\nSend #1... ";
	    int bytesWritten=clientSock->writeBlock(inputData, tempBytesAvailable);
	
	    ausgabe << "\nFlush... ";
	    clientSock->flush();
	     	    
    }

};

Code: Alles auswählen

#include <qsocket.h>
#include <qserversocket.h>
#include <qapplication.h>
#include <qtextstream.h>

#include <stdlib.h>
#include "MySpecialserver.h"



int main( int argc, char** argv )
{
    QApplication app( argc, argv , 0);
    ServerInfo info;
    
    QTextStream ausgabe ( stdout, IO_WriteOnly);
    ausgabe << "\nvor return";
    //app.setMainWidget( &info );
    //info.show();
    return app.exec();
}