2011-10-20 18:48:50 -04:00
/****************************************************************
* RetroShare is distributed under the following license :
*
* Copyright ( C ) 2011 RetroShare Team
*
* This program is free software ; you can redistribute it and / or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation ; either version 2
* of the License , or ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with this program ; if not , write to the Free Software
* Foundation , Inc . , 51 Franklin Street , Fifth Floor ,
* Boston , MA 02110 - 1301 , USA .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
# include <algorithm>
# include <QShortcut>
# include <QTimer>
# include <QTreeWidgetItem>
# include <QWidgetAction>
2012-01-17 15:36:36 -05:00
# include <QDateTime>
2011-10-20 18:48:50 -04:00
# include "retroshare/rspeers.h"
# include "GroupDefs.h"
2012-01-17 15:36:36 -05:00
# include "gui/chat/ChatDialog.h"
2013-07-16 18:33:45 -04:00
//#include "gui/chat/CreateLobbyDialog.h"
2011-10-20 18:48:50 -04:00
# include "gui/common/AvatarDefs.h"
2013-07-16 18:33:45 -04:00
2011-10-20 18:48:50 -04:00
# include "gui/connect/ConfCertDialog.h"
2015-05-12 16:30:44 -04:00
# include "gui/connect/PGPKeyDialog.h"
2011-10-20 18:48:50 -04:00
# include "gui/connect/ConnectFriendWizard.h"
# include "gui/groups/CreateGroup.h"
# include "gui/msgs/MessageComposer.h"
# include "gui/notifyqt.h"
# include "gui/RetroShareLink.h"
2012-02-19 10:03:07 -05:00
# include "retroshare-gui/RsAutoUpdatePage.h"
2012-02-13 13:43:15 -05:00
# ifdef UNFINISHED_FD
2011-10-20 18:48:50 -04:00
# include "gui/unfinished/profile/ProfileView.h"
# endif
# include "RSTreeWidgetItem.h"
# include "StatusDefs.h"
# include "util/misc.h"
# include "vmessagebox.h"
2013-10-19 09:25:06 -04:00
# include "util/QtVersion.h"
2015-01-10 08:13:41 -05:00
# include "gui/chat/ChatUserNotify.h"
2013-08-22 03:30:54 -04:00
# include "gui/connect/ConnectProgressDialog.h"
2011-10-20 18:48:50 -04:00
# include "FriendList.h"
# include "ui_FriendList.h"
/* Images for context menu icons */
# define IMAGE_DENYFRIEND ": / images / denied16.png"
2013-07-16 18:33:45 -04:00
# define IMAGE_REMOVEFRIEND ": / images / remove_user24.png"
2012-05-07 10:43:25 -04:00
# define IMAGE_EXPORTFRIEND ": / images / user / friend_suggestion16.png"
2011-10-20 18:48:50 -04:00
# define IMAGE_ADDFRIEND ": / images / user / add_user16.png"
2013-08-28 19:27:46 -04:00
# define IMAGE_FRIENDINFO ": / images / info16.png"
# define IMAGE_CHAT ": / images / chat_24.png"
2011-10-20 18:48:50 -04:00
# define IMAGE_MSG ": / images / mail_new.png"
# define IMAGE_CONNECT ": / images / connect_friend.png"
# define IMAGE_COPYLINK ": / images / copyrslink.png"
# define IMAGE_GROUP16 ": / images / user / group16.png"
# define IMAGE_EDIT ": / images / edit_16.png"
# define IMAGE_REMOVE ": / images / delete.png"
# define IMAGE_EXPAND ": / images / edit_add24.png"
# define IMAGE_COLLAPSE ": / images / edit_remove24.png"
/* Images for Status icons */
# define IMAGE_AVAILABLE ": / images / user / identityavaiblecyan24.png"
# define IMAGE_CONNECT2 ": / images / reload24.png"
# define IMAGE_PASTELINK ": / images / pasterslink.png"
# define IMAGE_GROUP24 ": / images / user / group24.png"
2013-07-04 16:11:36 -04:00
# define COLUMN_COUNT 5
2011-11-11 20:26:26 -05:00
# define COLUMN_NAME 0
2014-12-23 12:07:07 -05:00
# define COLUMN_AVATAR 1
# define COLUMN_STATE 2
# define COLUMN_LAST_CONTACT 3
2013-07-04 16:11:36 -04:00
# define COLUMN_IP 4
2011-10-20 18:48:50 -04:00
# define COLUMN_DATA 0 // column for storing the userdata id
# define COLUMN_AVATAR_WIDTH 42
# define ROLE_SORT Qt::UserRole
# define ROLE_ID Qt::UserRole + 1
# define ROLE_STANDARD Qt::UserRole + 2
2015-06-02 13:32:05 -04:00
// to store the best ssl id for pgp items
// the best id decides which avatar image we want to display at the pgpg item
# define ROLE_BEST_SSL Qt::UserRole + 3
2011-10-20 18:48:50 -04:00
# define TYPE_GPG 0
# define TYPE_SSL 1
# define TYPE_GROUP 2
// states for sorting (equal values are possible)
// used in BuildSortString - state + name
# define PEER_STATE_ONLINE 1
# define PEER_STATE_BUSY 2
# define PEER_STATE_AWAY 3
# define PEER_STATE_AVAILABLE 4
# define PEER_STATE_INACTIVE 5
# define PEER_STATE_OFFLINE 6
# define BuildStateSortString(bEnabled,sName,nState) bEnabled ? (QString ("%1").arg(nState) + " " + sName) : sName
/******
* # define FRIENDS_DEBUG 1
* * * * */
FriendList : : FriendList ( QWidget * parent ) :
RsAutoUpdatePage ( 1500 , parent ) ,
ui ( new Ui : : FriendList ) ,
m_compareRole ( new RSTreeWidgetItemCompareRole ) ,
mBigName ( false ) ,
2011-11-11 20:26:26 -05:00
mShowGroups ( true ) ,
2014-12-09 14:29:53 -05:00
mHideState ( true ) ,
2011-10-20 18:48:50 -04:00
mHideUnconnected ( false ) ,
groupsHasChanged ( false ) ,
openGroups ( NULL ) ,
2011-11-11 20:26:26 -05:00
openPeers ( NULL )
2011-10-20 18:48:50 -04:00
{
ui - > setupUi ( this ) ;
m_compareRole - > setRole ( COLUMN_NAME , ROLE_SORT ) ;
m_compareRole - > setRole ( COLUMN_STATE , ROLE_SORT ) ;
2011-11-11 20:26:26 -05:00
m_compareRole - > setRole ( COLUMN_LAST_CONTACT , ROLE_SORT ) ;
2013-07-04 16:11:36 -04:00
m_compareRole - > setRole ( COLUMN_IP , ROLE_SORT ) ;
2011-10-20 18:48:50 -04:00
m_compareRole - > setRole ( COLUMN_AVATAR , ROLE_STANDARD ) ;
2015-05-09 17:43:01 -04:00
connect ( ui - > peerTreeWidget , SIGNAL ( customContextMenuRequested ( QPoint ) ) , this , SLOT ( peerTreeWidgetCustomPopupMenu ( ) ) ) ;
2011-10-20 18:48:50 -04:00
connect ( ui - > peerTreeWidget , SIGNAL ( itemDoubleClicked ( QTreeWidgetItem * , int ) ) , this , SLOT ( chatfriend ( QTreeWidgetItem * ) ) ) ;
connect ( NotifyQt : : getInstance ( ) , SIGNAL ( groupsChanged ( int ) ) , this , SLOT ( groupsChanged ( ) ) ) ;
connect ( NotifyQt : : getInstance ( ) , SIGNAL ( friendsChanged ( ) ) , this , SLOT ( insertPeers ( ) ) ) ;
connect ( NotifyQt : : getInstance ( ) , SIGNAL ( peerHasNewAvatar ( const QString & ) ) , this , SLOT ( updateAvatar ( const QString & ) ) ) ;
2011-11-11 20:26:26 -05:00
connect ( ui - > actionHideOfflineFriends , SIGNAL ( triggered ( bool ) ) , this , SLOT ( setHideUnconnected ( bool ) ) ) ;
connect ( ui - > actionShowStatusColumn , SIGNAL ( triggered ( bool ) ) , this , SLOT ( setShowStatusColumn ( bool ) ) ) ;
connect ( ui - > actionShowAvatarColumn , SIGNAL ( triggered ( bool ) ) , this , SLOT ( setShowAvatarColumn ( bool ) ) ) ;
connect ( ui - > actionShowLastContactColumn , SIGNAL ( triggered ( bool ) ) , this , SLOT ( setShowLastContactColumn ( bool ) ) ) ;
2013-07-04 16:11:36 -04:00
connect ( ui - > actionShowIPColumn , SIGNAL ( triggered ( bool ) ) , this , SLOT ( setShowIPColumn ( bool ) ) ) ;
2011-11-11 20:26:26 -05:00
connect ( ui - > actionHideState , SIGNAL ( triggered ( bool ) ) , this , SLOT ( setHideState ( bool ) ) ) ;
connect ( ui - > actionRootIsDecorated , SIGNAL ( triggered ( bool ) ) , this , SLOT ( setRootIsDecorated ( bool ) ) ) ;
connect ( ui - > actionShowGroups , SIGNAL ( triggered ( bool ) ) , this , SLOT ( setShowGroups ( bool ) ) ) ;
connect ( ui - > actionSortByName , SIGNAL ( triggered ( ) ) , this , SLOT ( setSortByName ( ) ) ) ;
connect ( ui - > actionSortByState , SIGNAL ( triggered ( ) ) , this , SLOT ( setSortByState ( ) ) ) ;
connect ( ui - > actionSortByLastContact , SIGNAL ( triggered ( ) ) , this , SLOT ( setSortByLastContact ( ) ) ) ;
2013-07-04 16:11:36 -04:00
connect ( ui - > actionSortByIP , SIGNAL ( triggered ( ) ) , this , SLOT ( setSortByIP ( ) ) ) ;
2011-11-11 20:26:26 -05:00
connect ( ui - > actionSortPeersAscendingOrder , SIGNAL ( triggered ( ) ) , this , SLOT ( sortPeersAscendingOrder ( ) ) ) ;
connect ( ui - > actionSortPeersDescendingOrder , SIGNAL ( triggered ( ) ) , this , SLOT ( sortPeersDescendingOrder ( ) ) ) ;
2013-08-30 08:24:39 -04:00
connect ( ui - > filterLineEdit , SIGNAL ( textChanged ( QString ) ) , this , SLOT ( filterItems ( QString ) ) ) ;
ui - > filterLineEdit - > setPlaceholderText ( tr ( " Search " ) ) ;
ui - > filterLineEdit - > showFilterIcon ( ) ;
2011-11-11 20:26:26 -05:00
initializeHeader ( false ) ;
2011-10-20 18:48:50 -04:00
ui - > peerTreeWidget - > sortItems ( COLUMN_NAME , Qt : : AscendingOrder ) ;
// set header text aligment
2011-11-11 20:26:26 -05:00
QTreeWidgetItem * headerItem = ui - > peerTreeWidget - > headerItem ( ) ;
2011-10-20 18:48:50 -04:00
headerItem - > setTextAlignment ( COLUMN_NAME , Qt : : AlignHCenter | Qt : : AlignVCenter ) ;
headerItem - > setTextAlignment ( COLUMN_STATE , Qt : : AlignLeft | Qt : : AlignVCenter ) ;
headerItem - > setTextAlignment ( COLUMN_AVATAR , Qt : : AlignLeft | Qt : : AlignVCenter ) ;
// workaround for Qt bug, should be solved in next Qt release 4.7.0
// http://bugreports.qt.nokia.com/browse/QTBUG-8270
QShortcut * Shortcut = new QShortcut ( QKeySequence ( Qt : : Key_Delete ) , ui - > peerTreeWidget , 0 , 0 , Qt : : WidgetShortcut ) ;
connect ( Shortcut , SIGNAL ( activated ( ) ) , this , SLOT ( removefriend ( ) ) ) ;
2013-08-30 08:24:39 -04:00
/* Initialize display menu */
createDisplayMenu ( ) ;
2011-10-20 18:48:50 -04:00
}
FriendList : : ~ FriendList ( )
{
delete ui ;
delete ( m_compareRole ) ;
}
2013-08-30 08:24:39 -04:00
void FriendList : : addToolButton ( QToolButton * toolButton )
{
if ( ! toolButton ) {
return ;
}
/* Initialize button */
toolButton - > setAutoRaise ( true ) ;
toolButton - > setIconSize ( ui - > displayButton - > iconSize ( ) ) ;
toolButton - > setFocusPolicy ( ui - > displayButton - > focusPolicy ( ) ) ;
ui - > titleBarFrame - > layout ( ) - > addWidget ( toolButton ) ;
}
2011-11-11 20:26:26 -05:00
void FriendList : : processSettings ( bool bLoad )
{
int peerTreeVersion = 2 ; // version number for the settings to solve problems when modifying the column count
if ( bLoad ) {
// load settings
// state of peer tree
if ( Settings - > value ( " peerTreeVersion " ) . toInt ( ) = = peerTreeVersion ) {
ui - > peerTreeWidget - > header ( ) - > restoreState ( Settings - > value ( " peerTree " ) . toByteArray ( ) ) ;
}
// ui->peerTreeWidget->header()->doItemsLayout(); // is needed because I added a third column
// restoreState would corrupt the internal sectionCount
// state of the columns
setShowStatusColumn ( Settings - > value ( " showStatusColumn " , ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_STATE ) ) . toBool ( ) ) ;
setShowLastContactColumn ( Settings - > value ( " showLastContactColumn " , ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_LAST_CONTACT ) ) . toBool ( ) ) ;
2013-07-04 16:11:36 -04:00
setShowIPColumn ( Settings - > value ( " showIPColumn " , ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_IP ) ) . toBool ( ) ) ;
2011-11-11 20:26:26 -05:00
setShowAvatarColumn ( Settings - > value ( " showAvatarColumn " , ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_AVATAR ) ) . toBool ( ) ) ;
// states
setHideUnconnected ( Settings - > value ( " hideUnconnected " , mHideUnconnected ) . toBool ( ) ) ;
setHideState ( Settings - > value ( " hideState " , mHideState ) . toBool ( ) ) ;
2013-07-16 18:33:45 -04:00
//setRootIsDecorated(Settings->value("rootIsDecorated", ui->peerTreeWidget->rootIsDecorated()).toBool());
setRootIsDecorated ( true ) ;
2011-11-11 20:26:26 -05:00
setShowGroups ( Settings - > value ( " showGroups " , mShowGroups ) . toBool ( ) ) ;
// open groups
int arrayIndex = Settings - > beginReadArray ( " Groups " ) ;
2014-10-21 18:33:02 -04:00
for ( int index = 0 ; index < arrayIndex ; + + index ) {
2011-11-11 20:26:26 -05:00
Settings - > setArrayIndex ( index ) ;
addGroupToExpand ( Settings - > value ( " open " ) . toString ( ) . toStdString ( ) ) ;
}
Settings - > endArray ( ) ;
initializeHeader ( true ) ;
updateHeader ( ) ;
} else {
// save settings
// state of peer tree
Settings - > setValue ( " peerTree " , ui - > peerTreeWidget - > header ( ) - > saveState ( ) ) ;
Settings - > setValue ( " peerTreeVersion " , peerTreeVersion ) ;
// state of the columns
Settings - > setValue ( " showStatusColumn " , ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_STATE ) ) ;
Settings - > setValue ( " showLastContactColumn " , ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_LAST_CONTACT ) ) ;
2013-07-04 16:11:36 -04:00
Settings - > setValue ( " showIPColumn " , ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_IP ) ) ;
2011-11-11 20:26:26 -05:00
Settings - > setValue ( " showAvatarColumn " , ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_AVATAR ) ) ;
// states
Settings - > setValue ( " hideUnconnected " , mHideUnconnected ) ;
Settings - > setValue ( " hideState " , mHideState ) ;
Settings - > setValue ( " rootIsDecorated " , ui - > peerTreeWidget - > rootIsDecorated ( ) ) ;
Settings - > setValue ( " showGroups " , mShowGroups ) ;
// open groups
Settings - > beginWriteArray ( " Groups " ) ;
int arrayIndex = 0 ;
std : : set < std : : string > expandedPeers ;
getExpandedGroups ( expandedPeers ) ;
foreach ( std : : string groupId , expandedPeers ) {
Settings - > setArrayIndex ( arrayIndex + + ) ;
Settings - > setValue ( " open " , QString : : fromStdString ( groupId ) ) ;
}
Settings - > endArray ( ) ;
}
}
2012-11-19 11:01:21 -05:00
void FriendList : : changeEvent ( QEvent * e )
{
QWidget : : changeEvent ( e ) ;
switch ( e - > type ( ) ) {
case QEvent : : StyleChange :
insertPeers ( ) ;
break ;
default :
// remove compiler warnings
break ;
}
}
2014-10-09 11:17:42 -04:00
void FriendList : : initializeHeader ( bool /*afterLoadSettings*/ )
2011-11-11 20:26:26 -05:00
{
// set column size
QHeaderView * header = ui - > peerTreeWidget - > header ( ) ;
2013-10-19 09:25:06 -04:00
QHeaderView_setSectionsMovable ( header , true ) ;
//QHeaderView_setSectionResizeMode(header, COLUMN_NAME, QHeaderView::Stretch);
QHeaderView_setSectionResizeMode ( header , COLUMN_NAME , QHeaderView : : Interactive ) ;
QHeaderView_setSectionResizeMode ( header , COLUMN_STATE , QHeaderView : : Interactive ) ;
QHeaderView_setSectionResizeMode ( header , COLUMN_LAST_CONTACT , QHeaderView : : Interactive ) ;
QHeaderView_setSectionResizeMode ( header , COLUMN_IP , QHeaderView : : Interactive ) ;
QHeaderView_setSectionResizeMode ( header , COLUMN_AVATAR , QHeaderView : : Fixed ) ;
2011-11-11 20:26:26 -05:00
2013-07-06 17:45:18 -04:00
/* if (!afterLoadSettings) {
2011-11-11 20:26:26 -05:00
header - > resizeSection ( COLUMN_NAME , 150 ) ;
header - > resizeSection ( COLUMN_LAST_CONTACT , 120 ) ;
2013-07-06 17:45:18 -04:00
} */
2014-12-23 12:07:07 -05:00
header - > resizeSection ( COLUMN_NAME , 200 ) ;
2011-11-11 20:26:26 -05:00
header - > resizeSection ( COLUMN_AVATAR , COLUMN_AVATAR_WIDTH ) ;
}
2011-10-20 18:48:50 -04:00
/* Utility Fns */
inline std : : string getRsId ( QTreeWidgetItem * item )
{
return item - > data ( COLUMN_DATA , ROLE_ID ) . toString ( ) . toStdString ( ) ;
}
/**
* Creates the context popup menu and its submenus ,
* then shows it at the current cursor position .
*/
2015-05-09 17:43:01 -04:00
void FriendList : : peerTreeWidgetCustomPopupMenu ( )
2011-10-20 18:48:50 -04:00
{
QTreeWidgetItem * c = getCurrentPeer ( ) ;
QMenu contextMnu ( this ) ;
QWidget * widget = new QWidget ( & contextMnu ) ;
widget - > setStyleSheet ( " .QWidget{background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,stop:0 #FEFEFE, stop:1 #E8E8E8); border: 1px solid #CCCCCC;} " ) ;
// create menu header
QHBoxLayout * hbox = new QHBoxLayout ( widget ) ;
hbox - > setMargin ( 0 ) ;
hbox - > setSpacing ( 6 ) ;
QLabel * iconLabel = new QLabel ( widget ) ;
iconLabel - > setPixmap ( QPixmap ( " :/images/user/friends24.png " ) ) ;
iconLabel - > setMaximumSize ( iconLabel - > frameSize ( ) . height ( ) + 24 , 24 ) ;
hbox - > addWidget ( iconLabel ) ;
QLabel * textLabel = new QLabel ( " <strong>RetroShare</strong> " , widget ) ;
hbox - > addWidget ( textLabel ) ;
QSpacerItem * spacerItem = new QSpacerItem ( 40 , 20 , QSizePolicy : : Expanding , QSizePolicy : : Minimum ) ;
hbox - > addItem ( spacerItem ) ;
widget - > setLayout ( hbox ) ;
QWidgetAction * widgetAction = new QWidgetAction ( this ) ;
widgetAction - > setDefaultWidget ( widget ) ;
contextMnu . addAction ( widgetAction ) ;
// create menu entries
2012-01-27 15:53:17 -05:00
if ( c )
{ // if a peer is selected
int type = c - > type ( ) ;
// define header
switch ( type ) {
case TYPE_GROUP :
//this is a GPG key
textLabel - > setText ( " <strong> " + tr ( " Group " ) + " </strong> " ) ;
break ;
case TYPE_GPG :
//this is a GPG key
textLabel - > setText ( " <strong> " + tr ( " Friend " ) + " </strong> " ) ;
break ;
case TYPE_SSL :
//this is a SSL key
2014-12-30 06:11:08 -05:00
textLabel - > setText ( " <strong> " + tr ( " Node " ) + " </strong> " ) ;
2012-01-27 15:53:17 -05:00
break ;
}
2013-07-16 18:33:45 -04:00
// QMenu *lobbyMenu = NULL;
2012-01-27 15:53:17 -05:00
switch ( type ) {
case TYPE_GROUP :
{
bool standard = c - > data ( COLUMN_DATA , ROLE_STANDARD ) . toBool ( ) ;
2015-05-09 17:43:01 -04:00
contextMnu . addAction ( QIcon ( IMAGE_MSG ) , tr ( " Send message to whole group " ) , this , SLOT ( msgfriend ( ) ) ) ;
2012-01-27 15:53:17 -05:00
contextMnu . addSeparator ( ) ;
2012-11-24 09:48:31 -05:00
contextMnu . addAction ( QIcon ( IMAGE_EDIT ) , tr ( " Edit Group " ) , this , SLOT ( editGroup ( ) ) ) ;
2012-01-27 15:53:17 -05:00
2012-11-24 09:48:31 -05:00
QAction * action = contextMnu . addAction ( QIcon ( IMAGE_REMOVE ) , tr ( " Remove Group " ) , this , SLOT ( removeGroup ( ) ) ) ;
2012-01-27 15:53:17 -05:00
action - > setDisabled ( standard ) ;
}
break ;
case TYPE_GPG :
2015-05-09 17:43:01 -04:00
{
2015-05-29 06:07:12 -04:00
contextMnu . addAction ( QIcon ( IMAGE_CHAT ) , tr ( " Chat " ) , this , SLOT ( chatfriendproxy ( ) ) ) ;
contextMnu . addAction ( QIcon ( IMAGE_MSG ) , tr ( " Send message " ) , this , SLOT ( msgfriend ( ) ) ) ;
contextMnu . addSeparator ( ) ;
2015-05-12 16:30:44 -04:00
contextMnu . addAction ( QIcon ( IMAGE_FRIENDINFO ) , tr ( " Details " ) , this , SLOT ( configurefriend ( ) ) ) ;
2015-05-09 17:43:01 -04:00
contextMnu . addAction ( QIcon ( IMAGE_DENYFRIEND ) , tr ( " Deny " ) , this , SLOT ( removefriend ( ) ) ) ;
if ( mShowGroups )
2012-01-27 15:53:17 -05:00
{
2015-05-09 17:43:01 -04:00
QMenu * addToGroupMenu = NULL ;
QMenu * moveToGroupMenu = NULL ;
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
std : : list < RsGroupInfo > groupInfoList ;
rsPeers - > getGroupInfoList ( groupInfoList ) ;
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
GroupDefs : : sortByName ( groupInfoList ) ;
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
RsPgpId gpgId ( getRsId ( c ) ) ;
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
QTreeWidgetItem * parent = c - > parent ( ) ;
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
bool foundGroup = false ;
// add action for all groups, except the own group
for ( std : : list < RsGroupInfo > : : iterator groupIt = groupInfoList . begin ( ) ; groupIt ! = groupInfoList . end ( ) ; + + groupIt ) {
if ( std : : find ( groupIt - > peerIds . begin ( ) , groupIt - > peerIds . end ( ) , gpgId ) = = groupIt - > peerIds . end ( ) ) {
if ( parent ) {
if ( addToGroupMenu = = NULL ) {
addToGroupMenu = new QMenu ( tr ( " Add to group " ) , & contextMnu ) ;
}
QAction * addToGroupAction = new QAction ( GroupDefs : : name ( * groupIt ) , addToGroupMenu ) ;
addToGroupAction - > setData ( QString : : fromStdString ( groupIt - > id ) ) ;
connect ( addToGroupAction , SIGNAL ( triggered ( ) ) , this , SLOT ( addToGroup ( ) ) ) ;
addToGroupMenu - > addAction ( addToGroupAction ) ;
}
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
if ( moveToGroupMenu = = NULL ) {
moveToGroupMenu = new QMenu ( tr ( " Move to group " ) , & contextMnu ) ;
}
QAction * moveToGroupAction = new QAction ( GroupDefs : : name ( * groupIt ) , moveToGroupMenu ) ;
moveToGroupAction - > setData ( QString : : fromStdString ( groupIt - > id ) ) ;
connect ( moveToGroupAction , SIGNAL ( triggered ( ) ) , this , SLOT ( moveToGroup ( ) ) ) ;
moveToGroupMenu - > addAction ( moveToGroupAction ) ;
} else {
foundGroup = true ;
}
2012-01-27 15:53:17 -05:00
}
2015-05-09 17:43:01 -04:00
QMenu * groupsMenu = contextMnu . addMenu ( QIcon ( IMAGE_GROUP16 ) , tr ( " Groups " ) ) ;
groupsMenu - > addAction ( QIcon ( IMAGE_EXPAND ) , tr ( " Create new group " ) , this , SLOT ( createNewGroup ( ) ) ) ;
2013-09-27 17:40:51 -04:00
2015-05-09 17:43:01 -04:00
if ( addToGroupMenu | | moveToGroupMenu | | foundGroup ) {
if ( addToGroupMenu ) {
groupsMenu - > addMenu ( addToGroupMenu ) ;
}
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
if ( moveToGroupMenu ) {
groupsMenu - > addMenu ( moveToGroupMenu ) ;
}
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
if ( foundGroup ) {
// add remove from group
if ( parent & & parent - > type ( ) = = TYPE_GROUP ) {
QAction * removeFromGroup = groupsMenu - > addAction ( tr ( " Remove from group " ) ) ;
removeFromGroup - > setData ( parent - > data ( COLUMN_DATA , ROLE_ID ) ) ;
connect ( removeFromGroup , SIGNAL ( triggered ( ) ) , this , SLOT ( removeFromGroup ( ) ) ) ;
}
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
QAction * removeFromAllGroups = groupsMenu - > addAction ( tr ( " Remove from all groups " ) ) ;
removeFromAllGroups - > setData ( " " ) ;
connect ( removeFromAllGroups , SIGNAL ( triggered ( ) ) , this , SLOT ( removeFromGroup ( ) ) ) ;
}
}
}
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
}
break ;
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
case TYPE_SSL :
{
contextMnu . addAction ( QIcon ( IMAGE_CHAT ) , tr ( " Chat " ) , this , SLOT ( chatfriendproxy ( ) ) ) ;
contextMnu . addAction ( QIcon ( IMAGE_MSG ) , tr ( " Send message " ) , this , SLOT ( msgfriend ( ) ) ) ;
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
contextMnu . addSeparator ( ) ;
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
contextMnu . addAction ( QIcon ( IMAGE_FRIENDINFO ) , tr ( " Details " ) , this , SLOT ( configurefriend ( ) ) ) ;
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
if ( type = = TYPE_GPG | | type = = TYPE_SSL ) {
contextMnu . addAction ( QIcon ( IMAGE_EXPORTFRIEND ) , tr ( " Recommend this Friend to... " ) , this , SLOT ( recommendfriend ( ) ) ) ;
}
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
contextMnu . addAction ( QIcon ( IMAGE_CONNECT ) , tr ( " Attempt to connect " ) , this , SLOT ( connectfriend ( ) ) ) ;
2013-07-16 18:33:45 -04:00
2015-05-09 17:43:01 -04:00
contextMnu . addAction ( QIcon ( IMAGE_COPYLINK ) , tr ( " Copy certificate link " ) , this , SLOT ( copyFullCertificate ( ) ) ) ;
2012-01-27 15:53:17 -05:00
2015-05-09 17:43:01 -04:00
//this is a SSL key
contextMnu . addAction ( QIcon ( IMAGE_REMOVEFRIEND ) , tr ( " Remove Friend Node " ) , this , SLOT ( removefriend ( ) ) ) ;
2012-01-27 15:53:17 -05:00
}
}
2015-05-09 17:43:01 -04:00
}
2013-07-16 18:33:45 -04:00
2011-10-20 18:48:50 -04:00
contextMnu . addSeparator ( ) ;
2015-05-09 17:43:01 -04:00
QAction * action = contextMnu . addAction ( QIcon ( IMAGE_PASTELINK ) , tr ( " Paste certificate link " ) , this , SLOT ( pastePerson ( ) ) ) ;
if ( RSLinkClipboard : : empty ( RetroShareLink : : TYPE_CERTIFICATE ) )
action - > setDisabled ( true ) ;
2011-10-20 18:48:50 -04:00
contextMnu . addAction ( QIcon ( IMAGE_EXPAND ) , tr ( " Expand all " ) , ui - > peerTreeWidget , SLOT ( expandAll ( ) ) ) ;
contextMnu . addAction ( QIcon ( IMAGE_COLLAPSE ) , tr ( " Collapse all " ) , ui - > peerTreeWidget , SLOT ( collapseAll ( ) ) ) ;
contextMnu . exec ( QCursor : : pos ( ) ) ;
}
2013-09-02 18:51:26 -04:00
2013-07-16 18:33:45 -04:00
void FriendList : : createNewGroup ( )
{
CreateGroup createGrpDialog ( " " , this ) ;
createGrpDialog . exec ( ) ;
}
2011-10-20 18:48:50 -04:00
void FriendList : : updateDisplay ( )
{
insertPeers ( ) ;
}
void FriendList : : groupsChanged ( )
{
groupsHasChanged = true ;
insertPeers ( ) ;
}
void FriendList : : updateAvatar ( const QString & id )
{
2011-11-11 20:26:26 -05:00
if ( ui - > peerTreeWidget - > isColumnHidden ( COLUMN_AVATAR ) )
2011-10-20 18:48:50 -04:00
return ;
QTreeWidgetItemIterator it ( ui - > peerTreeWidget ) ;
while ( * it ) {
2015-06-02 13:32:05 -04:00
// case ssl item
2011-10-20 18:48:50 -04:00
if ( ( * it ) - > type ( ) = = TYPE_SSL & & id = = ( * it ) - > data ( COLUMN_DATA , ROLE_ID ) . toString ( ) ) {
if ( ( * it ) - > parent ( ) ! = NULL & & ( * it ) - > parent ( ) - > type ( ) = = TYPE_GPG ) {
QPixmap avatar ;
2015-02-07 17:43:53 -05:00
AvatarDefs : : getAvatarFromSslId ( RsPeerId ( id . toStdString ( ) ) , avatar ) ;
2011-10-20 18:48:50 -04:00
QIcon avatar_icon ( avatar ) ;
2015-05-09 17:43:01 -04:00
( * it ) - > setIcon ( COLUMN_AVATAR , avatar_icon ) ;
2011-10-20 18:48:50 -04:00
}
}
2015-06-02 13:32:05 -04:00
// case pgp item
if ( ( * it ) - > type ( ) = = TYPE_GPG & & id = = ( * it ) - > data ( COLUMN_DATA , ROLE_BEST_SSL ) . toString ( ) ) {
QPixmap avatar ;
AvatarDefs : : getAvatarFromSslId ( RsPeerId ( id . toStdString ( ) ) , avatar ) ;
QIcon avatar_icon ( avatar ) ;
( * it ) - > setIcon ( COLUMN_AVATAR , avatar_icon ) ;
}
2011-10-20 18:48:50 -04:00
+ + it ;
}
}
/**
* Get the list of peers from the RsIface .
2014-12-30 06:11:08 -05:00
* Adds all friend gpg ids , with their nodes as children to the peerTreeWidget .
2011-10-20 18:48:50 -04:00
* If enabled , peers are sorted in their associated groups .
* Groups are only updated , when groupsHasChanged is true .
*/
void FriendList : : insertPeers ( )
{
if ( RsAutoUpdatePage : : eventsLocked ( ) )
return ;
# ifdef FRIENDS_DEBUG
std : : cerr < < " FriendList::insertPeers() called. " < < std : : endl ;
# endif
2011-11-11 20:26:26 -05:00
bool isStatusColumnHidden = ui - > peerTreeWidget - > isColumnHidden ( COLUMN_STATE ) ;
bool isAvatarColumnHidden = ui - > peerTreeWidget - > isColumnHidden ( COLUMN_AVATAR ) ;
2011-10-20 18:48:50 -04:00
std : : list < StatusInfo > statusInfo ;
rsStatus - > getStatusList ( statusInfo ) ;
if ( ! rsPeers ) {
/* not ready yet! */
std : : cerr < < " FriendList::insertPeers() not ready yet : rsPeers unintialized. " < < std : : endl ;
return ;
}
2015-01-10 08:13:41 -05:00
// get peers with waiting incoming chats
std : : vector < RsPeerId > privateChatIds ;
ChatUserNotify : : getPeersWithWaitingChat ( privateChatIds ) ;
2011-10-20 18:48:50 -04:00
// get existing groups
std : : list < RsGroupInfo > groupInfoList ;
std : : list < RsGroupInfo > : : iterator groupIt ;
rsPeers - > getGroupInfoList ( groupInfoList ) ;
2014-03-17 16:56:06 -04:00
std : : list < RsPgpId > gpgFriends ;
std : : list < RsPgpId > : : iterator gpgIt ;
2011-10-20 18:48:50 -04:00
rsPeers - > getGPGAcceptedList ( gpgFriends ) ;
2014-12-30 06:11:08 -05:00
//add own gpg id, if we have more than on node (ssl client)
2014-03-17 16:56:06 -04:00
std : : list < RsPeerId > ownSslContacts ;
RsPgpId ownId = rsPeers - > getGPGOwnId ( ) ;
2011-10-20 18:48:50 -04:00
rsPeers - > getAssociatedSSLIds ( ownId , ownSslContacts ) ;
if ( ownSslContacts . size ( ) > 0 ) {
gpgFriends . push_back ( ownId ) ;
}
/* get a link to the table */
QTreeWidget * peerTreeWidget = ui - > peerTreeWidget ;
// remove items don't exist anymore
QTreeWidgetItemIterator itemIterator ( peerTreeWidget ) ;
QTreeWidgetItem * item ;
while ( ( item = * itemIterator ) ! = NULL ) {
2014-10-21 18:33:02 -04:00
+ + itemIterator ;
2011-10-20 18:48:50 -04:00
switch ( item - > type ( ) ) {
case TYPE_GPG :
{
QTreeWidgetItem * parent = item - > parent ( ) ;
2014-03-17 16:56:06 -04:00
RsPgpId gpg_widget_id ( getRsId ( item ) ) ;
2011-10-20 18:48:50 -04:00
// remove items that are not friends anymore
if ( std : : find ( gpgFriends . begin ( ) , gpgFriends . end ( ) , gpg_widget_id ) = = gpgFriends . end ( ) ) {
if ( parent ) {
delete ( parent - > takeChild ( parent - > indexOfChild ( item ) ) ) ;
} else {
delete ( peerTreeWidget - > takeTopLevelItem ( peerTreeWidget - > indexOfTopLevelItem ( item ) ) ) ;
}
break ;
}
2011-11-11 20:26:26 -05:00
if ( mShowGroups & & groupsHasChanged ) {
2011-10-20 18:48:50 -04:00
if ( parent ) {
if ( parent - > type ( ) = = TYPE_GROUP ) {
std : : string groupId = getRsId ( parent ) ;
// the parent is a group, check if the gpg id is assigned to the group
2014-10-21 18:33:02 -04:00
for ( groupIt = groupInfoList . begin ( ) ; groupIt ! = groupInfoList . end ( ) ; + + groupIt ) {
2011-10-20 18:48:50 -04:00
if ( groupIt - > id = = groupId ) {
if ( std : : find ( groupIt - > peerIds . begin ( ) , groupIt - > peerIds . end ( ) , gpg_widget_id ) = = groupIt - > peerIds . end ( ) ) {
delete ( parent - > takeChild ( parent - > indexOfChild ( item ) ) ) ;
}
break ;
}
}
}
} else {
// gpg item without group, check if the gpg id is assigned to a group
2014-10-21 18:33:02 -04:00
for ( groupIt = groupInfoList . begin ( ) ; groupIt ! = groupInfoList . end ( ) ; + + groupIt ) {
2011-10-20 18:48:50 -04:00
if ( std : : find ( groupIt - > peerIds . begin ( ) , groupIt - > peerIds . end ( ) , gpg_widget_id ) ! = groupIt - > peerIds . end ( ) ) {
delete ( peerTreeWidget - > takeTopLevelItem ( peerTreeWidget - > indexOfTopLevelItem ( item ) ) ) ;
break ;
}
}
}
}
}
break ;
case TYPE_GROUP :
{
2011-11-11 20:26:26 -05:00
if ( ! mShowGroups ) {
2011-10-20 18:48:50 -04:00
if ( item - > parent ( ) ) {
delete ( item - > parent ( ) - > takeChild ( item - > parent ( ) - > indexOfChild ( item ) ) ) ;
} else {
delete ( peerTreeWidget - > takeTopLevelItem ( peerTreeWidget - > indexOfTopLevelItem ( item ) ) ) ;
}
} else if ( groupsHasChanged ) {
// remove deleted groups
std : : string groupId = getRsId ( item ) ;
2014-10-21 18:33:02 -04:00
for ( groupIt = groupInfoList . begin ( ) ; groupIt ! = groupInfoList . end ( ) ; + + groupIt ) {
2011-10-20 18:48:50 -04:00
if ( groupIt - > id = = groupId ) {
break ;
}
}
2014-10-21 18:33:02 -04:00
if ( groupIt = = groupInfoList . end ( ) | | groupIt - > peerIds . empty ( ) ) {
2011-10-20 18:48:50 -04:00
if ( item - > parent ( ) ) {
delete ( item - > parent ( ) - > takeChild ( item - > parent ( ) - > indexOfChild ( item ) ) ) ;
} else {
delete ( peerTreeWidget - > takeTopLevelItem ( peerTreeWidget - > indexOfTopLevelItem ( item ) ) ) ;
}
}
}
}
break ;
}
}
2014-03-17 16:56:06 -04:00
std : : list < RsPgpId > fillGpgIds ;
2011-10-20 18:48:50 -04:00
// start with groups
groupIt = groupInfoList . begin ( ) ;
while ( true ) {
QTreeWidgetItem * groupItem = NULL ;
RsGroupInfo * groupInfo = NULL ;
int onlineCount = 0 ;
int availableCount = 0 ;
2011-11-11 20:26:26 -05:00
if ( mShowGroups & & groupIt ! = groupInfoList . end ( ) ) {
2011-10-20 18:48:50 -04:00
groupInfo = & ( * groupIt ) ;
2014-10-21 18:33:02 -04:00
if ( ( groupInfo - > flag & RS_GROUP_FLAG_STANDARD ) & & groupInfo - > peerIds . empty ( ) ) {
2011-10-20 18:48:50 -04:00
// don't show empty standard groups
2014-10-21 18:33:02 -04:00
+ + groupIt ;
2011-10-20 18:48:50 -04:00
continue ;
}
// search existing group item
int itemCount = peerTreeWidget - > topLevelItemCount ( ) ;
2014-10-21 18:33:02 -04:00
for ( int index = 0 ; index < itemCount ; + + index ) {
2011-10-20 18:48:50 -04:00
QTreeWidgetItem * groupItemLoop = peerTreeWidget - > topLevelItem ( index ) ;
if ( groupItemLoop - > type ( ) = = TYPE_GROUP & & getRsId ( groupItemLoop ) = = groupInfo - > id ) {
groupItem = groupItemLoop ;
break ;
}
}
if ( groupItem = = NULL ) {
// add group item
groupItem = new RSTreeWidgetItem ( m_compareRole , TYPE_GROUP ) ;
/* Add item to the list. Add here, because for setHidden the item must be added */
peerTreeWidget - > addTopLevelItem ( groupItem ) ;
groupItem - > setChildIndicatorPolicy ( QTreeWidgetItem : : DontShowIndicatorWhenChildless ) ;
groupItem - > setSizeHint ( COLUMN_NAME , QSize ( 26 , 26 ) ) ;
groupItem - > setTextAlignment ( COLUMN_NAME , Qt : : AlignLeft | Qt : : AlignVCenter ) ;
groupItem - > setIcon ( COLUMN_NAME , QIcon ( IMAGE_GROUP24 ) ) ;
2012-11-19 11:01:21 -05:00
groupItem - > setForeground ( COLUMN_NAME , QBrush ( textColorGroup ( ) ) ) ;
2011-10-20 18:48:50 -04:00
/* used to find back the item */
groupItem - > setData ( COLUMN_DATA , ROLE_ID , QString : : fromStdString ( groupInfo - > id ) ) ;
groupItem - > setData ( COLUMN_DATA , ROLE_STANDARD , ( groupInfo - > flag & RS_GROUP_FLAG_STANDARD ) ? true : false ) ;
} else {
// remove all gpg items that are not more assigned
int childCount = groupItem - > childCount ( ) ;
int childIndex = 0 ;
while ( childIndex < childCount ) {
QTreeWidgetItem * gpgItemLoop = groupItem - > child ( childIndex ) ;
if ( gpgItemLoop - > type ( ) = = TYPE_GPG ) {
2014-03-17 16:56:06 -04:00
if ( std : : find ( groupInfo - > peerIds . begin ( ) , groupInfo - > peerIds . end ( ) , RsPgpId ( getRsId ( gpgItemLoop ) ) ) = = groupInfo - > peerIds . end ( ) ) {
2011-10-20 18:48:50 -04:00
delete ( groupItem - > takeChild ( groupItem - > indexOfChild ( gpgItemLoop ) ) ) ;
childCount = groupItem - > childCount ( ) ;
continue ;
}
}
2014-10-21 18:33:02 -04:00
+ + childIndex ;
2011-10-20 18:48:50 -04:00
}
}
if ( openGroups ! = NULL & & openGroups - > find ( groupInfo - > id ) ! = openGroups - > end ( ) ) {
groupItem - > setExpanded ( true ) ;
}
// name is set after calculation of online/offline items
}
// iterate through gpg friends
2015-05-15 10:45:44 -04:00
for ( gpgIt = gpgFriends . begin ( ) ; gpgIt ! = gpgFriends . end ( ) ; + + gpgIt )
{
RsPgpId gpgId = * gpgIt ;
if ( mShowGroups ) {
if ( groupInfo ) {
// we fill a group, check if gpg id is assigned
if ( std : : find ( groupInfo - > peerIds . begin ( ) , groupInfo - > peerIds . end ( ) , gpgId ) = = groupInfo - > peerIds . end ( ) ) {
continue ;
}
} else {
// we fill the not assigned gpg ids
if ( std : : find ( fillGpgIds . begin ( ) , fillGpgIds . end ( ) , gpgId ) ! = fillGpgIds . end ( ) ) {
continue ;
2011-10-20 18:48:50 -04:00
}
}
2015-05-15 10:45:44 -04:00
// add equal too, its no problem
fillGpgIds . push_back ( gpgId ) ;
}
//add the gpg friends
2011-10-20 18:48:50 -04:00
# ifdef FRIENDS_DEBUG
2015-05-15 10:45:44 -04:00
std : : cerr < < " FriendList::insertPeers() inserting gpg_id : " < < gpgId < < std : : endl ;
2011-10-20 18:48:50 -04:00
# endif
2015-05-15 10:45:44 -04:00
/* make a widget per friend */
QTreeWidgetItem * gpgItem = NULL ;
QTreeWidgetItem * gpgItemLoop = NULL ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
// search existing gpg item
int itemCount = groupItem ? groupItem - > childCount ( ) : peerTreeWidget - > topLevelItemCount ( ) ;
for ( int index = 0 ; index < itemCount ; + + index ) {
gpgItemLoop = groupItem ? groupItem - > child ( index ) : peerTreeWidget - > topLevelItem ( index ) ;
if ( gpgItemLoop - > type ( ) = = TYPE_GPG & & getRsId ( gpgItemLoop ) = = gpgId . toStdString ( ) ) {
gpgItem = gpgItemLoop ;
break ;
2011-10-20 18:48:50 -04:00
}
2015-05-15 10:45:44 -04:00
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
RsPeerDetails detail ;
if ( ( ! rsPeers - > getGPGDetails ( gpgId , detail ) | | ! detail . accept_connection ) & & detail . gpg_id ! = ownId ) {
// don't accept anymore connection, remove from the view
if ( gpgItem ) {
2011-10-20 18:48:50 -04:00
if ( groupItem ) {
2015-05-15 10:45:44 -04:00
delete ( groupItem - > takeChild ( groupItem - > indexOfChild ( gpgItem ) ) ) ;
2011-10-20 18:48:50 -04:00
} else {
2015-05-15 10:45:44 -04:00
delete ( peerTreeWidget - > takeTopLevelItem ( peerTreeWidget - > indexOfTopLevelItem ( gpgItem ) ) ) ;
2011-10-20 18:48:50 -04:00
}
}
2015-05-15 10:45:44 -04:00
continue ;
}
if ( gpgItem = = NULL ) {
// create gpg item and add it to tree
gpgItem = new RSTreeWidgetItem ( m_compareRole , TYPE_GPG ) ; //set type to 0 for custom popup menu
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
/* Add gpg item to the list. Add here, because for setHidden the item must be added */
if ( groupItem ) {
groupItem - > addChild ( gpgItem ) ;
2011-11-11 20:26:26 -05:00
} else {
2015-05-15 10:45:44 -04:00
peerTreeWidget - > addTopLevelItem ( gpgItem ) ;
2011-11-11 20:26:26 -05:00
}
2015-05-15 10:45:44 -04:00
gpgItem - > setChildIndicatorPolicy ( QTreeWidgetItem : : DontShowIndicatorWhenChildless ) ;
gpgItem - > setTextAlignment ( COLUMN_NAME , Qt : : AlignLeft | Qt : : AlignVCenter ) ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
/* not displayed, used to find back the item */
gpgItem - > setData ( COLUMN_DATA , ROLE_ID , QString : : fromStdString ( detail . gpg_id . toStdString ( ) ) ) ;
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
if ( mBigName & & ! mHideState & & isStatusColumnHidden ) {
gpgItem - > setSizeHint ( COLUMN_NAME , QSize ( 40 , 40 ) ) ;
} else {
gpgItem - > setSizeHint ( COLUMN_NAME , QSize ( 26 , 26 ) ) ;
}
+ + availableCount ;
QString gpgItemText = QString : : fromUtf8 ( detail . name . c_str ( ) ) ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
// remove items that are not friends anymore
int childCount = gpgItem - > childCount ( ) ;
int childIndex = 0 ;
while ( childIndex < childCount ) {
std : : string ssl_id = getRsId ( gpgItem - > child ( childIndex ) ) ;
if ( ! rsPeers - > isFriend ( RsPeerId ( ssl_id ) ) ) {
delete ( gpgItem - > takeChild ( childIndex ) ) ;
// count again
2011-10-20 18:48:50 -04:00
childCount = gpgItem - > childCount ( ) ;
2015-05-15 10:45:44 -04:00
} else {
+ + childIndex ;
}
}
// update the childs (ssl certs)
bool gpg_connected = false ;
bool gpg_online = false ;
bool gpg_hasPrivateChat = false ;
int bestPeerState = 0 ; // for gpg item
unsigned int bestRSState = 0 ; // for gpg item
RsPeerId bestSslId ; // for gpg item
QString bestCustomStateString ; // for gpg item
std : : list < RsPeerId > sslContacts ;
QDateTime lastContact ;
QString itemIP ;
rsPeers - > getAssociatedSSLIds ( detail . gpg_id , sslContacts ) ;
for ( std : : list < RsPeerId > : : iterator sslIt = sslContacts . begin ( ) ; sslIt ! = sslContacts . end ( ) ; + + sslIt ) {
QTreeWidgetItem * sslItem = NULL ;
RsPeerId sslId = * sslIt ;
//find the corresponding sslItem child item of the gpg item
bool newChild = true ;
childCount = gpgItem - > childCount ( ) ;
for ( int childIndex = 0 ; childIndex < childCount ; + + childIndex ) {
// we assume, that only ssl items are child of the gpg item, so we don't need to test the type
if ( getRsId ( gpgItem - > child ( childIndex ) ) = = sslId . toStdString ( ) ) {
sslItem = gpgItem - > child ( childIndex ) ;
newChild = false ;
break ;
2011-10-20 18:48:50 -04:00
}
2015-05-15 10:45:44 -04:00
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
RsPeerDetails sslDetail ;
if ( ! rsPeers - > getPeerDetails ( sslId , sslDetail ) | | ! rsPeers - > isFriend ( sslId ) ) {
2011-10-20 18:48:50 -04:00
# ifdef FRIENDS_DEBUG
2015-05-15 10:45:44 -04:00
std : : cerr < < " Removing widget from the view : id : " < < sslId < < std : : endl ;
2011-10-20 18:48:50 -04:00
# endif
2015-05-15 10:45:44 -04:00
//child has disappeared, remove it from the gpg_item
if ( sslItem ) {
gpgItem - > removeChild ( sslItem ) ;
2011-10-20 18:48:50 -04:00
}
2015-05-15 10:45:44 -04:00
continue ;
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
if ( newChild ) {
sslItem = new RSTreeWidgetItem ( m_compareRole , TYPE_SSL ) ; //set type to 1 for custom popup menu
2011-10-20 18:48:50 -04:00
# ifdef FRIENDS_DEBUG
2015-05-15 10:45:44 -04:00
std : : cerr < < " FriendList::insertPeers() inserting sslItem. " < < std : : endl ;
2011-10-20 18:48:50 -04:00
# endif
2015-05-15 10:45:44 -04:00
/* Add ssl child to the list. Add here, because for setHidden the item must be added */
gpgItem - > addChild ( sslItem ) ;
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
/* not displayed, used to find back the item */
sslItem - > setData ( COLUMN_DATA , ROLE_ID , QString : : fromStdString ( sslDetail . id . toStdString ( ) ) ) ;
2011-10-20 18:48:50 -04:00
2015-06-02 13:32:05 -04:00
if ( ! isAvatarColumnHidden )
updateAvatar ( QString : : fromStdString ( sslDetail . id . toStdString ( ) ) ) ;
2015-05-15 10:45:44 -04:00
QString sText ;
QString customStateString ;
if ( sslDetail . state & RS_PEER_STATE_CONNECTED ) {
customStateString = QString : : fromUtf8 ( rsMsgs - > getCustomStateString ( sslDetail . id ) . c_str ( ) ) ;
}
sText = QString : : fromUtf8 ( sslDetail . location . c_str ( ) ) ;
if ( customStateString . isEmpty ( ) = = false ) {
sText + = " - " + customStateString ;
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
QString connectStateString = StatusDefs : : connectStateWithoutTransportTypeString ( sslDetail ) ;
if ( ! isStatusColumnHidden ) {
sslItem - > setText ( COLUMN_STATE , connectStateString ) ;
} else if ( ! mHideState & & connectStateString . isEmpty ( ) = = false ) {
sText + = " [ " + connectStateString + " ] " ;
}
sslItem - > setText ( COLUMN_NAME , sText ) ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
if ( isStatusColumnHidden = = true & & mHideState = = true ) {
/* Show the state as tooltip */
sslItem - > setToolTip ( COLUMN_NAME , connectStateString ) ;
} else {
sslItem - > setToolTip ( COLUMN_NAME , " " ) ;
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
// sort node
sslItem - > setData ( COLUMN_STATE , ROLE_SORT , sText ) ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
/* last contact */
QDateTime sslLastContact = QDateTime : : fromTime_t ( sslDetail . lastConnect ) ;
sslItem - > setData ( COLUMN_LAST_CONTACT , Qt : : DisplayRole , QVariant ( sslLastContact ) ) ;
sslItem - > setData ( COLUMN_LAST_CONTACT , ROLE_SORT , sslLastContact ) ;
if ( sslLastContact > lastContact ) {
lastContact = sslLastContact ;
}
2011-11-11 20:26:26 -05:00
2015-05-15 10:45:44 -04:00
/* IP */
2013-12-08 09:12:02 -05:00
2015-05-15 10:45:44 -04:00
QString sslItemIP = ( sslDetail . state & RS_PEER_STATE_CONNECTED ) ? StatusDefs : : connectStateIpString ( sslDetail ) : QString ( " --- " ) ;
2013-07-04 16:11:36 -04:00
2015-05-15 10:45:44 -04:00
sslItem - > setData ( COLUMN_IP , Qt : : DisplayRole , QVariant ( sslItemIP ) ) ;
sslItem - > setData ( COLUMN_IP , ROLE_SORT , sslItemIP ) ;
if ( sslItemIP ! = itemIP ) {
itemIP = sslItemIP ;
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
/* change color and icon */
QIcon sslIcon ;
QFont sslFont ;
QColor sslColor ;
if ( sslDetail . state & RS_PEER_STATE_CONNECTED ) {
// get the status info for this ssl id
int peerState = 0 ;
int rsState = 0 ;
std : : list < StatusInfo > : : iterator it ;
for ( it = statusInfo . begin ( ) ; it ! = statusInfo . end ( ) ; + + it ) {
if ( it - > id = = sslId ) {
rsState = it - > status ;
switch ( rsState ) {
case RS_STATUS_INACTIVE :
peerState = PEER_STATE_INACTIVE ;
break ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
case RS_STATUS_ONLINE :
peerState = PEER_STATE_ONLINE ;
break ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
case RS_STATUS_AWAY :
peerState = PEER_STATE_AWAY ;
break ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
case RS_STATUS_BUSY :
peerState = PEER_STATE_BUSY ;
break ;
}
/* find the best ssl contact for the gpg item */
if ( bestPeerState = = 0 | | peerState < bestPeerState ) {
/* first ssl contact or higher state */
bestPeerState = peerState ;
bestSslId = sslId ;
bestRSState = rsState ;
bestCustomStateString = customStateString ;
} else if ( peerState = = bestPeerState ) {
/* equal state */
if ( mBigName & & bestCustomStateString . isEmpty ( ) & & ! customStateString . isEmpty ( ) ) {
/* when customStateString is shown in name item, use sslId with customStateString.
second with a custom state string . . . use second */
2011-10-20 18:48:50 -04:00
bestPeerState = peerState ;
bestSslId = sslId ;
bestRSState = rsState ;
bestCustomStateString = customStateString ;
}
}
2015-05-15 10:45:44 -04:00
break ;
2011-10-20 18:48:50 -04:00
}
2015-05-15 10:45:44 -04:00
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
sslItem - > setHidden ( false ) ;
gpg_connected = true ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
sslIcon = QIcon ( " :/images/connect_established.png " ) ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
if ( rsState = = 0 ) {
2011-10-20 18:48:50 -04:00
sslFont . setBold ( true ) ;
2012-11-19 11:01:21 -05:00
sslColor = mTextColorStatus [ RS_STATUS_ONLINE ] ;
2011-10-20 18:48:50 -04:00
} else {
2015-05-15 10:45:44 -04:00
sslFont = StatusDefs : : font ( rsState ) ;
sslColor = mTextColorStatus [ rsState ] ;
2011-10-20 18:48:50 -04:00
}
2015-05-15 10:45:44 -04:00
} else if ( sslDetail . state & RS_PEER_STATE_ONLINE ) {
sslItem - > setHidden ( mHideUnconnected ) ;
gpg_online = true ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
if ( sslDetail . connectState ) {
sslIcon = QIcon ( " :/images/connect_creating.png " ) ;
} else {
sslIcon = QIcon ( " :/images/connect_no.png " ) ;
2011-10-20 18:48:50 -04:00
}
2015-05-15 10:45:44 -04:00
sslFont . setBold ( true ) ;
sslColor = mTextColorStatus [ RS_STATUS_ONLINE ] ;
} else {
sslItem - > setHidden ( mHideUnconnected ) ;
if ( sslDetail . connectState ) {
sslIcon = QIcon ( " :/images/connect_creating.png " ) ;
} else {
sslIcon = QIcon ( " :/images/connect_no.png " ) ;
2011-10-20 18:48:50 -04:00
}
2015-05-15 10:45:44 -04:00
sslFont . setBold ( false ) ;
sslColor = mTextColorStatus [ RS_STATUS_OFFLINE ] ;
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
if ( std : : find ( privateChatIds . begin ( ) , privateChatIds . end ( ) , sslDetail . id ) ! = privateChatIds . end ( ) ) {
// private chat is available
sslIcon = QIcon ( " :/images/chat.png " ) ;
gpg_hasPrivateChat = true ;
}
sslItem - > setIcon ( COLUMN_NAME , sslIcon ) ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
for ( int i = 0 ; i < COLUMN_COUNT ; + + i ) {
sslItem - > setTextColor ( i , sslColor ) ;
sslItem - > setFont ( i , sslFont ) ;
}
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
QIcon gpgIcon ;
if ( gpg_connected ) {
gpgItem - > setHidden ( false ) ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
+ + onlineCount ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
if ( bestPeerState = = 0 ) {
// show as online
bestPeerState = PEER_STATE_ONLINE ;
bestRSState = RS_STATUS_ONLINE ;
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
QColor textColor = mTextColorStatus [ bestRSState ] ;
QFont font = StatusDefs : : font ( bestRSState ) ;
for ( int i = 0 ; i < COLUMN_COUNT ; + + i ) {
gpgItem - > setTextColor ( i , textColor ) ;
gpgItem - > setFont ( i , font ) ;
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
gpgIcon = QIcon ( StatusDefs : : imageStatus ( bestRSState ) ) ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
if ( ! isStatusColumnHidden ) {
gpgItem - > setText ( COLUMN_STATE , StatusDefs : : name ( bestRSState ) ) ;
}
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
if ( isStatusColumnHidden & & mBigName & & ! mHideState ) {
if ( bestCustomStateString . isEmpty ( ) ) {
gpgItemText + = " \n " + StatusDefs : : name ( bestRSState ) ;
} else {
gpgItemText + = " \n " + bestCustomStateString ;
2011-10-20 18:48:50 -04:00
}
2015-05-15 10:45:44 -04:00
} else if ( isStatusColumnHidden & & ! mHideState ) {
gpgItemText + = " - " + StatusDefs : : name ( bestRSState ) ;
2011-10-20 18:48:50 -04:00
}
2015-05-15 10:45:44 -04:00
} else if ( gpg_online ) {
if ( ! isStatusColumnHidden ) {
gpgItem - > setText ( COLUMN_STATE , tr ( " Available " ) ) ;
} else if ( ! mHideState & & ! mBigName ) {
gpgItemText + = " - " + tr ( " Available " ) ;
2011-10-20 18:48:50 -04:00
}
2015-05-15 10:45:44 -04:00
bestPeerState = PEER_STATE_AVAILABLE ;
+ + onlineCount ;
gpgItem - > setHidden ( mHideUnconnected ) ;
gpgIcon = QIcon ( IMAGE_AVAILABLE ) ;
QFont font ;
font . setBold ( true ) ;
QColor textColor = mTextColorStatus [ RS_STATUS_ONLINE ] ;
for ( int i = 0 ; i < COLUMN_COUNT ; + + i ) {
gpgItem - > setTextColor ( i , textColor ) ;
gpgItem - > setFont ( i , font ) ;
2011-10-20 18:48:50 -04:00
}
2015-05-15 10:45:44 -04:00
} else {
if ( ! isStatusColumnHidden ) {
gpgItem - > setText ( COLUMN_STATE , StatusDefs : : name ( RS_STATUS_OFFLINE ) ) ;
} else if ( ! mHideState & & ! mBigName ) {
gpgItemText + = " - " + StatusDefs : : name ( RS_STATUS_OFFLINE ) ;
}
bestPeerState = PEER_STATE_OFFLINE ;
gpgItem - > setHidden ( mHideUnconnected ) ;
gpgIcon = QIcon ( StatusDefs : : imageStatus ( RS_STATUS_OFFLINE ) ) ;
2011-10-20 18:48:50 -04:00
2015-05-15 10:45:44 -04:00
QColor textColor = mTextColorStatus [ RS_STATUS_OFFLINE ] ;
QFont font = StatusDefs : : font ( RS_STATUS_OFFLINE ) ;
for ( int i = 0 ; i < COLUMN_COUNT ; + + i ) {
gpgItem - > setTextColor ( i , textColor ) ;
gpgItem - > setFont ( i , font ) ;
2011-10-20 18:48:50 -04:00
}
}
2015-05-15 10:45:44 -04:00
if ( gpg_hasPrivateChat ) {
gpgIcon = QIcon ( " :/images/chat.png " ) ;
}
2015-06-02 13:32:05 -04:00
if ( ! isAvatarColumnHidden ) {
2015-05-15 10:45:44 -04:00
QPixmap avatar ;
AvatarDefs : : getAvatarFromSslId ( bestSslId , avatar ) ;
QIcon avatar_icon ( avatar ) ;
gpgItem - > setIcon ( COLUMN_AVATAR , avatar_icon ) ;
2015-06-02 13:32:05 -04:00
// tell the avatar callback which avatar must be filled in at this place
gpgItem - > setData ( COLUMN_DATA , ROLE_BEST_SSL , QString : : fromStdString ( bestSslId . toStdString ( ) ) ) ;
2015-05-15 10:45:44 -04:00
}
gpgItem - > setText ( COLUMN_NAME , gpgItemText ) ;
gpgItem - > setData ( COLUMN_NAME , ROLE_SORT , " 2 " + gpgItemText ) ;
gpgItem - > setData ( COLUMN_STATE , ROLE_SORT , " 2 " + BuildStateSortString ( true , gpgItemText , bestPeerState ) ) ;
gpgItem - > setIcon ( COLUMN_NAME , gpgIcon ) ;
gpgItem - > setData ( COLUMN_LAST_CONTACT , Qt : : DisplayRole , QVariant ( lastContact ) ) ;
gpgItem - > setData ( COLUMN_LAST_CONTACT , ROLE_SORT , " 2 " + lastContact . toString ( " yyyyMMdd_hhmmss " ) ) ;
gpgItem - > setData ( COLUMN_IP , Qt : : DisplayRole , QVariant ( ) ) ;
gpgItem - > setData ( COLUMN_IP , ROLE_SORT , " 2 " + itemIP ) ;
if ( openPeers ! = NULL & & openPeers - > find ( gpgId . toStdString ( ) ) ! = openPeers - > end ( ) ) {
gpgItem - > setExpanded ( true ) ;
}
}
2011-10-20 18:48:50 -04:00
if ( groupInfo & & groupItem ) {
if ( ( groupInfo - > flag & RS_GROUP_FLAG_STANDARD ) & & groupItem - > childCount ( ) = = 0 ) {
// there are some dead id's assigned
groupItem - > setHidden ( true ) ;
} else {
groupItem - > setHidden ( false ) ;
QString groupName = GroupDefs : : name ( * groupInfo ) ;
groupItem - > setText ( COLUMN_NAME , QString ( " %1 (%2/%3) " ) . arg ( groupName ) . arg ( onlineCount ) . arg ( availableCount ) ) ;
// show first the standard groups, than the user groups
groupItem - > setData ( COLUMN_NAME , ROLE_SORT , ( ( groupInfo - > flag & RS_GROUP_FLAG_STANDARD ) ? " 0 " : " 1 " ) + groupName ) ;
}
}
2011-11-11 20:26:26 -05:00
if ( mShowGroups & & groupIt ! = groupInfoList . end ( ) ) {
2014-10-21 18:33:02 -04:00
+ + groupIt ;
2011-10-20 18:48:50 -04:00
} else {
// all done
break ;
}
}
if ( filterText . isEmpty ( ) = = false ) {
filterItems ( filterText ) ;
}
QTreeWidgetItem * c = getCurrentPeer ( ) ;
if ( c & & c - > isHidden ( ) ) {
// active item is hidden, deselect it
ui - > peerTreeWidget - > setCurrentItem ( NULL ) ;
}
groupsHasChanged = false ;
if ( openGroups ! = NULL ) {
delete ( openGroups ) ;
openGroups = NULL ;
}
if ( openPeers ! = NULL ) {
delete ( openPeers ) ;
openPeers = NULL ;
}
}
/**
* Returns a list with all groupIds that are expanded
*/
bool FriendList : : getExpandedGroups ( std : : set < std : : string > & groups ) const
{
int itemCount = ui - > peerTreeWidget - > topLevelItemCount ( ) ;
2014-10-21 18:33:02 -04:00
for ( int index = 0 ; index < itemCount ; + + index ) {
2011-10-20 18:48:50 -04:00
QTreeWidgetItem * item = ui - > peerTreeWidget - > topLevelItem ( index ) ;
if ( item - > type ( ) = = TYPE_GROUP & & item - > isExpanded ( ) ) {
groups . insert ( item - > data ( COLUMN_DATA , ROLE_ID ) . toString ( ) . toStdString ( ) ) ;
}
}
return true ;
}
/**
* Returns a list with all gpg ids that are expanded
*/
bool FriendList : : getExpandedPeers ( std : : set < std : : string > & peers ) const
{
peers . clear ( ) ;
QTreeWidgetItemIterator it ( ui - > peerTreeWidget ) ;
while ( * it ) {
QTreeWidgetItem * item = * it ;
if ( item - > type ( ) = = TYPE_GPG & & item - > isExpanded ( ) ) {
peers . insert ( peers . end ( ) , getRsId ( item ) ) ;
}
+ + it ;
}
return true ;
}
///** Open a QFileDialog to browse for export a file. */
//void FriendList::exportfriend()
//{
// QTreeWidgetItem *c = getCurrentPeer();
//#ifdef FRIENDS_DEBUG
// std::cerr << "FriendList::exportfriend()" << std::endl;
//#endif
// if (!c)
// {
//#ifdef FRIENDS_DEBUG
// std::cerr << "FriendList::exportfriend() None Selected -- sorry" << std::endl;
//#endif
// return;
// }
// std::string id = getPeerRsCertId(c);
// if (misc::getSaveFileName(this, RshareSettings::LASTDIR_CERT, tr("Save Certificate"), tr("Certificates (*.pqi)"), fileName))
// {
//#ifdef FRIENDS_DEBUG
// std::cerr << "FriendList::exportfriend() Saving to: " << fileName.toStdString() << std::endl;
//#endif
// if (rsPeers)
// {
// rsPeers->saveCertificateToFile(id, fileName.toUtf8().constData());
// }
// }
//}
void FriendList : : chatfriendproxy ( )
{
chatfriend ( getCurrentPeer ( ) ) ;
}
/**
* Start a chat with a friend
*
* @ param pPeer the gpg or ssl QTreeWidgetItem to chat with
*/
2014-10-25 08:26:09 -04:00
void FriendList : : chatfriend ( QTreeWidgetItem * item )
2011-10-20 18:48:50 -04:00
{
2014-10-25 08:26:09 -04:00
if ( item = = NULL ) {
2011-10-20 18:48:50 -04:00
return ;
}
2014-10-25 08:26:09 -04:00
switch ( item - > type ( ) ) {
case TYPE_GROUP :
break ;
case TYPE_GPG :
ChatDialog : : chatFriend ( RsPgpId ( getRsId ( item ) ) ) ;
break ;
case TYPE_SSL :
2014-12-29 16:41:05 -05:00
ChatDialog : : chatFriend ( ChatId ( RsPeerId ( getRsId ( item ) ) ) ) ;
2014-10-25 08:26:09 -04:00
break ;
}
2011-10-20 18:48:50 -04:00
}
void FriendList : : addFriend ( )
{
std : : string groupId = getSelectedGroupId ( ) ;
ConnectFriendWizard connwiz ( this ) ;
if ( groupId . empty ( ) = = false ) {
connwiz . setGroup ( groupId ) ;
}
connwiz . exec ( ) ;
}
void FriendList : : msgfriend ( )
{
2015-05-29 06:07:12 -04:00
QTreeWidgetItem * item = getCurrentPeer ( ) ;
2011-10-20 18:48:50 -04:00
2015-05-29 06:07:12 -04:00
if ( ! item )
2011-10-20 18:48:50 -04:00
return ;
2015-05-29 06:07:12 -04:00
switch ( item - > type ( ) ) {
case TYPE_GROUP :
break ;
case TYPE_GPG :
MessageComposer : : msgFriend ( RsPgpId ( getRsId ( item ) ) ) ;
break ;
case TYPE_SSL :
MessageComposer : : msgFriend ( RsPeerId ( getRsId ( item ) ) ) ;
break ;
}
2011-10-20 18:48:50 -04:00
}
void FriendList : : recommendfriend ( )
{
QTreeWidgetItem * peer = getCurrentPeer ( ) ;
if ( ! peer )
return ;
2012-01-23 17:38:50 -05:00
std : : string peerId = getRsId ( peer ) ;
2014-03-17 16:56:06 -04:00
std : : list < RsPeerId > ids ;
2012-01-23 17:38:50 -05:00
2014-03-17 16:56:06 -04:00
switch ( peer - > type ( ) )
{
2012-01-23 17:38:50 -05:00
case TYPE_SSL :
2014-03-17 16:56:06 -04:00
ids . push_back ( RsPeerId ( peerId ) ) ;
2012-01-23 17:38:50 -05:00
break ;
case TYPE_GPG :
2014-03-17 16:56:06 -04:00
rsPeers - > getAssociatedSSLIds ( RsPgpId ( peerId ) , ids ) ;
2012-01-23 17:38:50 -05:00
break ;
default :
return ;
}
2015-04-17 17:36:22 -04:00
std : : set < RsPeerId > sids ;
for ( std : : list < RsPeerId > : : const_iterator it ( ids . begin ( ) ) ; it ! = ids . end ( ) ; + + it )
sids . insert ( * it ) ;
2012-01-23 17:38:50 -05:00
2015-04-17 17:36:22 -04:00
MessageComposer : : recommendFriend ( sids ) ;
2011-10-20 18:48:50 -04:00
}
void FriendList : : pastePerson ( )
{
2013-09-27 17:40:51 -04:00
//RSLinkClipboard::process(RetroShareLink::TYPE_PERSON);
2012-03-30 15:43:39 -04:00
RSLinkClipboard : : process ( RetroShareLink : : TYPE_CERTIFICATE ) ;
2011-10-20 18:48:50 -04:00
}
2012-01-18 15:31:30 -05:00
void FriendList : : copyFullCertificate ( )
{
QTreeWidgetItem * c = getCurrentPeer ( ) ;
QList < RetroShareLink > urls ;
2014-03-17 16:56:06 -04:00
RetroShareLink link ;
link . createCertificate ( RsPeerId ( getRsId ( c ) ) ) ;
2012-01-18 15:31:30 -05:00
urls . push_back ( link ) ;
std : : cerr < < " link: " < < std : : endl ;
std : : cerr < < link . toString ( ) . toStdString ( ) < < std : : endl ;
RSLinkClipboard : : copyLinks ( urls ) ;
}
2013-09-27 17:40:51 -04:00
// void FriendList::copyLink()
// {
// QTreeWidgetItem *c = getCurrentPeer();
//
// if (c == NULL) {
// return;
// }
//
// QList<RetroShareLink> urls;
// RetroShareLink link;
// if (link.createPerson(getRsId(c))) {
// urls.push_back(link);
// }
//
// RSLinkClipboard::copyLinks(urls);
// }
2011-10-20 18:48:50 -04:00
/**
* Find out which group is selected
*
* @ return If a group item is selected , its groupId otherwise an empty string
*/
std : : string FriendList : : getSelectedGroupId ( ) const
{
QTreeWidgetItem * c = getCurrentPeer ( ) ;
if ( c & & c - > type ( ) = = TYPE_GROUP ) {
return getRsId ( c ) ;
}
return std : : string ( ) ;
}
QTreeWidgetItem * FriendList : : getCurrentPeer ( ) const
{
/* get the current, and extract the Id */
QTreeWidgetItem * item = ui - > peerTreeWidget - > currentItem ( ) ;
# ifdef FRIENDS_DEBUG
if ( ! item )
{
std : : cerr < < " Invalid Current Item " < < std : : endl ;
return NULL ;
}
/* Display the columns of this item. */
2012-03-28 14:02:49 -04:00
QString out = " CurrentPeerItem: \n " ;
2011-10-20 18:48:50 -04:00
2014-10-21 18:33:02 -04:00
for ( int i = 1 ; i < COLUMN_COUNT ; + + i )
2011-10-20 18:48:50 -04:00
{
QString txt = item - > text ( i ) ;
2012-03-28 14:02:49 -04:00
out + = QString ( " \t %1:%2 \n " ) . arg ( i ) . arg ( txt ) ;
2011-10-20 18:48:50 -04:00
}
2012-03-28 14:02:49 -04:00
std : : cerr < < out . toStdString ( ) ;
2011-10-20 18:48:50 -04:00
# endif
return item ;
}
2012-02-13 13:43:15 -05:00
# ifdef UNFINISHED_FD
2011-10-20 18:48:50 -04:00
/* GUI stuff -> don't do anything directly with Control */
void FriendsDialog : : viewprofile ( )
{
/* display Dialog */
QTreeWidgetItem * c = getCurrentPeer ( ) ;
// static ProfileView *profileview = new ProfileView();
if ( ! c )
return ;
/* set the Id */
std : : string id = getRsId ( c ) ;
profileview - > setPeerId ( id ) ;
profileview - > show ( ) ;
}
# endif
/* So from the Peers Dialog we can call the following control Functions:
* ( 1 ) Remove Current . FriendRemove ( id )
* ( 2 ) Allow / DisAllow . FriendStatus ( id , accept )
* ( 2 ) Connect . FriendConnectAttempt ( id , accept )
* ( 3 ) Set Address . FriendSetAddress ( id , str , port )
* ( 4 ) Set Trust . FriendTrustSignature ( id , bool )
* ( 5 ) Configure ( GUI Only ) - > 3 / 4
*
* All of these rely on the finding of the current Id .
*/
void FriendList : : removefriend ( )
{
QTreeWidgetItem * c = getCurrentPeer ( ) ;
# ifdef FRIENDS_DEBUG
std : : cerr < < " FriendList::removefriend() " < < std : : endl ;
# endif
if ( ! c )
{
# ifdef FRIENDS_DEBUG
std : : cerr < < " FriendList::removefriend() None Selected -- sorry " < < std : : endl ;
# endif
return ;
}
if ( rsPeers )
{
2015-01-23 19:59:32 -05:00
switch ( c - > type ( ) ) {
case TYPE_GPG :
if ( ! RsPgpId ( getRsId ( c ) ) . isNull ( ) ) {
if ( ( QMessageBox : : question ( this , " RetroShare " , tr ( " Do you want to remove this Friend? " ) , QMessageBox : : Yes | QMessageBox : : No , QMessageBox : : Yes ) ) = = QMessageBox : : Yes )
{
rsPeers - > removeFriend ( RsPgpId ( getRsId ( c ) ) ) ;
}
}
break ;
case TYPE_SSL :
if ( ! RsPeerId ( getRsId ( c ) ) . isNull ( ) ) {
if ( ( QMessageBox : : question ( this , " RetroShare " , tr ( " Do you want to remove this node? " ) , QMessageBox : : Yes | QMessageBox : : No , QMessageBox : : Yes ) ) = = QMessageBox : : Yes )
{
rsPeers - > removeFriendLocation ( RsPeerId ( getRsId ( c ) ) ) ;
}
}
break ;
2011-10-20 18:48:50 -04:00
}
}
}
void FriendList : : connectfriend ( )
{
QTreeWidgetItem * c = getCurrentPeer ( ) ;
# ifdef FRIENDS_DEBUG
std : : cerr < < " FriendList::connectfriend() " < < std : : endl ;
# endif
if ( ! c )
{
# ifdef FRIENDS_DEBUG
std : : cerr < < " FriendList::connectfriend() None Selected -- sorry " < < std : : endl ;
# endif
return ;
}
if ( rsPeers )
{
if ( c - > type ( ) = = TYPE_GPG ) {
int childCount = c - > childCount ( ) ;
2014-10-21 18:33:02 -04:00
for ( int childIndex = 0 ; childIndex < childCount ; + + childIndex ) {
2011-10-20 18:48:50 -04:00
QTreeWidgetItem * item = c - > child ( childIndex ) ;
if ( item - > type ( ) = = TYPE_SSL ) {
2014-03-17 16:56:06 -04:00
rsPeers - > connectAttempt ( RsPeerId ( getRsId ( item ) ) ) ;
2011-10-20 18:48:50 -04:00
item - > setIcon ( COLUMN_NAME , ( QIcon ( IMAGE_CONNECT2 ) ) ) ;
2013-08-26 03:24:37 -04:00
// Launch ProgressDialog, only if single SSL child.
if ( childCount = = 1 )
{
2014-03-17 16:56:06 -04:00
ConnectProgressDialog : : showProgress ( RsPeerId ( getRsId ( item ) ) ) ;
2013-08-26 03:24:37 -04:00
}
2011-10-20 18:48:50 -04:00
}
}
} else {
//this is a SSL key
2014-03-17 16:56:06 -04:00
rsPeers - > connectAttempt ( RsPeerId ( getRsId ( c ) ) ) ;
2011-10-20 18:48:50 -04:00
c - > setIcon ( COLUMN_NAME , ( QIcon ( IMAGE_CONNECT2 ) ) ) ;
2013-08-26 03:24:37 -04:00
// Launch ProgressDialog.
2014-03-17 16:56:06 -04:00
ConnectProgressDialog : : showProgress ( RsPeerId ( getRsId ( c ) ) ) ;
2011-10-20 18:48:50 -04:00
}
}
}
/* GUI stuff -> don't do anything directly with Control */
void FriendList : : configurefriend ( )
{
2014-03-17 16:56:06 -04:00
if ( ! RsPeerId ( getRsId ( getCurrentPeer ( ) ) ) . isNull ( ) )
ConfCertDialog : : showIt ( RsPeerId ( getRsId ( getCurrentPeer ( ) ) ) , ConfCertDialog : : PageDetails ) ;
else if ( ! RsPgpId ( getRsId ( getCurrentPeer ( ) ) ) . isNull ( ) )
2015-05-12 16:30:44 -04:00
PGPKeyDialog : : showIt ( RsPgpId ( getRsId ( getCurrentPeer ( ) ) ) , PGPKeyDialog : : PageDetails ) ;
2014-03-17 16:56:06 -04:00
else
std : : cerr < < " FriendList::configurefriend: id is not an SSL nor a PGP id. " < < std : : endl ;
2011-10-20 18:48:50 -04:00
}
2013-07-16 18:33:45 -04:00
// void FriendList::showLobby()
// {
// std::string lobby_id = qobject_cast<QAction*>(sender())->data().toString().toStdString();
//
// if (lobby_id.empty())
// return;
//
// std::string vpeer_id;
//
// if (rsMsgs->getVirtualPeerId(ChatLobbyId(QString::fromStdString(lobby_id).toULongLong()), vpeer_id))
// ChatDialog::chatFriend(vpeer_id);
// }
//
// void FriendList::unsubscribeToLobby()
// {
// std::string lobby_id = qobject_cast<QAction*>(sender())->data().toString().toStdString();
//
// if (lobby_id.empty())
// return;
//
// std::string vpeer_id ;
// rsMsgs->getVirtualPeerId (ChatLobbyId(QString::fromStdString(lobby_id).toULongLong()), vpeer_id);
//
// if (QMessageBox::Ok == QMessageBox::question(this,tr("Unsubscribe to lobby"),tr("You are about to unsubscribe a chat lobby<br>You can only re-enter if your friends invite you again."),QMessageBox::Ok | QMessageBox::Cancel))
// rsMsgs->unsubscribeChatLobby(ChatLobbyId(QString::fromStdString(lobby_id).toULongLong())) ;
//
// // we should also close existing windows.
// ChatDialog::closeChat(vpeer_id);
// }
2011-12-27 08:47:37 -05:00
2014-03-17 16:56:06 -04:00
void FriendList : : getSslIdsFromItem ( QTreeWidgetItem * item , std : : list < RsPeerId > & sslIds )
2011-11-23 17:10:37 -05:00
{
2012-01-27 15:53:17 -05:00
if ( item = = NULL ) {
2011-11-23 17:10:37 -05:00
return ;
}
2012-01-27 15:53:17 -05:00
std : : string peerId = getRsId ( item ) ;
switch ( item - > type ( ) ) {
case TYPE_SSL :
2014-03-17 16:56:06 -04:00
sslIds . push_back ( RsPeerId ( peerId ) ) ;
2012-01-27 15:53:17 -05:00
break ;
case TYPE_GPG :
2014-03-17 16:56:06 -04:00
rsPeers - > getAssociatedSSLIds ( RsPgpId ( peerId ) , sslIds ) ;
2012-01-27 15:53:17 -05:00
break ;
case TYPE_GROUP :
{
RsGroupInfo groupInfo ;
if ( rsPeers - > getGroupInfo ( peerId , groupInfo ) ) {
2015-04-17 17:36:22 -04:00
std : : set < RsPgpId > : : iterator gpgIt ;
2012-01-27 15:53:17 -05:00
for ( gpgIt = groupInfo . peerIds . begin ( ) ; gpgIt ! = groupInfo . peerIds . end ( ) ; + + gpgIt ) {
rsPeers - > getAssociatedSSLIds ( * gpgIt , sslIds ) ;
}
}
}
break ;
2011-11-23 17:10:37 -05:00
}
2012-01-27 15:53:17 -05:00
}
2011-10-20 18:48:50 -04:00
void FriendList : : addToGroup ( )
{
QTreeWidgetItem * c = getCurrentPeer ( ) ;
if ( c = = NULL ) {
return ;
}
if ( c - > type ( ) ! = TYPE_GPG ) {
// wrong type
return ;
}
std : : string groupId = qobject_cast < QAction * > ( sender ( ) ) - > data ( ) . toString ( ) . toStdString ( ) ;
2014-03-17 16:56:06 -04:00
RsPgpId gpgId ( getRsId ( c ) ) ;
2011-10-20 18:48:50 -04:00
2014-03-17 16:56:06 -04:00
if ( gpgId . isNull ( ) | | groupId . empty ( ) ) {
2011-10-20 18:48:50 -04:00
return ;
}
// automatically expand the group, the peer is added to
addGroupToExpand ( groupId ) ;
// add to group
rsPeers - > assignPeerToGroup ( groupId , gpgId , true ) ;
}
void FriendList : : moveToGroup ( )
{
QTreeWidgetItem * c = getCurrentPeer ( ) ;
if ( c = = NULL ) {
return ;
}
if ( c - > type ( ) ! = TYPE_GPG ) {
// wrong type
return ;
}
std : : string groupId = qobject_cast < QAction * > ( sender ( ) ) - > data ( ) . toString ( ) . toStdString ( ) ;
2014-03-17 16:56:06 -04:00
RsPgpId gpgId ( getRsId ( c ) ) ;
2011-10-20 18:48:50 -04:00
2014-03-17 16:56:06 -04:00
if ( gpgId . isNull ( ) | | groupId . empty ( ) ) {
2011-10-20 18:48:50 -04:00
return ;
}
// remove from all groups
rsPeers - > assignPeerToGroup ( " " , gpgId , false ) ;
// automatically expand the group, the peer is added to
addGroupToExpand ( groupId ) ;
// add to group
rsPeers - > assignPeerToGroup ( groupId , gpgId , true ) ;
}
void FriendList : : removeFromGroup ( )
{
QTreeWidgetItem * c = getCurrentPeer ( ) ;
if ( c = = NULL ) {
return ;
}
if ( c - > type ( ) ! = TYPE_GPG ) {
// wrong type
return ;
}
std : : string groupId = qobject_cast < QAction * > ( sender ( ) ) - > data ( ) . toString ( ) . toStdString ( ) ;
2014-03-17 16:56:06 -04:00
RsPgpId gpgId ( getRsId ( c ) ) ;
2011-10-20 18:48:50 -04:00
2014-03-17 16:56:06 -04:00
if ( gpgId . isNull ( ) ) {
2011-10-20 18:48:50 -04:00
return ;
}
// remove from (all) group(s)
rsPeers - > assignPeerToGroup ( groupId , gpgId , false ) ;
}
void FriendList : : editGroup ( )
{
QTreeWidgetItem * c = getCurrentPeer ( ) ;
if ( c = = NULL ) {
return ;
}
if ( c - > type ( ) ! = TYPE_GROUP ) {
// wrong type
return ;
}
std : : string groupId = getRsId ( c ) ;
if ( groupId . empty ( ) ) {
return ;
}
CreateGroup editGrpDialog ( groupId , this ) ;
editGrpDialog . exec ( ) ;
}
void FriendList : : removeGroup ( )
{
QTreeWidgetItem * c = getCurrentPeer ( ) ;
if ( c = = NULL ) {
return ;
}
if ( c - > type ( ) ! = TYPE_GROUP ) {
// wrong type
return ;
}
std : : string groupId = getRsId ( c ) ;
if ( groupId . empty ( ) ) {
return ;
}
rsPeers - > removeGroup ( groupId ) ;
}
2011-11-11 20:26:26 -05:00
void FriendList : : setHideUnconnected ( bool hidden )
{
2011-10-20 18:48:50 -04:00
if ( mHideUnconnected ! = hidden ) {
mHideUnconnected = hidden ;
insertPeers ( ) ;
}
}
2011-11-11 20:26:26 -05:00
void FriendList : : setShowStatusColumn ( bool show )
2011-10-20 18:48:50 -04:00
{
2011-11-11 20:26:26 -05:00
ui - > actionHideState - > setEnabled ( ! show ) ;
bool isColumnVisible = ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_STATE ) ;
2011-10-20 18:48:50 -04:00
2011-11-11 20:26:26 -05:00
if ( isColumnVisible ! = show ) {
ui - > peerTreeWidget - > setColumnHidden ( COLUMN_STATE , ! show ) ;
2011-10-20 18:48:50 -04:00
2011-11-11 20:26:26 -05:00
updateHeader ( ) ;
2011-10-20 18:48:50 -04:00
insertPeers ( ) ;
}
}
2011-11-11 20:26:26 -05:00
void FriendList : : setShowLastContactColumn ( bool show )
2011-10-20 18:48:50 -04:00
{
2011-11-11 20:26:26 -05:00
bool isColumnVisible = ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_LAST_CONTACT ) ;
2011-10-20 18:48:50 -04:00
2011-11-11 20:26:26 -05:00
if ( isColumnVisible ! = show ) {
ui - > peerTreeWidget - > setColumnHidden ( COLUMN_LAST_CONTACT , ! show ) ;
2011-10-24 12:10:24 -04:00
2011-11-11 20:26:26 -05:00
updateHeader ( ) ;
insertPeers ( ) ;
}
}
2013-07-04 16:11:36 -04:00
void FriendList : : setShowIPColumn ( bool show )
{
bool isColumnVisible = ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_IP ) ;
if ( isColumnVisible ! = show ) {
ui - > peerTreeWidget - > setColumnHidden ( COLUMN_IP , ! show ) ;
updateHeader ( ) ;
insertPeers ( ) ;
}
}
2011-11-11 20:26:26 -05:00
void FriendList : : setShowAvatarColumn ( bool show )
{
bool isColumnVisible = ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_AVATAR ) ;
if ( isColumnVisible = = show )
2011-10-24 12:10:24 -04:00
return ;
2011-11-11 20:26:26 -05:00
ui - > peerTreeWidget - > setColumnHidden ( COLUMN_AVATAR , ! show ) ;
2011-10-24 12:10:24 -04:00
2011-11-11 20:26:26 -05:00
updateHeader ( ) ;
2014-11-20 20:54:21 -05:00
initializeHeader ( true ) ;
2011-10-24 12:10:24 -04:00
insertPeers ( ) ;
2011-10-20 18:48:50 -04:00
}
void FriendList : : setHideState ( bool hidden )
{
if ( mHideState ! = hidden ) {
mHideState = hidden ;
insertPeers ( ) ;
}
}
/**
2011-11-11 20:26:26 -05:00
* Set the header visible .
2011-10-20 18:48:50 -04:00
*/
2011-11-11 20:26:26 -05:00
void FriendList : : updateHeader ( )
2011-10-20 18:48:50 -04:00
{
2013-07-04 16:11:36 -04:00
if ( ui - > peerTreeWidget - > isColumnHidden ( COLUMN_STATE ) \
& & ui - > peerTreeWidget - > isColumnHidden ( COLUMN_LAST_CONTACT ) \
& & ui - > peerTreeWidget - > isColumnHidden ( COLUMN_IP ) ) {
2011-11-11 20:26:26 -05:00
ui - > peerTreeWidget - > setHeaderHidden ( true ) ;
2014-12-23 20:40:08 -05:00
initializeHeader ( true ) ;
2011-10-20 18:48:50 -04:00
} else {
2011-11-11 20:26:26 -05:00
ui - > peerTreeWidget - > setHeaderHidden ( false ) ;
2011-10-20 18:48:50 -04:00
}
}
2011-11-11 20:26:26 -05:00
void FriendList : : setSortByName ( )
2011-10-20 18:48:50 -04:00
{
2011-11-11 20:26:26 -05:00
ui - > peerTreeWidget - > sortByColumn ( COLUMN_NAME ) ;
sortPeersAscendingOrder ( ) ;
2011-10-20 18:48:50 -04:00
}
2011-11-11 20:26:26 -05:00
void FriendList : : setSortByState ( )
2011-10-20 18:48:50 -04:00
{
2011-11-11 20:26:26 -05:00
ui - > peerTreeWidget - > sortByColumn ( COLUMN_STATE ) ;
sortPeersAscendingOrder ( ) ;
2011-10-20 18:48:50 -04:00
}
2011-11-11 20:26:26 -05:00
void FriendList : : setSortByLastContact ( )
2011-10-20 18:48:50 -04:00
{
2011-11-11 20:26:26 -05:00
ui - > peerTreeWidget - > sortByColumn ( COLUMN_LAST_CONTACT ) ;
sortPeersDescendingOrder ( ) ;
2011-10-20 18:48:50 -04:00
}
2013-07-04 16:11:36 -04:00
void FriendList : : setSortByIP ( )
{
ui - > peerTreeWidget - > sortByColumn ( COLUMN_IP ) ;
sortPeersDescendingOrder ( ) ;
}
2011-11-11 20:26:26 -05:00
void FriendList : : sortPeersAscendingOrder ( )
2011-10-20 18:48:50 -04:00
{
2011-11-11 20:26:26 -05:00
ui - > peerTreeWidget - > sortByColumn ( ui - > peerTreeWidget - > sortColumn ( ) , Qt : : AscendingOrder ) ;
2011-10-20 18:48:50 -04:00
}
2011-11-11 20:26:26 -05:00
void FriendList : : sortPeersDescendingOrder ( )
2011-10-20 18:48:50 -04:00
{
2011-11-11 20:26:26 -05:00
ui - > peerTreeWidget - > sortByColumn ( ui - > peerTreeWidget - > sortColumn ( ) , Qt : : DescendingOrder ) ;
2011-10-20 18:48:50 -04:00
}
2011-11-11 20:26:26 -05:00
void FriendList : : setRootIsDecorated ( bool show )
2011-10-20 18:48:50 -04:00
{
2011-11-11 20:26:26 -05:00
ui - > peerTreeWidget - > setRootIsDecorated ( show ) ;
2011-10-20 18:48:50 -04:00
}
2011-11-11 20:26:26 -05:00
void FriendList : : setShowGroups ( bool show )
2011-10-20 18:48:50 -04:00
{
2011-11-11 20:26:26 -05:00
if ( mShowGroups ! = show ) {
mShowGroups = show ;
if ( mShowGroups ) {
// remove all not assigned gpg ids
int childCount = ui - > peerTreeWidget - > topLevelItemCount ( ) ;
int childIndex = 0 ;
while ( childIndex < childCount ) {
QTreeWidgetItem * item = ui - > peerTreeWidget - > topLevelItem ( childIndex ) ;
if ( item - > type ( ) = = TYPE_GPG ) {
delete ( ui - > peerTreeWidget - > takeTopLevelItem ( childIndex ) ) ;
childCount = ui - > peerTreeWidget - > topLevelItemCount ( ) ;
continue ;
}
2014-10-21 18:33:02 -04:00
+ + childIndex ;
2011-11-11 20:26:26 -05:00
}
}
2011-10-20 18:48:50 -04:00
insertPeers ( ) ;
}
}
/**
* If set to true , the customStateString will be shwon in all gpg peer items ,
* not only in the ssl ids ( used in MessengerWindow ) .
* These items will then be doublespaced .
*/
void FriendList : : setBigName ( bool bigName )
{
if ( mBigName ! = bigName ) {
mBigName = bigName ;
// Change the size of the already existing items
QSize newSize ;
if ( mBigName ) {
newSize . setHeight ( 40 ) ;
newSize . setWidth ( 40 ) ;
} else {
newSize . setHeight ( 26 ) ;
newSize . setWidth ( 26 ) ;
}
QTreeWidgetItemIterator it ( ui - > peerTreeWidget ) ;
while ( * it ) {
if ( ( * it ) - > type ( ) = = TYPE_GPG ) {
( * it ) - > setSizeHint ( COLUMN_NAME , newSize ) ;
}
2014-10-21 18:33:02 -04:00
+ + it ;
2011-10-20 18:48:50 -04:00
}
}
}
/**
* Hides all items that don ' t contain sPattern in the name column .
*/
2012-04-05 17:03:03 -04:00
void FriendList : : filterItems ( const QString & text )
2011-10-20 18:48:50 -04:00
{
2012-04-05 17:03:03 -04:00
filterText = text ;
int count = ui - > peerTreeWidget - > topLevelItemCount ( ) ;
2014-10-21 18:33:02 -04:00
for ( int index = 0 ; index < count ; + + index ) {
2012-04-05 17:03:03 -04:00
FriendList : : filterItem ( ui - > peerTreeWidget - > topLevelItem ( index ) , filterText ) ;
2011-10-20 18:48:50 -04:00
}
QTreeWidgetItem * c = getCurrentPeer ( ) ;
if ( c & & c - > isHidden ( ) ) {
// active item is hidden, deselect it
ui - > peerTreeWidget - > setCurrentItem ( NULL ) ;
}
}
2012-04-05 17:03:03 -04:00
bool FriendList : : filterItem ( QTreeWidgetItem * item , const QString & text )
2011-10-20 18:48:50 -04:00
{
2012-04-05 17:03:03 -04:00
bool visible = true ;
2011-10-20 18:48:50 -04:00
2012-04-05 17:03:03 -04:00
if ( text . isEmpty ( ) = = false ) {
if ( item - > text ( 0 ) . contains ( text , Qt : : CaseInsensitive ) = = false ) {
visible = false ;
2011-10-20 18:48:50 -04:00
}
}
2012-04-05 17:03:03 -04:00
int visibleChildCount = 0 ;
int count = item - > childCount ( ) ;
2014-10-21 18:33:02 -04:00
for ( int index = 0 ; index < count ; + + index ) {
2012-04-05 17:03:03 -04:00
if ( FriendList : : filterItem ( item - > child ( index ) , text ) ) {
2014-10-21 18:33:02 -04:00
+ + visibleChildCount ;
2011-10-20 18:48:50 -04:00
}
}
2012-04-05 17:03:03 -04:00
if ( visible | | visibleChildCount ) {
item - > setHidden ( false ) ;
2011-10-20 18:48:50 -04:00
} else {
2012-04-05 17:03:03 -04:00
item - > setHidden ( true ) ;
2011-10-20 18:48:50 -04:00
}
2012-04-05 17:03:03 -04:00
return ( visible | | visibleChildCount ) ;
2011-10-20 18:48:50 -04:00
}
/**
* Add a groupId to the openGroups list . These groups
* will be expanded , when they ' re added to the QTreeWidget
*/
void FriendList : : addGroupToExpand ( const std : : string & groupId )
{
if ( openGroups = = NULL ) {
openGroups = new std : : set < std : : string > ;
}
openGroups - > insert ( groupId ) ;
}
/**
* Add a gpgId to the openPeers list . These peers
* will be expanded , when they ' re added to the QTreeWidget
*/
void FriendList : : addPeerToExpand ( const std : : string & gpgId )
{
if ( openPeers = = NULL ) {
openPeers = new std : : set < std : : string > ;
}
openPeers - > insert ( gpgId ) ;
}
2011-11-11 20:26:26 -05:00
2013-08-30 08:24:39 -04:00
void FriendList : : createDisplayMenu ( )
2011-11-11 20:26:26 -05:00
{
QMenu * displayMenu = new QMenu ( this ) ;
connect ( displayMenu , SIGNAL ( aboutToShow ( ) ) , this , SLOT ( updateMenu ( ) ) ) ;
2013-07-16 18:33:45 -04:00
// displayMenu->addAction(ui->actionSortPeersDescendingOrder);
// displayMenu->addAction(ui->actionSortPeersAscendingOrder);
2011-11-11 20:26:26 -05:00
QMenu * menu = displayMenu - > addMenu ( tr ( " Columns " ) ) ;
menu - > addAction ( ui - > actionShowAvatarColumn ) ;
menu - > addAction ( ui - > actionShowLastContactColumn ) ;
2013-07-04 16:11:36 -04:00
menu - > addAction ( ui - > actionShowIPColumn ) ;
2015-05-03 05:15:42 -04:00
menu - > addAction ( ui - > actionShowStatusColumn ) ;
2014-11-21 07:10:26 -05:00
menu = displayMenu - > addMenu ( tr ( " Sort by " ) ) ;
2013-07-16 18:33:45 -04:00
// menu->addAction(ui->actionSortByName);
2014-11-21 07:10:26 -05:00
menu - > addAction ( ui - > actionSortByState ) ;
2013-07-16 18:33:45 -04:00
// menu->addAction(ui->actionSortByLastContact);
// menu->addAction(ui->actionSortByIP);
2011-11-11 20:26:26 -05:00
displayMenu - > addAction ( ui - > actionHideOfflineFriends ) ;
displayMenu - > addAction ( ui - > actionHideState ) ;
2013-07-16 18:33:45 -04:00
// displayMenu->addAction(ui->actionRootIsDecorated);
2011-11-11 20:26:26 -05:00
displayMenu - > addAction ( ui - > actionShowGroups ) ;
2014-11-21 07:10:26 -05:00
QActionGroup * group = new QActionGroup ( this ) ;
2013-07-16 18:33:45 -04:00
// group->addAction(ui->actionSortByName);
2014-11-21 07:10:26 -05:00
group - > addAction ( ui - > actionSortByState ) ;
2013-07-16 18:33:45 -04:00
// group->addAction(ui->actionSortByLastContact);
// group->addAction(ui->actionSortByIP);
2011-11-11 20:26:26 -05:00
2013-08-30 08:24:39 -04:00
ui - > displayButton - > setMenu ( displayMenu ) ;
2011-11-11 20:26:26 -05:00
}
void FriendList : : updateMenu ( )
{
switch ( ui - > peerTreeWidget - > sortColumn ( ) ) {
case COLUMN_NAME :
ui - > actionSortByName - > setChecked ( true ) ;
break ;
case COLUMN_STATE :
ui - > actionSortByState - > setChecked ( true ) ;
break ;
case COLUMN_LAST_CONTACT :
ui - > actionSortByLastContact - > setChecked ( true ) ;
break ;
2013-07-04 16:11:36 -04:00
case COLUMN_IP :
ui - > actionSortByIP - > setChecked ( true ) ;
break ;
2011-11-11 20:26:26 -05:00
case COLUMN_AVATAR :
break ;
}
ui - > actionShowStatusColumn - > setChecked ( ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_STATE ) ) ;
ui - > actionShowLastContactColumn - > setChecked ( ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_LAST_CONTACT ) ) ;
2013-07-04 16:11:36 -04:00
ui - > actionShowIPColumn - > setChecked ( ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_IP ) ) ;
2011-11-11 20:26:26 -05:00
ui - > actionShowAvatarColumn - > setChecked ( ! ui - > peerTreeWidget - > isColumnHidden ( COLUMN_AVATAR ) ) ;
ui - > actionHideOfflineFriends - > setChecked ( mHideUnconnected ) ;
ui - > actionHideState - > setChecked ( mHideState ) ;
ui - > actionRootIsDecorated - > setChecked ( ui - > peerTreeWidget - > rootIsDecorated ( ) ) ;
ui - > actionShowGroups - > setChecked ( mShowGroups ) ;
}