/*modify by Lee 11-03-2014
add the function to get and set the state from table tb_state
*/
WBSDBaseWindow::WBSDBaseWindow(QWidget *parent)
: QMainWindow(parent)
{
connect(wbsd_SERIAL_PORT::itsInstance,SIGNAL(gotMessage(Message)),this,SLOT(gotMessage(Message)));
connect(wbsd_SERIAL_PORT::itsInstance,SIGNAL(connectionStatusChanged(int,StringMessage)),this,SLOT(connectionStatusChanged(int,StringMessage)));
curtUnitTmp =0;
_crtMachineUnit = UNIT_Other;
}
bool KXMessages::x11Event( XEvent* ev_P )
{
if( ev_P->type != ClientMessage || ev_P->xclient.format != 8 )
return QWidget::x11Event( ev_P );
if( ev_P->xclient.message_type != d->accept_atom1 && ev_P->xclient.message_type != d->accept_atom2 )
return QWidget::x11Event( ev_P );
char buf[ 21 ]; // can't be longer
int i;
for( i = 0;
i < 20 && ev_P->xclient.data.b[ i ] != '\0';
++i )
buf[ i ] = ev_P->xclient.data.b[ i ];
buf[ i ] = '\0';
if( d->incoming_messages.contains( ev_P->xclient.window ))
{
if( ev_P->xclient.message_type == d->accept_atom1 && d->accept_atom1 != d->accept_atom2 )
// two different messages on the same window at the same time shouldn't happen anyway
d->incoming_messages[ ev_P->xclient.window ] = QByteArray();
d->incoming_messages[ ev_P->xclient.window ] += buf;
}
else
{
if( ev_P->xclient.message_type == d->accept_atom2 && d->accept_atom1 != d->accept_atom2 )
return false; // middle of message, but we don't have the beginning
d->incoming_messages[ ev_P->xclient.window ] = buf;
}
if( i < 20 ) // last message fragment
{
emit gotMessage( QString::fromUtf8( d->incoming_messages[ ev_P->xclient.window ] ));
d->incoming_messages.remove( ev_P->xclient.window );
}
return false; // lets other KXMessages instances get the event too
}
void Connection::IncomingMsg (HalfPacket hp)
{
quint32 msgId = 0, flags = 0;
Str1251 from;
FromMRIM (hp.Data_, msgId, flags, from);
QByteArray textBA;
FromMRIM (hp.Data_, textBA);
const QString& text = (flags & MsgFlag::CP1251) ?
FromMRIM1251 (textBA) :
FromMRIM16 (textBA);
qDebug () << Q_FUNC_INFO << from << text << (flags & MsgFlag::NoRecv);
if (!(flags & MsgFlag::NoRecv))
Write (PF_.MessageAck (from, msgId).Packet_);
if (flags & MsgFlag::Authorize)
emit gotAuthRequest (from, text);
else if (flags & MsgFlag::Notify)
TM_->GotNotification (from);
else if (flags & MsgFlag::Alarm)
emit gotAttentionRequest (from, text);
else if (flags & MsgFlag::Multichat)
{
}
else
emit gotMessage ({msgId, flags, from, text, QDateTime::currentDateTime ()});
}
void MessageDispatcherThread::run()
{
QTcpSocket socket;
socket.setSocketDescriptor(m_descriptor);
quint64 dataSize = 0;
while(!m_doQuit)
{
socket.waitForReadyRead();
if (dataSize == 0) {
QDataStream stream(&socket);
stream.setVersion(QDataStream::Qt_4_6);
if (socket.bytesAvailable() < sizeof(quint64))
continue;
stream >> dataSize;
}
if (socket.bytesAvailable() < dataSize)
continue;
emit gotMessage(socket.readAll(), socket.peerAddress());
break;
}
void MetaEntry::handleRealGotMessage (QObject *msgObj)
{
IMessage *msg = qobject_cast<IMessage*> (msgObj);
if (!msg)
{
qWarning () << Q_FUNC_INFO
<< msgObj
<< "doesn't implement IMessage";
return;
}
MetaMessage *message = new MetaMessage (msgObj, this);
const bool shouldSort = !Messages_.isEmpty () &&
Messages_.last ()->GetDateTime () > msg->GetDateTime ();
Messages_ << message;
if (shouldSort)
std::stable_sort (Messages_.begin (), Messages_.end (),
[] (IMessage *left, IMessage *right)
{
return left->GetDateTime () < right->GetDateTime ();
});
emit gotMessage (message);
}
void RoomCLEntry::HandleMessage (RoomPublicMessage *msg)
{
Account_->GetParentProtocol ()->GetProxyObject ()->
GetFormatterProxy ().PreprocessMessage (msg);
AllMessages_ << msg;
emit gotMessage (msg);
}
void RoomCLEntry::HandleMessage (RoomPublicMessage *msg)
{
GlooxProtocol *proto = qobject_cast<GlooxProtocol*> (Account_->GetParentProtocol ());
IProxyObject *proxy = qobject_cast<IProxyObject*> (proto->GetProxyObject ());
proxy->PreprocessMessage (msg);
AllMessages_ << msg;
emit gotMessage (msg);
}
void RFCommRecvThread::messageDone( int id, RFCommMessageObject* msg )
{
assert( _recvBuffer.find( id ) != _recvBuffer.end() );
assert( msg->payloadComplete() );
emit gotMessage( *msg );
delete msg;
_recvBuffer.erase( id );
}
void EntryBase::HandleMessage (IrcMessage *msg)
{
msg->SetOtherPart (this);
IrcProtocol *proto = qobject_cast<IrcProtocol*> (Account_->
GetParentProtocol ());
IProxyObject *proxy =
qobject_cast<IProxyObject*> (proto->GetProxyObject ());
proxy->PreprocessMessage (msg);
AllMessages_ << msg;
emit gotMessage (msg);
}
AbstractViewInspector::AbstractViewInspector(QObject *parent) :
QObject(parent),
m_currentTool(0),
m_showAppOnTop(false),
m_designModeBehavior(false),
m_animationPaused(false),
m_slowDownFactor(1.0),
m_debugService(QDeclarativeInspectorService::instance())
{
connect(m_debugService, SIGNAL(gotMessage(QByteArray)),
this, SLOT(handleMessage(QByteArray)));
}
void Guitest::init(){
gui = new clientGUI;
QObject::connect(gui, SIGNAL(sendConnectInfo(QString,int,QString)), this, SLOT(login(QString,int,QString)));
QObject::connect(this, SIGNAL(connected()), gui, SLOT(wasConnected()));
QObject::connect(gui, SIGNAL(sendMsg(QString)), this, SLOT(sendMsg(QString)));
QObject::connect(this, SIGNAL(newMessage(QString,QString)), gui, SLOT(gotMessage(QString,QString)));
QObject::connect(gui, SIGNAL(updateStatus(QString)), this, SLOT(status(QString)));
QObject::connect(this, SIGNAL(listUpdate(QMap<QString,QString>&)), gui, SLOT(updateList(QMap<QString,QString>&)));
QObject::connect(this, SIGNAL(sendError(QString)), gui, SLOT(catchError(QString)));
QObject::connect(this, SIGNAL(sendServerDisconnect()), gui, SLOT(onServerDisconnect()));
}
void EntryBase::HandleMessage (GlooxMessage *msg)
{
if (msg->GetMessageType () == IMessage::Type::ChatMessage)
{
HasUnreadMsgs_ = true;
UnreadMessages_ << msg;
}
const auto proxy = Account_->GetParentProtocol ()->GetProxyObject ();
proxy->GetFormatterProxy ().PreprocessMessage (msg);
AllMessages_ << msg;
emit gotMessage (msg);
}
void EntryBase::HandleMessage (GlooxMessage *msg)
{
if (msg->GetMessageType () == IMessage::MTChatMessage)
{
HasUnreadMsgs_ = true;
UnreadMessages_ << msg;
}
GlooxProtocol *proto = qobject_cast<GlooxProtocol*> (Account_->GetParentProtocol ());
IProxyObject *proxy = qobject_cast<IProxyObject*> (proto->GetProxyObject ());
proxy->PreprocessMessage (msg);
AllMessages_ << msg;
emit gotMessage (msg);
}
void ConferenceTask::parseMessage( YMSGTransfer *t )
{
kdDebug(YAHOO_RAW_DEBUG) ;
QString room = t->firstParam( 57 );
QString from = t->firstParam( 3 );
bool utf = QString( t->firstParam( 97 ) ).toInt() == 1;
QString msg;
if( utf )
msg = QString::fromUtf8( t->firstParam( 14 ) );
else
msg = t->firstParam( 14 );
if( !msg.isEmpty() )
emit gotMessage( from, room, msg );
}
void Buddy::Store (ConvIMMessage *msg)
{
Messages_ << msg;
emit gotMessage (msg);
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
console = new Console;
console->setEnabled(false);
tabs = new QTabWidget();
setCentralWidget(tabs);
serial = new QSerialPort(this);
settings = new SettingsDialog;
ui->actionConnect->setEnabled(true);
ui->actionDisconnect->setEnabled(false);
ui->actionQuit->setEnabled(true);
ui->actionConfigure->setEnabled(true);
ui->actionAscii->setEnabled(true);
ui->actionBinary->setEnabled(true);
nodeNames = new NodeNames();
logFile = new LogFile();
decoder = new Decoder();
connect(decoder, SIGNAL(logMessage(QString)), logFile, SLOT(add(QString)));
tempDistModel = new TempModel(this);
tempDistModel->setNodeNameHelper(nodeNames);
zoneSetpointModel = new SetpointModel(this);
zoneSetpointModel->setNodeNameHelper(nodeNames);
demandModel = new DemandModel(this);
demandModel->setNodeNameHelper(nodeNames);
commandModel = new CommandModel(this);
commandModel->setNodeNameHelper(nodeNames);
nowNextModel = new ProgNowNextModel(this);
nowNextModel->setNodeNameHelper(nodeNames);
unknown1060Model = new Unknown18Model(this);
unknown1060Model->setNodeNameHelper(nodeNames);
unknown1100Model = new Unknown16Model(this);
unknown1100Model->setNodeNameHelper(nodeNames);
unknown0008Model = new Unknown16Model(this);
unknown0008Model->setNodeNameHelper(nodeNames);
unknown0009Model = new Unknown16Model(this);
unknown0009Model->setNodeNameHelper(nodeNames);
unknown1F09Model = new Unknown16Model(this);
unknown1F09Model->setNodeNameHelper(nodeNames);
unknown3B00Model = new Unknown16Model(this);
unknown3B00Model->setNodeNameHelper(nodeNames);
messageModel = new MessageModel(this);
MessageTab *messageTab = new MessageTab();
messageTab->setMessageCountersModel(commandModel);
messageTab->setMessageLogModel(messageModel);
tabs->addTab(messageTab, "Messages");
TemperaturesTab *temperaturesTab = new TemperaturesTab();
temperaturesTab->setMeasuredTempsModel(tempDistModel);
temperaturesTab->setSetpointsModel(zoneSetpointModel);
temperaturesTab->setDemandsModel(demandModel);
temperaturesTab->setProgNowNextModel(nowNextModel);
tabs->addTab(temperaturesTab, "Temperatures");
UnknownTab *unknownTab = new UnknownTab();
unknownTab->set0008Model(unknown0008Model);
unknownTab->set0009Model(unknown0009Model);
unknownTab->set1060Model(unknown1060Model);
unknownTab->set1100Model(unknown1100Model);
unknownTab->set1F09Model(unknown1F09Model);
unknownTab->set3B00Model(unknown3B00Model);
tabs->addTab(unknownTab, "Unknown messages");
DecoderTab *decoderTab = new DecoderTab();
tabs->addTab(decoderTab, "Decoder");
tabs->addTab(console, "Console");
initActionsConnections();
parser=NULL;
setBinaryParser();
connect(serial, SIGNAL(readyRead()), this, SLOT(readData()));
connect(decoder, SIGNAL(consoleMessage(QString)), this, SLOT(message(QString)));
connect(decoder, SIGNAL(gotMessage(QByteArray)), messageModel, SLOT(newData(QByteArray)));
//connect decoded messages to tables
connect(decoder, SIGNAL(zoneTempDistribution(quint32,quint32,quint32,float)), tempDistModel, SLOT(newData(quint32,quint32,quint32,float)));
connect(decoder, SIGNAL(zoneSetpointSetting(quint32,quint32,quint32,float)), zoneSetpointModel, SLOT(newData(quint32,quint32,quint32,float)));
connect(decoder, SIGNAL(heatDemand(quint32,quint32,quint32,quint32)), demandModel, SLOT(newData(quint32, quint32, quint32, quint32)));
connect(decoder, SIGNAL(gotCommand(quint32,quint32,quint32)), commandModel, SLOT(newData(quint32,quint32,quint32)));
connect(decoder, SIGNAL(programmerNowNext(quint32,quint32,float,float,quint32)), nowNextModel, SLOT(newData(quint32, quint32, float, float, quint32)));
//connect unknown messages to tables
connect(decoder, SIGNAL(unknown1060(quint32,quint32,QByteArray)), unknown1060Model, SLOT(newData(quint32,quint32,QByteArray)));
connect(decoder, SIGNAL(unknown1100(quint32,QByteArray)), unknown1100Model, SLOT(newData(quint32,QByteArray)));
connect(decoder, SIGNAL(unknown0008(quint32,QByteArray)), unknown0008Model, SLOT(newData(quint32,QByteArray)));
connect(decoder, SIGNAL(unknown0009(quint32,QByteArray)), unknown0009Model, SLOT(newData(quint32,QByteArray)));
connect(decoder, SIGNAL(unknown1F09(quint32,QByteArray)), unknown1F09Model, SLOT(newData(quint32,QByteArray)));
connect(decoder, SIGNAL(unknown3B00(quint32,QByteArray)), unknown3B00Model, SLOT(newData(quint32,QByteArray)));
//connect decoder stats to decoder tab
connect(decoder, SIGNAL(inputByteCount(quint32)), decoderTab, SLOT(inputByteCount(quint32)));
connect(decoder, SIGNAL(candidatePayloadCount(quint32)), decoderTab, SLOT(candidatePayloadCount(quint32)));
connect(decoder, SIGNAL(overLengthMessageCount(quint32)), decoderTab, SLOT(overLengthMessageCount(quint32)));
connect(decoder, SIGNAL(lengthOddCount(quint32)), decoderTab, SLOT(lengthOddCount(quint32)));
connect(decoder, SIGNAL(manchesterInvalidCount(quint32)), decoderTab, SLOT(manchesterInvalidCount(quint32)));
connect(decoder, SIGNAL(validMessageCount(quint32)), decoderTab, SLOT(validMessageCount(quint32)));
//connect decoded messages to influxdb
connect(decoder, SIGNAL(influxData(QString)), this, SLOT(writeInflux(QString)));
//receive broadcast traffic from RF receiver
udpSocket = new QUdpSocket(this);
udpSocket->bind(8888, QUdpSocket::ShareAddress);
connect(udpSocket, SIGNAL(readyRead()),
this, SLOT(readPendingDatagrams()));
//send influx format data
influxSocket = new QUdpSocket(this);
}
void ToxContact::HandleMessage (ChatMessage *msg)
{
AllMessages_ << msg;
emit gotMessage (msg);
}
void ChannelCLEntry::HandleMessage (ChannelPublicMessage *msg)
{
AllMessages_ << msg;
emit gotMessage (msg);
}
void WBSDBaseWindow::disconnectToMessages(QObject *aWindow){
disconnect(aWindow,SLOT(gotMessage(Message)));
disconnect(aWindow,SLOT(connectionStatusChanged (int,StringMessage)));
}
void Client::tcpSocketReadyRead() {
// qDebug("INFO: Client::tcpSocketReadyRead - reporting");
QByteArray message = s->readAll();
if ( message.mid(0,4) == tr("GET ").toUtf8() ) {
// qDebug("INFO: Client::tcpSocketReadyRead - new Handshake");
// qDebug(message);
} else {
// qDebug("INFO: Client::tcpSocketReadyRead - not Handshake!");
// qDebug(message);
if ( message.at(0) == char(0) && message.at(message.size()-1) == char(255) ) {
// qDebug("INFO: Client::tcpSocketReadyRead - new Message!");
QByteArray ba = message.mid(1, message.size()-2);
emit gotMessage(n, ba);
// qDebug(text.toAscii());
}
return;
}
QByteArray origin;
if ( message.contains("Origin:") ) {
int p = message.indexOf("Origin: ");
int d = message.indexOf("\r\n", p);
origin = message.mid(p+8, d-p-8);
}
int k1, k2;
k1 = message.indexOf("Sec-WebSocket-Key1:");
k2 = message.indexOf("Sec-WebSocket-Key2:");
if ( k1 != -1 || k2 != -1 ) {
// qDebug("INFO: Client::tcpSocketReadyRead - keys found");
} else {
qDebug("ERROR: Client::tcpSocketReadyRead - Sec-WebSocket keys were not found!");
return;
}
QString kt1, kt2;
kt1 = message.mid(k1+20,message.indexOf("\n",k1+20)-k1-21);
kt2 = message.mid(k2+20,message.indexOf("\n",k2+20)-k2-21);
if ( !kt1.contains(" ") || !kt2.contains(" ") ) {
qDebug("ERROR: Widget::tcpSocketReadyRead - Sec-WebSocket keys had no spaces!");
return;
}
int s1 = 0, s2 = 0;
unsigned int n1 = 0, n2 = 0;
for ( int i = 0; i < kt1.length(); i++ ) {
if ( kt1.at(i).isDigit() )
n1 = n1*10 + kt1.at(i).digitValue();
if ( kt1.at(i).isSpace() )
s1++;
}
for ( int i = 0; i < kt2.length(); i++ ) {
if ( kt2.at(i).isDigit() )
n2 = n2*10 + kt2.at(i).digitValue();
if ( kt2.at(i).isSpace() )
s2++;
}
n1 = n1/s1;
n2 = n2/s2;
char challenge[16];
memcpy(challenge, &n1, 4);
memcpy(challenge+4, &n2, 4);
char t;
t = challenge[0];
challenge[0] = challenge[3];
challenge[3] = t;
t = challenge[1];
challenge[1] = challenge[2];
challenge[2] = t;
t = challenge[4];
challenge[4] = challenge[7];
challenge[7] = t;
t = challenge[5];
challenge[5] = challenge[6];
challenge[6] = t;
QString key_3 = message.mid(message.indexOf("\r\n\r\n")+4,8);
for ( int i = 0; i < 8; i++ )
challenge[8+i] = key_3.at(i).unicode();
QCryptographicHash digest(QCryptographicHash::Md5);
digest.addData(challenge, 16);
QByteArray location;
location.append("ws://");
QByteArray host;
if ( message.contains("Host:") ) {
int p = message.indexOf("Host: ");
int d = message.indexOf("\r\n", p);
host = message.mid(p+6,d-p-6);
}
location.append(host);
QByteArray resource_name = message.mid(4, message.indexOf(" ",4)-4);
location.append(resource_name);
QByteArray responce;
responce += tr("HTTP/1.1 101 WebSocket Protocol Handshake\r\n");
responce += tr("Upgrade: WebSocket\r\n");
responce += tr("Connection: Upgrade\r\n");
responce += tr("Sec-WebSocket-Origin: ") + origin + tr("\r\n");
responce += tr("Sec-WebSocket-Location: ") + location + tr("\r\n");
// responce += tr("Sec-WebSocket-Protocol: \r\n");
responce += tr("\r\n");
responce += digest.result();
// qDebug("Handshake responce\n");
// qDebug(responce);
// qDebug(responce.toHex());
s->write(responce);
timer = new QTimer(this);
connect( timer, SIGNAL(timeout()), this, SLOT(handshakeTimeOut()));
timer->start(0);
}
void MessageManager::receiveNode( QDomNode node )
{
qDebug( "MessageManager::receiveNode()" );
QDomElement element = node.toElement();
if( node.nodeName() == "message" )
{
MessageType type = NormalMessage;
//Normal Message
QString jid, subject, text;
if( element.hasAttribute("from") )
jid = element.attribute("from");
else if( element.hasAttribute("to") )
jid = element.attribute("to");
//Error Message
int errornum;
QString errorname;
//News Message
QString newsType, title, url;
QDateTime datetime = QDateTime::currentDateTime( Qt::LocalTime );
if( !node.hasChildNodes() )
return;
if( jid == "newspub" )
type = NewsMessage;
if( element.hasAttribute( "type" ) )
{
if( element.attribute( "type" ) == "chat" )
type = ChatMessage;
else if( element.attribute( "type" ) == "error" )
type = ErrorMessage;
}
for( QDomNode n = node.firstChild(); !n.isNull(); n = n.nextSibling() )
{
QDomElement e = n.toElement();
if ( n.nodeName() == "subject" )
{
text = decode( e.attribute( "subject" ).latin1() );
}
else if ( n.nodeName() == "body" )
{
text = decode( e.text().latin1() );
}
else if( n.nodeName() == "no" )
type = AdvertisementMessage;
else if( n.nodeName() == "error" )
{
if( e.hasAttribute( "code" ) )
errornum = e.attribute( "code" ).toInt();
errorname = decode( e.text().latin1() );
}
else if( n.nodeName() == "x" )
{
if( n.hasChildNodes() )
{
QDomNode items = n.firstChild();
for( QDomNode item = node.firstChild(); !item.isNull(); item = item.nextSibling() )
{
QDomElement itemElement = n.toElement();
if( item.nodeName() == "title" )
title = decode( itemElement.text().latin1() );
else if( item.nodeName() == "date" )
{
QString date = decode( itemElement.text().latin1() );
int year = date.mid( 0, 4 ).toInt();
int month = date.mid( 5, 2 ).toInt();
int day = date.mid( 8, 2 ).toInt();
int hour = date.mid( 11, 2 ).toInt();
int min = date.mid( 13, 2 ).toInt();
int sec = date.mid( 16, 2 ).toInt();
datetime.setDate( QDate( year, month, day ) );
datetime.setTime( QTime( hour, min, sec ) );
}
else if( item.nodeName() == "url" )
url = decode( itemElement.text().latin1() );
else if( item.nodeName() == "text" )
text = decode( itemElement.text().latin1() );
}
}
else
{
if( e.hasAttribute( "xmlns" ) && e.attribute( "xmlns" ) == "jabber:x:delay" )
{
QString stamp = e.attribute( "stamp" );
int year = stamp.mid( 0, 4 ).toInt();
int month = stamp.mid( 4, 2 ).toInt();
int day = stamp.mid( 6, 2 ).toInt();
int hour = stamp.mid( 9, 2 ).toInt();
int min = stamp.mid( 12, 2 ).toInt();
int sec = stamp.mid( 15, 2 ).toInt();
datetime.setDate( QDate( year, month, day ) );
datetime.setTime( QTime( hour, min, sec ) );
}
}
}
}
if( text.isEmpty() )
return;
if( type == NormalMessage)
emit gotMessage( jid, text, datetime );
else if( type == ChatMessage )
emit gotChatMessage( jid, text, datetime );
else if( type == ErrorMessage )
emit gotErrorMessage( jid, errornum, errorname, text, datetime );
else if( type == NewsMessage )
emit gotNewsMessage( newsType, title, datetime, url, text );
}
else if( node.nodeName() == "n" )
{
QString from = decode( element.attribute( "f" ).ascii() );
QString subject = decode( element.attribute( "s" ).ascii() );
emit gotEmail( from, subject );
}
else if( node.nodeName() == "w" && element.hasAttribute( "f" ) && element.hasAttribute( "e" ) && element.hasAttribute( "s" ) )
{
QString jid = element.attribute( "f" );
QString email = element.attribute( "e" );
QString www = element.attribute( "s" );
QString msg = element.text();
emit gotWebMessage( jid, email, www, msg );
}
else if( node.nodeName() == "m" && element.hasAttribute( "f" ) && element.hasAttribute( "tp" ) )
{
QString jid = element.attribute( "f" );
QString type = element.attribute( "tp" );
if( type == "a" )
emit gotSoundAlert( jid );
else if( type == "t" || type == "u" )
{
bool start_typing = true;
if( type == "t" )
start_typing = true;
else if( type == "u" )
start_typing = false;
emit gotTypingNotification( jid, start_typing );
}
}
}
void WBSDBaseWindow::connectToMessages(QObject *aWindow){
connect(this ,SIGNAL(transferMessage(Message)),aWindow,SLOT(gotMessage(Message)));
connect(this ,SIGNAL(newConnectionStatus(int,StringMessage)),aWindow,SLOT(connectionStatusChanged (int,StringMessage)));
}
