void NoteItem::setUnread(bool unread)
{
if (m_unread != unread) {
m_unread = unread;
emit unreadChanged();
}
}
void ChatChannel::markRead(quint64 id)
{
if (id == Q_UINT64_C(0xffffffffffffffff)) {
m_unread.clear();
emit unreadChanged(m_unread);
emit unreadCountChanged(m_unread.count());
return;
}
for (int i = 0; i < m_unread.size(); ++i) {
if (m_unread.at(i).id() == id) {
m_unread.removeAt(i);
emit unreadChanged(m_unread);
emit unreadCountChanged(m_unread.count());
return;
}
}
}
Telegram::Telegram(int argc, char **argv, QObject *parent) :
QObject(parent)
{
p = new TelegramPrivate;
p->update_dialog_again = false;
p->update_dialog_timer_id = 0;
p->update_contact_again = false;
p->update_contact_timer_id = 0;
p->authenticating = false;
p->started = false;
p->msg_send_timer = 0;
p->last_wait_and_get = Enums::NoWaitAndGet;
p->tg_thread = new TelegramThread(argc,argv);
connect( p->tg_thread, SIGNAL(contactsChanged()) , SIGNAL(meChanged()) );
connect( p->tg_thread, SIGNAL(contactsChanged()) , SLOT(_loadOwnInfo()) );
connect( p->tg_thread, SIGNAL(unreadChanged()) , SIGNAL(unreadChanged()) );
connect( p->tg_thread, SIGNAL(contactsChanged()) , SIGNAL(contactsChanged()) );
connect( p->tg_thread, SIGNAL(dialogsChanged()) , SIGNAL(dialogsChanged()) );
connect( p->tg_thread, SIGNAL(incomingMsg(qint64)) , SIGNAL(incomingMsg(qint64)) );
connect( p->tg_thread, SIGNAL(incomingNewMsg(qint64)) , SLOT(_incomingNewMsg(qint64)) );
connect( p->tg_thread, SIGNAL(userIsTyping(int,int)) , SIGNAL(userIsTyping(int,int)) );
connect( p->tg_thread, SIGNAL(userStatusChanged(int,int,QDateTime)), SIGNAL(userStatusChanged(int,int,QDateTime)) );
connect( p->tg_thread, SIGNAL(msgChanged(qint64)) , SIGNAL(msgChanged(qint64)) );
connect( p->tg_thread, SIGNAL(msgSent(qint64,qint64)) , SIGNAL(msgSent(qint64,qint64)) );
connect( p->tg_thread, SIGNAL(userPhotoChanged(int)) , SIGNAL(userPhotoChanged(int)) );
connect( p->tg_thread, SIGNAL(chatPhotoChanged(int)) , SIGNAL(chatPhotoChanged(int)) );
connect( p->tg_thread, SIGNAL(fileUploaded(int,QString)) , SIGNAL(fileUploaded(int,QString)) );
connect( p->tg_thread, SIGNAL(fileUploading(int,QString,qreal)) , SIGNAL(fileUploading(int,QString,qreal)) );
connect( p->tg_thread, SIGNAL(fileUserUploaded(int)) , SIGNAL(fileUserUploaded(int)) );
connect( p->tg_thread, SIGNAL(fileUserUploading(int,qreal)) , SIGNAL(fileUserUploading(int,qreal)) );
connect( p->tg_thread, SIGNAL(msgFileDownloaded(qint64)) , SIGNAL(msgFileDownloaded(qint64)) );
connect( p->tg_thread, SIGNAL(msgFileDownloading(qint64,qreal)) , SIGNAL(msgFileDownloading(qint64,qreal)) );
connect( p->tg_thread, SIGNAL(messageDeleted(qint64)) , SIGNAL(messageDeleted(qint64)) );
connect( p->tg_thread, SIGNAL(messageRestored(qint64)) , SIGNAL(messageRestored(qint64)) );
connect( p->tg_thread, SIGNAL(registeringStarted()) , SLOT(registeringStarted()) );
connect( p->tg_thread, SIGNAL(registeringFinished()) , SLOT(registeringFinished()) );
connect( p->tg_thread, SIGNAL(registeringInvalidCode()) , SIGNAL(registeringInvalidCode()) );
connect( p->tg_thread, SIGNAL(myStatusUpdated()) , SIGNAL(myStatusUpdated()) );
connect( p->tg_thread, SIGNAL(waitAndGet(int)) , SLOT(_waitAndGet(int)) );
connect( p->tg_thread, SIGNAL(tgStarted()) , SLOT(_startedChanged()) );
p->tg_thread->start();
}
void StackedChatWidget::addSession(ChatSessionImpl *session)
{
if(!m_sessionList->count()) {
m_sessionList->setVisible(true);
m_chatWidget->setVisible(true);
m_stack->addWidget(m_sessionList);
m_stack->addWidget(m_chatWidget);
}
m_sessionList->addSession(session);
connect(session,SIGNAL(activated(bool)),SLOT(onSessionActivated(bool)));
connect(session,SIGNAL(unreadChanged(qutim_sdk_0_3::MessageList)),SLOT(onUnreadChanged()));
}
void NotificationsModel::_readSuccess()
{
for (auto it = _notifs.constBegin(); it != _notifs.constEnd(); ++it)
if (!(*it)->isRead())
{
(*it)->_read = true;
emit (*it)->readChanged();
}
else
break;
emit unreadChanged();
}
qint64 ChatChannel::doAppendMessage(qutim_sdk_0_3::Message &message)
{
if (message.isIncoming())
emit messageReceived(&message);
else
emit messageSent(&message);
if (message.property("spam", false) || message.property("hide", false))
return message.id();
bool service = message.property("service", false);
if ((!isActive() && !service) && message.isIncoming()) {
m_unread.append(message);
emit unreadChanged(m_unread);
emit unreadCountChanged(m_unread.count());
}
if (!message.property("silent", false) && !isActive())
Notification::send(message);
emit messageAppended(message);
return message.id();
}
void SimpleTray::onSessionCreated(qutim_sdk_0_3::ChatSession *session)
{
connect(session, SIGNAL(unreadChanged(qutim_sdk_0_3::MessageList)),
this, SLOT(onUnreadChanged(qutim_sdk_0_3::MessageList)));
connect(session, SIGNAL(destroyed()), this, SLOT(onSessionDestroyed()));
}
void ChatSessionImpl::doAppendMessage(Message &message)
{
Q_D(ChatSessionImpl);
if(d_func()->fetchingHistory == ChatSessionImplPrivate::Fetching) {
d_func()->awaitingMessages.append(message);
return;
}
if (!message.chatUnit()) {
qWarning() << "Message" << message.text() << "must have a chatUnit";
message.setChatUnit(getUnit());
}
if (message.isIncoming())
emit messageReceived(&message);
else
emit messageSent(&message);
if (message.property("spam", false) || message.property("hide", false))
return;
if ((!isActive() && !message.property("service", false))
&& message.isIncoming()
&& !message.property("history", false)) {
d->unread.append(message);
emit unreadChanged(d->unread);
}
//if (!message.isIncoming())
// setChatState(ChatUnit::ChatStateActive);
bool service = message.property("service").isValid();
const Conference *conf = qobject_cast<const Conference *>(message.chatUnit());
if (!service && !conf
&& message.chatUnit() != d->current_unit.data()
&& message.isIncoming()
&& !message.property("history", false))
{
d->last_active_unit = const_cast<ChatUnit*>(message.chatUnit());
}
if (!message.property("service", false)
&& (!conf || message.property("mention", false))
&& message.isIncoming()
&& !message.property("history", false)) {
ChatLayer::instance()->alert(300);
if (conf) {
ServicePointer<AbstractChatForm> form("ChatForm");
if (form) {
if (QWidget *widget = form->chatWidget(this)) {
QApplication::alert(widget, 300);
}
}
}
}
if (!message.property("silent", false))
Notification::send(message);
if(!message.property("fake",false)) {
if (d->focus == ChatSessionImplPrivate::FirstOutOfFocus)
message.setProperty("firstFocus", true);
if (d->focus & ChatSessionImplPrivate::OutOfFocus)
message.setProperty("focus", true);
d->focus &= ChatSessionImplPrivate::OutOfFocus;
d->getController()->appendMessage(message);
if (!message.property("service", false) && !message.property("topic", false)) {
if (d->lastMessages.count() < LastMessagesCount) {
d->lastMessages << message;
} else {
d->lastMessages[d->lastMessagesIndex] = message;
d->lastMessagesIndex = (d->lastMessagesIndex + 1) % d->lastMessages.count();
}
}
}
}
void VLongPollClient::onDataReceived()
{
QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
reply->deleteLater();
QByteArray rawData = reply->readAll();
debug() << Q_FUNC_INFO << rawData;
QVariantMap data = Json::parse(rawData).toMap();
if (data.contains("failed")) {
requestServer();
return;
} else if (data.isEmpty() || reply->error() != QNetworkReply::NoError) {
if (m_connection->connectionState() == Connected)
QTimer::singleShot(1000, this, SLOT(requestServer()));
return;
}
QVariantList updates = data.value("updates").toList();
for (int i = 0; i < updates.size(); i++) {
QVariantList update = updates.at(i).toList();
int updateType = update.value(0, -1).toInt();
switch (updateType) {
case MessageAdded: {
MessageFlags flags(update.value(2).toInt());
if (flags & MessageOutbox)
continue;
QString id = update.value(3).toString();
QString messageId = update.value(1).toString();
QString subject = update.value(5).toString();
QString text = update.value(6).toString();
VContact *contact = m_connection->account()->getContact(id, true);
qutim_sdk_0_3::Message message;
message.setChatUnit(contact);
message.setProperty("subject", subject);
message.setText(unescape(text));
message.setProperty("mid",messageId);
//message.setProperty("html",text);
message.setTime(QDateTime::currentDateTime());
message.setIncoming(true);
ChatSession *s = ChatLayer::get(contact, true);
s->appendMessage(message);
connect(s,SIGNAL(unreadChanged(qutim_sdk_0_3::MessageList)),SLOT(onUnreadChanged(qutim_sdk_0_3::MessageList)));
m_unread_mess[s].append(message);
contact->setChatState(ChatStateActive);
break;
}
case UserOnline:
case UserOffline: {
// WTF? Why VKontakte sends minus as first char of id?
QString id = update.value(1).toString().mid(1);
VContact *contact = m_connection->account()->getContact(id, false);
if (contact)
contact->setOnline(updateType == UserOnline);
break;
}
}
}
if (m_connection->connectionState() == Connected)
requestData(data.value("ts").toString());
}