Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-10-01 02:35:48 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

Patch (modified) from Phenom to allow auto-subscribe to chat lobbies

Browse Source 
git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@6466 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
csoler 2013-06-29 16:15:33 +00:00
parent 9f88917ac1
commit 7414659bd9
12 changed files with 243 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
libretroshare/src/retroshare/rsflags.h
View File

@ -57,6 +57,7 @@ template<int n> class t_RsFlags32
#define FLAGS_TAG_FILE_STORAGE 0x184738
#define FLAGS_TAG_FILE_SEARCH 0xf29ba5
#define FLAGS_TAG_SERVICE_PERM 0x380912
#define FLAGS_TAG_SERVICE_CHAT 0x839042
// Flags for requesting transfers, ask for turtle, cache, speed, etc.
//
@ -74,3 +75,7 @@ typedef t_RsFlags32<FLAGS_TAG_FILE_SEARCH > FileSearchFlags ;
//
typedef t_RsFlags32<FLAGS_TAG_SERVICE_PERM > ServicePermissionFlags ;
// Flags for chat lobbies
//
typedef t_RsFlags32<FLAGS_TAG_SERVICE_CHAT > ChatLobbyFlags ;

4
libretroshare/src/retroshare/rsmsgs.h
View File

@ -77,6 +77,8 @@
#define RS_CHAT_LOBBY_PRIVACY_LEVEL_PUBLIC 1 /* lobby is visible by friends. Friends can connect.*/
#define RS_CHAT_LOBBY_PRIVACY_LEVEL_PRIVATE 2 /* lobby invisible by friends. Peers on invitation only .*/
const ChatLobbyFlags RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE( 0x00000001 ) ;
typedef uint64_t ChatLobbyId ;
typedef uint64_t ChatLobbyMsgId ;
typedef std::string ChatLobbyNickName ;
@ -321,6 +323,8 @@ virtual bool setNickNameForChatLobby(const ChatLobbyId& lobby_id,const std::stri
virtual bool getNickNameForChatLobby(const ChatLobbyId& lobby_id,std::string& nick) = 0 ;
virtual bool setDefaultNickNameForChatLobby(const std::string& nick) = 0;
virtual bool getDefaultNickNameForChatLobby(std::string& nick) = 0 ;
virtual void setLobbyAutoSubscribe(const ChatLobbyId& lobby_id, const bool autoSubscribe) = 0 ;
virtual bool getLobbyAutoSubscribe(const ChatLobbyId& lobby_id) = 0 ;
virtual ChatLobbyId createChatLobby(const std::string& lobby_name,const std::string& lobby_topic,const std::list<std::string>& invited_friends,uint32_t lobby_privacy_type) = 0 ;
/****************************************/

11
libretroshare/src/rsserver/p3msgs.cc
View File

@ -332,6 +332,17 @@ ChatLobbyId p3Msgs::createChatLobby(const std::string& lobby_name,const std::str
return mChatSrv->createChatLobby(lobby_name,lobby_topic,invited_friends,privacy_type) ;
}
void p3Msgs::setLobbyAutoSubscribe(const ChatLobbyId& lobby_id, const bool autoSubscribe)
{
mChatSrv->setLobbyAutoSubscribe(lobby_id, autoSubscribe);
}
bool p3Msgs::getLobbyAutoSubscribe(const ChatLobbyId& lobby_id)
{
return mChatSrv->getLobbyAutoSubscribe(lobby_id);
}
bool p3Msgs::acceptLobbyInvite(const ChatLobbyId& id)
{
return mChatSrv->acceptLobbyInvite(id) ;

2
libretroshare/src/rsserver/p3msgs.h
View File

@ -185,6 +185,8 @@ class p3Msgs: public RsMsgs
virtual bool getNickNameForChatLobby(const ChatLobbyId&,std::string& nick) ;
virtual bool setDefaultNickNameForChatLobby(const std::string&) ;
virtual bool getDefaultNickNameForChatLobby(std::string& nick) ;
virtual void setLobbyAutoSubscribe(const ChatLobbyId& lobby_id, const bool autoSubscribe);
virtual bool getLobbyAutoSubscribe(const ChatLobbyId& lobby_id);
virtual ChatLobbyId createChatLobby(const std::string& lobby_name,const std::string& lobby_topic,const std::list<std::string>& invited_friends,uint32_t privacy_type) ;
virtual bool createDistantChatInvite(const std::string& pgp_id,time_t time_of_validity,std::string& encrypted_string) ;

77
libretroshare/src/serialiser/rsmsgitems.cc
View File

@ -211,8 +211,18 @@ std::ostream& RsPrivateChatDistantInviteConfigItem::print(std::ostream &out, uin
printRsItemEnd(out, "RsPrivateChatDistantInviteConfigItem", indent);
return out;
}
std::ostream& RsChatLobbyConfigItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsChatLobbyConfigItem", indent);
uint16_t int_Indent = indent + 2;
printIndent(out, int_Indent);
out << "lobby_Id: " << lobby_Id << std::endl;
out << "flags : " << flags << std::endl;
printRsItemEnd(out, "RsChatLobbyConfigItem", indent);
return out;
}
std::ostream& RsChatStatusItem::print(std::ostream &out, uint16_t indent)
{
printRsItemBase(out, "RsChatStatusItem", indent);
@ -281,6 +291,7 @@ RsItem *RsChatSerialiser::deserialise(void *data, uint32_t *pktsize)
case RS_PKT_SUBTYPE_CHAT_LOBBY_LIST: return new RsChatLobbyListItem(data,*pktsize) ;
case RS_PKT_SUBTYPE_CHAT_LOBBY_LIST_deprecated: return new RsChatLobbyListItem_deprecated(data,*pktsize) ;
case RS_PKT_SUBTYPE_CHAT_LOBBY_LIST_deprecated2:return new RsChatLobbyListItem_deprecated2(data,*pktsize) ;
case RS_PKT_SUBTYPE_CHAT_LOBBY_CONFIG: return new RsChatLobbyConfigItem(data,*pktsize) ;
default:
std::cerr << "Unknown packet type in chat!" << std::endl ;
return NULL ;
@ -441,6 +452,16 @@ uint32_t RsChatAvatarItem::serial_size()
return s;
}
uint32_t RsChatLobbyConfigItem::serial_size()
{
uint32_t s = 8; /* header */
s += 8;/* lobby_Id */
s += 4;/* flags */
return s;
}
/*************************************************************************/
RsChatAvatarItem::~RsChatAvatarItem()
{
@ -942,6 +963,43 @@ bool RsChatAvatarItem::serialise(void *data, uint32_t& pktsize)
return ok;
}
bool RsChatLobbyConfigItem::serialise(void *data, uint32_t& pktsize)
{
uint32_t tlvsize = serial_size() ;
uint32_t offset = 0;
if (pktsize < tlvsize)
return false; /* not enough space */
pktsize = tlvsize;
bool ok = true;
ok &= setRsItemHeader(data, tlvsize, PacketId(), tlvsize);
#ifdef CHAT_DEBUG
std::cerr << "RsChatLobbyConfigItem::serialiseItem() Header: " << ok << std::endl;
std::cerr << "RsChatLobbyConfigItem::serialiseItem() Size: " << tlvsize << std::endl;
#endif
/* skip the header */
offset += 8;
/* add mandatory parts first */
ok &= setRawUInt64(data, tlvsize, &offset, lobby_Id);
ok &= setRawUInt32(data, tlvsize, &offset, flags );
if (offset != tlvsize)
{
ok = false;
#ifdef CHAT_DEBUG
std::cerr << "RsChatLobbyConfigItem::serialise() Size Error! " << std::endl;
#endif
}
return ok;
}
RsChatMsgItem::RsChatMsgItem(void *data,uint32_t /*size*/,uint8_t subtype)
: RsChatItem(subtype)
{
@ -1234,6 +1292,25 @@ RsPrivateChatDistantInviteConfigItem::RsPrivateChatDistantInviteConfigItem(void
if (!ok)
std::cerr << "Unknown error while deserializing." << std::endl ;
}
RsChatLobbyConfigItem::RsChatLobbyConfigItem(void *data,uint32_t /*size*/)
: RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_CONFIG)
{
uint32_t offset = 8; // skip the header
uint32_t rssize = getRsItemSize(data);
bool ok = true ;
/* get mandatory parts first */
ok &= getRawUInt64(data, rssize, &offset, &lobby_Id);
ok &= getRawUInt32(data, rssize, &offset, &flags);
#ifdef CHAT_DEBUG
std::cerr << "Building new chat msg config item." << std::endl ;
#endif
if (offset != rssize)
std::cerr << "Size error while deserializing." << std::endl ;
if (!ok)
std::cerr << "Unknown error while deserializing." << std::endl ;
}
/* set data from RsChatMsgItem to RsPrivateChatMsgConfigItem */
void RsPrivateChatMsgConfigItem::set(RsChatMsgItem *ci, const std::string &/*peerId*/, uint32_t confFlags)

17
libretroshare/src/serialiser/rsmsgitems.h
View File

@ -66,6 +66,7 @@ const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_EVENT = 0x10 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_LIST_deprecated2 = 0x11 ; // to be removed (deprecated since 02 Dec. 2012)
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_LIST = 0x12 ;
const uint8_t RS_PKT_SUBTYPE_DISTANT_INVITE_CONFIG = 0x13 ;
const uint8_t RS_PKT_SUBTYPE_CHAT_LOBBY_CONFIG = 0x15 ;
// for defining tags themselves and msg tags
const uint8_t RS_PKT_SUBTYPE_MSG_TAG_TYPE = 0x03;
@ -337,7 +338,23 @@ class RsPrivateChatDistantInviteConfigItem: public RsChatItem
uint32_t time_of_validity ;
uint32_t last_hit_time ;
};
class RsChatLobbyConfigItem: public RsChatItem
{
public:
RsChatLobbyConfigItem() :RsChatItem(RS_PKT_SUBTYPE_CHAT_LOBBY_CONFIG) { lobby_Id = 0; }
RsChatLobbyConfigItem(void *data,uint32_t size) ; // deserialization
virtual ~RsChatLobbyConfigItem() {}
virtual void clear() { lobby_Id = 0; }
virtual std::ostream& print(std::ostream &out, uint16_t indent = 0);
virtual bool serialise(void *data,uint32_t& size) ; // Isn't it better that items can serialize themselves ?
virtual uint32_t serial_size() ; // deserialise is handled using a constructor
uint64_t lobby_Id;
uint32_t flags ;
};
// This class contains activity info for the sending peer: active, idle, typing, etc.
//

58
libretroshare/src/services/p3chatservice.cc
View File

@ -399,6 +399,11 @@ void p3ChatService::locked_printDebugInfo() const
for(std::set<std::string>::const_iterator it2(it->second.participating_friends.begin());it2!=it->second.participating_friends.end();++it2)
std::cerr << " With friend: " << *it2 << std::endl;
}
std::cerr << "Chat lobby flags: " << std::endl;
for( std::map<ChatLobbyId,ChatLobbyFlags>::const_iterator it(_known_lobbies_flags.begin()) ;it!=_known_lobbies_flags.end();++it)
std::cerr << " \"" << std::hex << it->first << "\" flags = " << it->second << std::dec << std::endl;
}
bool p3ChatService::isLobbyId(const std::string& id,ChatLobbyId& lobby_id)
@ -840,6 +845,8 @@ void p3ChatService::handleRecvChatLobbyList(RsChatLobbyListItem_deprecated2 *ite
}
void p3ChatService::handleRecvChatLobbyList(RsChatLobbyListItem *item)
{
std::list<ChatLobbyId> chatLobbyToSubscribe;
{
time_t now = time(NULL) ;
@ -851,7 +858,7 @@ void p3ChatService::handleRecvChatLobbyList(RsChatLobbyListItem *item)
rec.lobby_id = item->lobby_ids[i] ;
rec.lobby_name = item->lobby_names[i] ;
rec.lobby_topic = item->lobby_topics[i] ;
rec.lobby_topic = item->lobby_topics[i] ;
rec.participating_friends.insert(item->PeerId()) ;
if(_should_reset_lobby_counts)
@ -861,9 +868,21 @@ void p3ChatService::handleRecvChatLobbyList(RsChatLobbyListItem *item)
rec.last_report_time = now ;
rec.lobby_privacy_level = item->lobby_privacy_levels[i] ;
std::map<ChatLobbyId,ChatLobbyFlags>::const_iterator it(_known_lobbies_flags.find(item->lobby_ids[i])) ;
if(it != _known_lobbies_flags.end() && (it->second & RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE))
{
ChatLobbyId clid = item->lobby_ids[i];
chatLobbyToSubscribe.push_back(clid);
}
}
}
std::list<ChatLobbyId>::iterator it;
for (it = chatLobbyToSubscribe.begin(); it != chatLobbyToSubscribe.end(); it++)
joinVisibleChatLobby(*it);
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_CHAT_LOBBY_LIST, NOTIFY_TYPE_ADD) ;
_should_reset_lobby_counts = false ;
}
@ -1782,6 +1801,11 @@ bool p3ChatService::loadList(std::list<RsItem*>& load)
_default_nick_name = kit->value ;
}
RsChatLobbyConfigItem *cas = NULL ;
if(NULL != (cas = dynamic_cast<RsChatLobbyConfigItem*>(*it)))
_known_lobbies_flags[cas->lobby_Id] = ChatLobbyFlags(cas->flags) ;
// delete unknown items
delete *it;
}
@ -1855,6 +1879,17 @@ bool p3ChatService::saveList(bool& cleanup, std::list<RsItem*>& list)
list.push_back(vitem) ;
/* Save Lobby Auto Subscribe */
for(std::map<ChatLobbyId,ChatLobbyFlags>::const_iterator it=_known_lobbies_flags.begin();it!=_known_lobbies_flags.end();++it)
{
RsChatLobbyConfigItem *cas = new RsChatLobbyConfigItem ;
cas->lobby_Id=it->first;
cas->flags=it->second.toUInt32();
list.push_back(cas) ;
}
return true;
}
@ -2747,6 +2782,25 @@ bool p3ChatService::setNickNameForChatLobby(const ChatLobbyId& lobby_id,const st
return true ;
}
void p3ChatService::setLobbyAutoSubscribe(const ChatLobbyId& lobby_id, const bool autoSubscribe)
{
if(autoSubscribe)
_known_lobbies_flags[lobby_id] |= RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE ;
else
_known_lobbies_flags[lobby_id] &= ~RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE ;
rsicontrol->getNotify().notifyListChange(NOTIFY_LIST_CHAT_LOBBY_LIST, NOTIFY_TYPE_ADD) ;
IndicateConfigChanged();
}
bool p3ChatService::getLobbyAutoSubscribe(const ChatLobbyId& lobby_id)
{
if(_known_lobbies_flags.find(lobby_id) == _known_lobbies_flags.end()) // keep safe about default values form std::map
return false;
return _known_lobbies_flags[lobby_id] & RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE ;
}
void p3ChatService::cleanLobbyCaches()
{
#ifdef CHAT_DEBUG
@ -3127,7 +3181,7 @@ void p3ChatService::sendTurtleData(RsChatItem *item)
gitem->data_bytes = malloc(gitem->data_size) ;
memcpy(gitem->data_bytes ,&IV,8) ;
memcpy(gitem->data_bytes+8,encrypted_data,encrypted_size) ;
memcpy(& (((uint8_t*)gitem->data_bytes)[8]),encrypted_data,encrypted_size) ;
delete[] encrypted_data ;
delete item ;

8
libretroshare/src/services/p3chatservice.h
View File

@ -169,6 +169,8 @@ class p3ChatService: public p3Service, public p3Config, public pqiMonitor, publi
bool getNickNameForChatLobby(const ChatLobbyId& lobby_id,std::string& nick) ;
bool setDefaultNickNameForChatLobby(const std::string& nick) ;
bool getDefaultNickNameForChatLobby(std::string& nick) ;
void setLobbyAutoSubscribe(const ChatLobbyId& lobby_id, const bool autoSubscribe);
bool getLobbyAutoSubscribe(const ChatLobbyId& lobby_id);
void sendLobbyStatusString(const ChatLobbyId& id,const std::string& status_string) ;
ChatLobbyId createChatLobby(const std::string& lobby_name,const std::string& lobby_topic, const std::list<std::string>& invited_friends,uint32_t privacy_type) ;
@ -286,12 +288,18 @@ class p3ChatService: public p3Service, public p3Config, public pqiMonitor, publi
time_t last_connexion_challenge_time ;
time_t last_keep_alive_packet_time ;
std::set<std::string> previously_known_peers ;
uint32_t flags ;
};
std::map<ChatLobbyId,ChatLobbyEntry> _chat_lobbys ;
std::map<ChatLobbyId,ChatLobbyInvite> _lobby_invites_queue ;
std::map<ChatLobbyId,VisibleChatLobbyRecord> _visible_lobbies ;
std::map<std::string,ChatLobbyId> _lobby_ids ;
std::map<ChatLobbyId,ChatLobbyFlags> _known_lobbies_flags ; // flags for all lobbies, including the ones that are not known. So we can't
// store them in _chat_lobbies (subscribed lobbies) nor _visible_lobbies.
// Known flags:
// RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE
std::string _default_nick_name ;
float _time_shift_average ;
time_t last_lobby_challenge_time ; // prevents bruteforce attack

57
retroshare-gui/src/gui/ChatLobbyWidget.cpp
View File

@ -25,6 +25,8 @@
#define ROLE_ID Qt::UserRole + 1
#define ROLE_SUBSCRIBED Qt::UserRole + 2
#define ROLE_PRIVACYLEVEL Qt::UserRole + 3
#define ROLE_AUTOSUBSCRIBE Qt::UserRole + 4
#define TYPE_FOLDER 0
#define TYPE_LOBBY 1
@ -38,6 +40,7 @@
#define IMAGE_PEER_LEAVING ":images/user/remove_user24.png"
#define IMAGE_TYPING ":images/typing.png"
#define IMAGE_MESSAGE ":images/chat.png"
#define IMAGE_AUTOSUBSCRIBE ":images/accepted16.png"
ChatLobbyWidget::ChatLobbyWidget(QWidget *parent, Qt::WFlags flags)
: RsAutoUpdatePage(5000, parent, flags)
@ -138,6 +141,11 @@ void ChatLobbyWidget::lobbyTreeWidgetCustomPopupMenu(QPoint)
} else {
contextMnu.addAction(QIcon(IMAGE_SUBSCRIBE), tr("Subscribe"), this, SLOT(subscribeItem()));
}
if (item->data(COLUMN_DATA, ROLE_AUTOSUBSCRIBE).toBool()) {
contextMnu.addAction(QIcon(IMAGE_AUTOSUBSCRIBE), tr("Remove Auto Subscribe"), this, SLOT(autoSubscribeItem()));
} else {
contextMnu.addAction(QIcon(IMAGE_UNSUBSCRIBE), tr("Add Auto Subscribe"), this, SLOT(autoSubscribeItem()));
}
}
if (contextMnu.children().count() == 0) {
@ -152,7 +160,7 @@ void ChatLobbyWidget::lobbyChanged()
updateDisplay();
}
static void updateItem(QTreeWidgetItem *item, ChatLobbyId id, const std::string &name, const std::string &topic, int count, bool subscribed)
static void updateItem(QTreeWidgetItem *item, ChatLobbyId id, const std::string &name, const std::string &topic, int count, bool subscribed, bool autoSubscribe)
{
item->setText(COLUMN_NAME, QString::fromUtf8(name.c_str()));
item->setData(COLUMN_NAME, ROLE_SORT, QString::fromUtf8(name.c_str()));
@ -172,6 +180,7 @@ static void updateItem(QTreeWidgetItem *item, ChatLobbyId id, const std::string
item->setData(COLUMN_DATA, ROLE_ID, (qulonglong)id);
item->setData(COLUMN_DATA, ROLE_SUBSCRIBED, subscribed);
item->setData(COLUMN_DATA, ROLE_AUTOSUBSCRIBE, autoSubscribe);
QColor color = QApplication::palette().color(QPalette::Active, QPalette::Text);
if (!subscribed) {
@ -311,7 +320,23 @@ void ChatLobbyWidget::updateDisplay()
subscribed = true;
}
updateItem(item, lobby.lobby_id, lobby.lobby_name,lobby.lobby_topic, lobby.total_number_of_peers, subscribed);
bool autoSubscribe = rsMsgs->getLobbyAutoSubscribe(lobby.lobby_id);
if (autoSubscribe && subscribed)
{
if(_lobby_infos.find(lobby.lobby_id) == _lobby_infos.end())
{
if (item == lobbyTreeWidget->currentItem())
{
ChatDialog::chatFriend(vpid) ;
}else{
ChatDialog::chatFriend(vpid,false) ;
}
}
}
updateItem(item, lobby.lobby_id, lobby.lobby_name,lobby.lobby_topic, lobby.total_number_of_peers, subscribed, autoSubscribe);
}
// time_t now = time(NULL) ;
@ -358,7 +383,9 @@ void ChatLobbyWidget::updateDisplay()
// item->setIcon(COLUMN_NAME, QIcon(IMAGE_PRIVATE));
// }
updateItem(item, lobby.lobby_id, lobby.lobby_name,lobby.lobby_topic, lobby.nick_names.size(), true);
bool autoSubscribe = rsMsgs->getLobbyAutoSubscribe(lobby.lobby_id);
updateItem(item, lobby.lobby_id, lobby.lobby_name,lobby.lobby_topic, lobby.nick_names.size(), true, autoSubscribe);
}
}
@ -399,11 +426,23 @@ static void subscribeLobby(QTreeWidgetItem *item)
if (rsMsgs->joinVisibleChatLobby(id)) {
std::string vpeer_id;
if (rsMsgs->getVirtualPeerId(id, vpeer_id)) {
ChatDialog::chatFriend(vpeer_id) ;
ChatDialog::chatFriend(vpeer_id,true) ;
}
}
}
void ChatLobbyWidget::autoSubscribeLobby(QTreeWidgetItem *item)
{
if (item == NULL && item->type() != TYPE_LOBBY) {
return;
}
ChatLobbyId id = item->data(COLUMN_DATA, ROLE_ID).toULongLong();
bool isAutoSubscribe = rsMsgs->getLobbyAutoSubscribe(id);
rsMsgs->setLobbyAutoSubscribe(id, !isAutoSubscribe);
if (!isAutoSubscribe) subscribeLobby(item);
}
void ChatLobbyWidget::showBlankPage(ChatLobbyId id)
{
// show the default blank page.
@ -439,6 +478,11 @@ void ChatLobbyWidget::subscribeItem()
subscribeLobby(lobbyTreeWidget->currentItem());
}
void ChatLobbyWidget::autoSubscribeItem()
{
autoSubscribeLobby(lobbyTreeWidget->currentItem());
}
QTreeWidgetItem *ChatLobbyWidget::getTreeWidgetItem(ChatLobbyId id)
{
for(int p=0;p<2;++p)
@ -539,6 +583,9 @@ void ChatLobbyWidget::unsubscribeChatLobby(ChatLobbyId id)
ChatDialog::closeChat(vpeer_id);
rsMsgs->unsubscribeChatLobby(id);
bool isAutoSubscribe = rsMsgs->getLobbyAutoSubscribe(id);
if (isAutoSubscribe) rsMsgs->setLobbyAutoSubscribe(id, !isAutoSubscribe);
}
void ChatLobbyWidget::updateCurrentLobby()
@ -605,7 +652,7 @@ void ChatLobbyWidget::readChatLobbyInvites()
std::string vpid;
if(rsMsgs->getVirtualPeerId((*it).lobby_id,vpid )) {
ChatDialog::chatFriend(vpid);
ChatDialog::chatFriend(vpid,true);
} else {
std::cerr << "No lobby known with id 0x" << std::hex << (*it).lobby_id << std::dec << std::endl;
}

3
retroshare-gui/src/gui/ChatLobbyWidget.h
View File

@ -51,8 +51,11 @@ protected slots:
void updateMessageChanged(ChatLobbyId);
void updatePeerEntering(ChatLobbyId);
void updatePeerLeaving(ChatLobbyId);
void autoSubscribeItem();
private:
void autoSubscribeLobby(QTreeWidgetItem *item);
RSTreeWidgetItemCompareRole *compareRole;
QTreeWidgetItem *privateLobbyItem;
QTreeWidgetItem *publicLobbyItem;

15
retroshare-gui/src/gui/chat/ChatDialog.cpp
View File

@ -95,7 +95,7 @@ void ChatDialog::init(const std::string &peerId, const QString &title)
ChatLobbyId lobby_id = 0;
if (rsMsgs->isLobbyId(peerId, lobby_id)) {
chatflags = RS_CHAT_OPEN | RS_CHAT_FOCUS; // use own flags
// chatflags = RS_CHAT_OPEN | RS_CHAT_FOCUS; // use own flags
}
uint32_t distant_peer_status ;
@ -211,7 +211,7 @@ void ChatDialog::init(const std::string &peerId, const QString &title)
}
}
/*static*/ void ChatDialog::chatFriend(const std::string &peerId)
/*static*/ void ChatDialog::chatFriend(const std::string &peerId, const bool forceFocus)
{
if (peerId.empty()){
return;
@ -222,14 +222,13 @@ void ChatDialog::init(const std::string &peerId, const QString &title)
if(rsMsgs->getDistantChatStatus(peerId,distant_peer_status,distant_chat_pgp_id))
{
getChat(peerId,RS_CHAT_OPEN | RS_CHAT_FOCUS); // use own flags
getChat(peerId, forceFocus ? RS_CHAT_OPEN | RS_CHAT_FOCUS : RS_CHAT_OPEN ); // use own flags
return ;
}
ChatLobbyId lid;
if (rsMsgs->isLobbyId(peerId, lid)) {
getChat(peerId, RS_CHAT_OPEN | RS_CHAT_FOCUS);
return;
getChat(peerId, (forceFocus ? (RS_CHAT_OPEN | RS_CHAT_FOCUS) : RS_CHAT_OPEN));
}
RsPeerDetails detail;
@ -245,7 +244,7 @@ void ChatDialog::init(const std::string &peerId, const QString &title)
if (sslIds.size() == 1) {
// chat with the one ssl id (online or offline)
getChat(sslIds.front(), RS_CHAT_OPEN | RS_CHAT_FOCUS);
getChat(sslIds.front(), forceFocus ? RS_CHAT_OPEN | RS_CHAT_FOCUS : RS_CHAT_OPEN);
return;
}
@ -258,7 +257,7 @@ void ChatDialog::init(const std::string &peerId, const QString &title)
if (onlineIds.size() == 1) {
// chat with the online ssl id
getChat(onlineIds.front(), RS_CHAT_OPEN | RS_CHAT_FOCUS);
getChat(onlineIds.front(), forceFocus ? RS_CHAT_OPEN | RS_CHAT_FOCUS : RS_CHAT_OPEN);
return;
}
@ -267,7 +266,7 @@ void ChatDialog::init(const std::string &peerId, const QString &title)
mb.setWindowIcon(QIcon(":/images/rstray3.png"));
mb.exec();
} else {
getChat(peerId, RS_CHAT_OPEN | RS_CHAT_FOCUS);
getChat(peerId, forceFocus ? RS_CHAT_OPEN | RS_CHAT_FOCUS : RS_CHAT_OPEN);
}
}

2
retroshare-gui/src/gui/chat/ChatDialog.h
View File

@ -37,7 +37,7 @@ public:
static ChatDialog *getExistingChat(const std::string &peerId);
static ChatDialog *getChat(const std::string &peerId, uint chatflags);
static void cleanupChat();
static void chatFriend(const std::string &peerId);
static void chatFriend(const std::string &peerId, bool forceFocus = true);
static void closeChat(const std::string &peerId);
static void chatChanged(int list, int type);