~ubuntu-branches/ubuntu/saucy/kopete/saucy-proposed

« back to all changes in this revision

Viewing changes to kopete/config/accounts/kopeteaccountconfig.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-06-21 02:22:39 UTC
  • Revision ID: package-import@ubuntu.com-20130621022239-63l3zc8p0nf26pt6
Tags: upstream-4.10.80
ImportĀ upstreamĀ versionĀ 4.10.80

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
    accountconfig.cpp  -  Kopete account config page
 
3
 
 
4
    Copyright (c) 2007      by Gustavo Pichorim Boiko <gustavo.boiko@kdemail.net>
 
5
    Copyright (c) 2003-2007 by Olivier Goffart        <ogoffart@kde.org>
 
6
    Copyright (c) 2003      by Martijn Klingens       <klingens@kde.org>
 
7
    Copyright (c) 2007      by Will Stephenson        <wstephenson@kde.org>
 
8
 
 
9
    Kopete    (c) 2003-2007 by the Kopete developers  <kopete-devel@kde.org>
 
10
 
 
11
    *************************************************************************
 
12
    *                                                                       *
 
13
    * This program is free software; you can redistribute it and/or modify  *
 
14
    * it under the terms of the GNU General Public License as published by  *
 
15
    * the Free Software Foundation; either version 2 of the License, or     *
 
16
    * (at your option) any later version.                                   *
 
17
    *                                                                       *
 
18
    *************************************************************************
 
19
*/
 
20
 
 
21
#include "kopeteaccountconfig.h"
 
22
 
 
23
#include <QtGui/QCheckBox>
 
24
#include <QtGui/QLayout>
 
25
#include <QtGui/QHeaderView>
 
26
#include <QtGui/QBoxLayout>
 
27
#include <QtCore/QPointer>
 
28
#include <QtCore/QTimer>
 
29
#include <QtGui/QContextMenuEvent>
 
30
 
 
31
#include <kcolorbutton.h>
 
32
#include <kpushbutton.h>
 
33
#include <kdebug.h>
 
34
#include <kdialog.h>
 
35
#include <kpluginfactory.h>
 
36
#include <kiconloader.h>
 
37
#include <klocale.h>
 
38
#include <kmessagebox.h>
 
39
#include <kicon.h>
 
40
#include <kaction.h>
 
41
#include <kmenu.h>
 
42
#include <kcolordialog.h>
 
43
 
 
44
#include "addaccountwizard.h"
 
45
#include "editaccountwidget.h"
 
46
#include "kopeteaccountmanager.h"
 
47
#include "kopeteidentitymanager.h"
 
48
#include "kopeteidentity.h"
 
49
#include "kopeteprotocol.h"
 
50
#include "kopeteaccount.h"
 
51
#include "kopetecontact.h"
 
52
#include "accountidentitydialog.h"
 
53
#include "identitydialog.h"
 
54
 
 
55
 
 
56
K_PLUGIN_FACTORY( KopeteAccountConfigFactory,
 
57
                registerPlugin<KopeteAccountConfig>(); )
 
58
K_EXPORT_PLUGIN( KopeteAccountConfigFactory("kcm_kopete_accountconfig") )
 
59
 
 
60
KopeteAccountConfig::KopeteAccountConfig( QWidget *parent, const QVariantList &args )
 
61
: KCModule( KopeteAccountConfigFactory::componentData(), parent, args )
 
62
{
 
63
        setupUi( this );
 
64
 
 
65
        QHeaderView *header = mAccountList->header();
 
66
        header->setResizeMode( 1, QHeaderView::ResizeToContents );
 
67
        header->setResizeMode( 0, QHeaderView::Stretch );
 
68
        header->setVisible(false);
 
69
        
 
70
        configureActions();
 
71
        configureMenus();
 
72
 
 
73
        connect( mAccountList,  SIGNAL(itemPositionChanged()), this, SLOT(changed()) );
 
74
        connect( mAccountList,  SIGNAL(itemSelectionChanged()), this, SLOT(slotItemSelected()) );
 
75
        connect( mAccountList,  SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)), this, SLOT(slotModify()) );
 
76
        connect( mAccountList,  SIGNAL(itemChanged(QTreeWidgetItem*,int)), this, SLOT(slotItemChanged(QTreeWidgetItem*)) );
 
77
        connect( mAccountList,  SIGNAL(itemClicked(QTreeWidgetItem*,int)), this, SLOT(slotItemClicked(QTreeWidgetItem*,int)) );
 
78
 
 
79
        // this ensures that newly created accounts are assigned to the selected identity
 
80
        connect( Kopete::AccountManager::self(), SIGNAL(accountRegistered(Kopete::Account*)), this, SLOT(slotAccountAdded(Kopete::Account*)) );
 
81
    connect( Kopete::AccountManager::self(), SIGNAL(accountUnregistered(const Kopete::Account*)), this, SLOT(slotAccountRemoved(const Kopete::Account*)) );
 
82
 
 
83
        mAccountList->installEventFilter( this );
 
84
 
 
85
        setButtons( Help );
 
86
        load();
 
87
}
 
88
 
 
89
KopeteAccountLVI* KopeteAccountConfig::selectedAccount()
 
90
{
 
91
        QList<QTreeWidgetItem*> selectedItems = mAccountList->selectedItems();
 
92
        if(!selectedItems.empty())
 
93
                return dynamic_cast<KopeteAccountLVI*>( selectedItems.first() );
 
94
        return 0;
 
95
}
 
96
 
 
97
KopeteIdentityLVI* KopeteAccountConfig::selectedIdentity()
 
98
{
 
99
        QList<QTreeWidgetItem*> selectedItems = mAccountList->selectedItems();
 
100
        if(!selectedItems.empty())
 
101
                return dynamic_cast<KopeteIdentityLVI*>( selectedItems.first() );
 
102
        return 0;
 
103
}
 
104
 
 
105
void KopeteAccountConfig::save()
 
106
{
 
107
        uint priority = 0;
 
108
        for ( int i = 0; i < mAccountList->topLevelItemCount(); i++ )
 
109
                priority += mAccountList->topLevelItem( i )->childCount();
 
110
                        
 
111
        for ( int i = 0; i < mAccountList->topLevelItemCount(); i++ )
 
112
        {
 
113
                KopeteIdentityLVI* identity = dynamic_cast<KopeteIdentityLVI*>( mAccountList->topLevelItem( i ) );
 
114
                for ( int j = 0; j < identity->childCount(); j++ )
 
115
                {
 
116
                        KopeteAccountLVI* account = dynamic_cast<KopeteAccountLVI*>( identity->child( j ) );
 
117
                        account->account()->setIdentity( identity->identity() );
 
118
                        account->account()->setPriority( priority-- );
 
119
                }
 
120
        }
 
121
 
 
122
        Kopete::AccountManager::self()->save();
 
123
        Kopete::IdentityManager::self()->save();
 
124
 
 
125
 
 
126
        //load(); //refresh the colred accounts (in case of apply)
 
127
}
 
128
 
 
129
bool accountPriorityLessThan(const Kopete::Account* a, const Kopete::Account* b)
 
130
{
 
131
        return (a->priority() > b->priority());
 
132
}
 
133
 
 
134
bool identityPriorityLessThan(const Kopete::Identity* a, const Kopete::Identity* b)
 
135
{
 
136
        if ( a->accounts().isEmpty() )
 
137
                return false;
 
138
        
 
139
        if ( b->accounts().isEmpty() && !a->accounts().isEmpty() )
 
140
                return true;
 
141
        
 
142
        return (a->accounts().first()->priority() > b->accounts().first()->priority());
 
143
}
 
144
 
 
145
void KopeteAccountConfig::load()
 
146
{
 
147
        mAccountList->clear();
 
148
 
 
149
        QHash<Kopete::Identity *,QTreeWidgetItem *> identityItemHash;
 
150
        Kopete::Identity *defaultIdentity = Kopete::IdentityManager::self()->defaultIdentity();
 
151
 
 
152
        // Sort by priority, the priority is take from identity accounts because identity doesn't have priority
 
153
        QList<Kopete::Identity*> identityList = Kopete::IdentityManager::self()->identities();
 
154
        qSort( identityList.begin(), identityList.end(), identityPriorityLessThan );
 
155
 
 
156
        foreach(Kopete::Identity *i, identityList)
 
157
        {
 
158
                //KopeteIdentityLVI *lvi = new KopeteIdentityLVI( i, mIdentityList );
 
159
                QTreeWidgetItem *identityItem = new KopeteIdentityLVI( i, mAccountList );
 
160
                // Insert the item after the previous one
 
161
                
 
162
                identityItem->setText( 0, i->label() );
 
163
                identityItem->setIcon( 0, KIcon( i->customIcon()) );
 
164
                
 
165
                identityItem->setExpanded( true );
 
166
                
 
167
                if (i == defaultIdentity)
 
168
                {
 
169
                        QFont font = identityItem->font( 0 );
 
170
                        font.setBold( true );
 
171
                        identityItem->setFont( 0, font );
 
172
                        identityItem->setSelected( true );
 
173
                }
 
174
                //identityItem->setSizeHint( 0, QSize(0, 42) );
 
175
                
 
176
                identityItemHash.insert(i,identityItem);
 
177
        }
 
178
 
 
179
        // Sort by priority
 
180
        QList<Kopete::Account*> accountList = Kopete::AccountManager::self()->accounts();
 
181
        qSort( accountList.begin(), accountList.end(), accountPriorityLessThan );
 
182
 
 
183
        foreach( Kopete::Account *account, accountList )
 
184
        {
 
185
                Kopete::Identity *idnt = account->identity();
 
186
                
 
187
                Q_ASSERT(identityItemHash.contains(idnt));
 
188
                KopeteAccountLVI *lvi = new KopeteAccountLVI( account, identityItemHash[idnt] );
 
189
                lvi->setText( 0, account->accountLabel() );
 
190
                lvi->setIcon( 0, account->myself()->onlineStatus().iconFor( account ) );
 
191
                QFont font = lvi->font( 0 );
 
192
                font.setBold( true );
 
193
                lvi->setFont( 0, font );
 
194
 
 
195
                lvi->setSizeHint( 0, QSize(0, 42) );
 
196
                
 
197
                lvi->setText( 1, account->myself()->onlineStatus().description() );
 
198
                lvi->setTextAlignment( 1, Qt::AlignRight | Qt::AlignVCenter );
 
199
                lvi->setFont( 1, font );
 
200
        
 
201
                lvi->setFlags( (lvi->flags() & ~Qt::ItemIsDropEnabled) | Qt::ItemIsUserCheckable );
 
202
                lvi->setCheckState ( 0, account->excludeConnect() ? Qt::Unchecked : Qt::Checked );
 
203
 
 
204
                connect( account->myself(), SIGNAL(onlineStatusChanged(Kopete::Contact*,Kopete::OnlineStatus,Kopete::OnlineStatus)),
 
205
                                 this, SLOT(slotOnlineStatusChanged(Kopete::Contact*,Kopete::OnlineStatus,Kopete::OnlineStatus)));
 
206
        }
 
207
 
 
208
        changed( false );
 
209
        slotItemSelected();
 
210
}
 
211
 
 
212
void KopeteAccountConfig::slotItemSelected()
 
213
{
 
214
        bool accountSelected = selectedAccount();
 
215
        bool hasMultipleIdentities = ( Kopete::IdentityManager::self()->identities().size() > 1 );
 
216
        mButtonAccountModify->setEnabled( accountSelected );
 
217
        mButtonAccountRemove->setEnabled( accountSelected );
 
218
        m_actionAccountSwitchIdentity->setEnabled( accountSelected && hasMultipleIdentities );
 
219
        mButtonAccountSwitchIdentity->setEnabled( m_actionAccountSwitchIdentity->isEnabled() );
 
220
        mButtonAccountSetColor->setEnabled( accountSelected );
 
221
 
 
222
        bool identitySelected = selectedIdentity();
 
223
        bool isDefaultIdentity = (identitySelected && Kopete::IdentityManager::self()->defaultIdentity() == selectedIdentity()->identity());
 
224
        mButtonAccountAdd->setEnabled( identitySelected );
 
225
        mButtonIdentityCopy->setEnabled( identitySelected );
 
226
        mButtonIdentityModify->setEnabled( identitySelected );
 
227
        m_actionIdentityRemove->setEnabled( identitySelected && !isDefaultIdentity );
 
228
        mButtonIdentityRemove->setEnabled( m_actionIdentityRemove->isEnabled() );
 
229
        m_actionIdentitySetDefault->setEnabled( identitySelected && !isDefaultIdentity );
 
230
        mButtonIdentitySetDefault->setEnabled( m_actionIdentitySetDefault->isEnabled() );
 
231
}
 
232
 
 
233
void KopeteAccountConfig::slotAddAccount()
 
234
{
 
235
        AddAccountWizard *addwizard = new AddAccountWizard( this, true );
 
236
        KopeteIdentityLVI *ilvi = selectedIdentity();
 
237
        if (ilvi)
 
238
        {
 
239
                addwizard->setIdentity( ilvi->identity() );
 
240
        }
 
241
        addwizard->show();
 
242
}
 
243
 
 
244
void KopeteAccountConfig::slotModify()
 
245
{
 
246
        KopeteAccountLVI *alvi = selectedAccount();
 
247
        KopeteIdentityLVI *ilvi = selectedIdentity();
 
248
        
 
249
        if ( ilvi && ilvi->identity() )
 
250
                return modifyIdentity( ilvi->identity() );
 
251
 
 
252
        if ( alvi && alvi->account() )
 
253
                return modifyAccount( alvi->account() );
 
254
}
 
255
        
 
256
        
 
257
void KopeteAccountConfig::modifyAccount(Kopete::Account *account)
 
258
{
 
259
        Kopete::Protocol *proto = account->protocol();
 
260
 
 
261
        QPointer <KDialog> editDialog = new KDialog( this );
 
262
        editDialog->setCaption( i18n("Modify Account" ) );
 
263
        editDialog->setButtons( KDialog::Ok | KDialog::Cancel );
 
264
        editDialog->setDefaultButton(KDialog::Ok);
 
265
        editDialog->showButtonSeparator(true);
 
266
 
 
267
        KopeteEditAccountWidget *m_accountWidget = proto->createEditAccountWidget( account, editDialog );
 
268
        if ( !m_accountWidget )
 
269
                return;
 
270
 
 
271
        // FIXME: Why the #### is EditAccountWidget not a QWidget?!? This sideways casting
 
272
        //        is braindead and error-prone. Looking at MSN the only reason I can see is
 
273
        //        because it allows direct subclassing of designer widgets. But what is
 
274
        //        wrong with embedding the designer widget in an empty QWidget instead?
 
275
        //        Also, if this REALLY has to be a pure class and not a widget, then the
 
276
        //        class should at least be renamed to EditAccountIface instead - Martijn
 
277
        QWidget *w = dynamic_cast<QWidget *>( m_accountWidget );
 
278
        if ( !w )
 
279
                return;
 
280
 
 
281
        editDialog->setMainWidget( w );
 
282
        if ( editDialog->exec() == QDialog::Accepted )
 
283
        {
 
284
                if( m_accountWidget->validateData() )
 
285
                        m_accountWidget->apply();
 
286
        }
 
287
        delete editDialog;
 
288
 
 
289
        load();
 
290
        Kopete::AccountManager::self()->save();
 
291
}
 
292
 
 
293
void KopeteAccountConfig::modifyIdentity(Kopete::Identity *)
 
294
{
 
295
        KopeteIdentityLVI *lvi = selectedIdentity();
 
296
        
 
297
        if ( !lvi || !lvi->identity() )
 
298
                return;
 
299
 
 
300
        Kopete::Identity *ident = lvi->identity();
 
301
 
 
302
        QPointer <IdentityDialog> dialog = new IdentityDialog(ident, this);
 
303
        dialog->exec();
 
304
        delete dialog;
 
305
 
 
306
        load();
 
307
        Kopete::IdentityManager::self()->save();
 
308
}
 
309
 
 
310
void KopeteAccountConfig::removeAccount()
 
311
{
 
312
        KopeteAccountLVI *lvi = selectedAccount();
 
313
        
 
314
        if ( lvi && lvi->account() ) {
 
315
                Kopete::Account *i = lvi->account();
 
316
                if ( KMessageBox::warningContinueCancel( this, i18n( "Are you sure you want to remove the account \"%1\"?", i->accountLabel() ),
 
317
                                        i18n( "Remove Account" ), KGuiItem(i18n( "Remove Account" ), "edit-delete"), KStandardGuiItem::cancel(),
 
318
                                        QString(), KMessageBox::Notify | KMessageBox::Dangerous ) == KMessageBox::Continue )
 
319
                {
 
320
                        Kopete::AccountManager::self()->removeAccount( i );
 
321
                }
 
322
        }
 
323
}
 
324
 
 
325
void KopeteAccountConfig::removeIdentity()
 
326
{
 
327
        KopeteIdentityLVI *lvi = selectedIdentity();
 
328
        Kopete::Identity *i;
 
329
        
 
330
        if ( lvi && ( i = lvi->identity() ) ) {
 
331
                if (!i->accounts().count())
 
332
                {
 
333
                        if ( KMessageBox::warningContinueCancel( this, i18n( "Are you sure you want to remove the identity \"%1\"?", i->label() ),
 
334
                                                i18n( "Remove Identity" ), KGuiItem(i18n( "Remove Identity" ), "edit-delete"), KStandardGuiItem::cancel(),
 
335
                                                "askRemoveIdentity", KMessageBox::Notify | KMessageBox::Dangerous ) == KMessageBox::Continue )
 
336
                        {
 
337
                                Kopete::IdentityManager::self()->removeIdentity( i );
 
338
                                delete lvi;
 
339
                        }
 
340
                }
 
341
                else
 
342
                {
 
343
                        // if there are any accounts linked to this identity, need to change them before removing the identity
 
344
                        if ( AccountIdentityDialog::changeAccountIdentity( this, i->accounts(), i, 
 
345
                                                i18n("Before removing the identity %1, the following accounts must be " 
 
346
                                                        "assigned to another identity:", i->label())) )
 
347
                        {
 
348
                                Kopete::IdentityManager::self()->removeIdentity( i );
 
349
                                delete lvi;
 
350
                        }
 
351
                }
 
352
                // if we removed the default identity, this will trigger an update
 
353
                Kopete::IdentityManager::self()->defaultIdentity();
 
354
                save();
 
355
                // To be sure that accounts with relocated identities appear, reload
 
356
                load();
 
357
        }
 
358
}
 
359
 
 
360
void KopeteAccountConfig::slotAccountSwitchIdentity()
 
361
{
 
362
        KopeteAccountLVI *lvi = selectedAccount();
 
363
 
 
364
        if ( !lvi || !lvi->account() )
 
365
                return;
 
366
 
 
367
        // If there are only two identities, don't show the dialog,
 
368
        // just switch to the other identity
 
369
        Kopete::Account *a = lvi->account();
 
370
        if ( Kopete::IdentityManager::self()->identities().size() == 2 ) {
 
371
                foreach ( Kopete::Identity * id, Kopete::IdentityManager::self()->identities() ) {
 
372
                        if ( id != a->identity() ) {
 
373
                                a->setIdentity( id );
 
374
                                break;
 
375
                        }
 
376
                }
 
377
        } else {
 
378
                AccountIdentityDialog::changeAccountIdentity( this, a, 0, i18n("Select an identity for the account:"));
 
379
        }
 
380
 
 
381
        load();
 
382
}
 
383
 
 
384
void KopeteAccountConfig::slotAccountSetColor()
 
385
{
 
386
        KopeteAccountLVI *lvi = selectedAccount();
 
387
 
 
388
        if ( !lvi || !lvi->account() )
 
389
                return;
 
390
 
 
391
        Kopete::Account *a = lvi->account();
 
392
 
 
393
        QColor color = a->color();
 
394
 
 
395
        if ( KColorDialog::getColor(color, Qt::black, this) == KColorDialog::Accepted ) {
 
396
                a->setColor(color);
 
397
        }
 
398
 
 
399
        load();
 
400
}
 
401
 
 
402
void KopeteAccountConfig::slotSetDefaultIdentity()
 
403
{
 
404
        KopeteIdentityLVI *lvi = selectedIdentity();
 
405
        
 
406
        if ( !lvi || !lvi->identity() )
 
407
                return;
 
408
 
 
409
        Kopete::IdentityManager::self()->setDefaultIdentity( lvi->identity() );
 
410
        load();
 
411
}
 
412
 
 
413
void KopeteAccountConfig::slotAddIdentity()
 
414
{
 
415
        Kopete::Identity *ident = new Kopete::Identity(i18n("New Identity"));
 
416
 
 
417
        if (!ident)
 
418
                return;
 
419
 
 
420
        QPointer <IdentityDialog> dialog = new IdentityDialog(ident, this);
 
421
        if ( dialog->exec() == QDialog::Accepted ) {
 
422
                ident = Kopete::IdentityManager::self()->registerIdentity(ident);
 
423
                if (ident) {
 
424
                        Kopete::IdentityManager::self()->save();
 
425
                        load();
 
426
                }
 
427
        } else {
 
428
                delete ident;
 
429
        }
 
430
        delete dialog;
 
431
}
 
432
 
 
433
void KopeteAccountConfig::slotCopyIdentity()
 
434
{
 
435
        Kopete::Identity * existing = selectedIdentity()->identity();
 
436
        uint copyCount = 2;
 
437
        QString newLabel = i18nc( "String used for creating first copy of a named item",
 
438
                        "Copy of %1", existing->label() );
 
439
        Kopete::Identity::List ids = Kopete::IdentityManager::self()->identities();
 
440
        QStringList idLabels;
 
441
        foreach ( Kopete::Identity *i, ids ) {
 
442
                idLabels.append( i->label() );
 
443
        }
 
444
        while ( idLabels.contains( newLabel ) && copyCount < 100 ) {
 
445
                newLabel = i18nc( "String used for creating second and subsequent copies of a named item",
 
446
                        "Copy %1 of %2", copyCount++, existing->label() );
 
447
        }
 
448
        Kopete::Identity * ident = existing->clone();
 
449
        ident->setLabel( newLabel );
 
450
 
 
451
        QPointer <IdentityDialog> dialog = new IdentityDialog(ident, this);
 
452
        if ( dialog->exec() == QDialog::Accepted ) {
 
453
                if ( Kopete::IdentityManager::self()->registerIdentity(ident) ) {
 
454
                        load();
 
455
                }
 
456
        } else {
 
457
                delete ident;
 
458
        }
 
459
        delete dialog;
 
460
}
 
461
 
 
462
void KopeteAccountConfig::slotOnlineStatusChanged( Kopete::Contact *contact,
 
463
                                                                                                   const Kopete::OnlineStatus &newStatus, 
 
464
                                                                                                   const Kopete::OnlineStatus &/*oldStatus*/)
 
465
{
 
466
        //get all items
 
467
        QList<QTreeWidgetItem*> items = mAccountList->findItems("", Qt::MatchContains | Qt::MatchRecursive);
 
468
        QList<QTreeWidgetItem*>::iterator it;
 
469
        for (it = items.begin(); it != items.end(); ++it)
 
470
        {
 
471
                KopeteAccountLVI *i = dynamic_cast<KopeteAccountLVI*>(*it);
 
472
                if (!i || !i->account())
 
473
                        continue;
 
474
 
 
475
                if (i->account()->myself() == contact)
 
476
                {
 
477
                        (*it)->setIcon( 0, newStatus.iconFor(i->account()) );
 
478
                        (*it)->setText( 1, newStatus.description() );
 
479
                        break;
 
480
                }
 
481
        }
 
482
 
 
483
}
 
484
 
 
485
void KopeteAccountConfig::slotAccountAdded( Kopete::Account * account )
 
486
{
 
487
        save();
 
488
        load();
 
489
}
 
490
 
 
491
void KopeteAccountConfig::slotAccountRemoved( const Kopete::Account * account )
 
492
{
 
493
        QList<QTreeWidgetItem*> items = mAccountList->findItems("", Qt::MatchContains | Qt::MatchRecursive);
 
494
        QList<QTreeWidgetItem*>::iterator it;
 
495
        for (it = items.begin(); it != items.end(); ++it)
 
496
        {
 
497
                KopeteAccountLVI *lvi = dynamic_cast<KopeteAccountLVI*>(*it);
 
498
                if ( lvi && lvi->account() == account)
 
499
                {
 
500
                        delete lvi;
 
501
                        break;
 
502
                }
 
503
        }
 
504
}
 
505
 
 
506
void KopeteAccountConfig::slotItemChanged(QTreeWidgetItem* item)
 
507
{
 
508
        if(!item)
 
509
                return;
 
510
        KopeteAccountLVI *a = dynamic_cast<KopeteAccountLVI*>(item);
 
511
        KopeteIdentityLVI *i = dynamic_cast<KopeteIdentityLVI*>(item->parent());
 
512
        if(a && i)
 
513
        {
 
514
                if(a->account()->identity() != i->identity() )
 
515
                {
 
516
                        a->account()->setIdentity( i->identity() );
 
517
                        changed(true);
 
518
                }
 
519
        }
 
520
}
 
521
 
 
522
bool KopeteAccountConfig::eventFilter( QObject *obj, QEvent *event )
 
523
{
 
524
        if ( obj == mAccountList && event->type() == QEvent::ContextMenu )
 
525
        {
 
526
                QContextMenuEvent *cmEvent = static_cast<QContextMenuEvent *>(event);
 
527
                KopeteIdentityLVI *ilvi = selectedIdentity();
 
528
                if ( ilvi && ilvi->identity() )
 
529
                {
 
530
                        m_identityContextMenu->popup(cmEvent->globalPos());
 
531
                }
 
532
 
 
533
                KopeteAccountLVI *alvi = selectedAccount();
 
534
                if ( alvi && alvi->account() )
 
535
                {
 
536
                        m_accountContextMenu->popup(cmEvent->globalPos());
 
537
                }
 
538
                return true;
 
539
        }
 
540
 
 
541
        return QObject::eventFilter( obj, event );
 
542
}
 
543
 
 
544
void KopeteAccountConfig::configureActions()
 
545
{
 
546
        // Add account
 
547
        m_actionAccountAdd = new KAction( i18n( "&Add Account..." ), this );
 
548
        m_actionAccountAdd->setIcon( KIcon("list-add") );
 
549
        mButtonAccountAdd->setIcon( m_actionAccountAdd->icon() );
 
550
        mButtonAccountAdd->setText( m_actionAccountAdd->text() );
 
551
        connect( m_actionAccountAdd, SIGNAL(triggered(bool)), this, SLOT(slotAddAccount()) );
 
552
        connect( mButtonAccountAdd, SIGNAL(clicked()), m_actionAccountAdd, SLOT(trigger()) );
 
553
 
 
554
        // Modify account
 
555
        m_actionAccountModify = new KAction( i18n( "&Modify Account..." ), this );
 
556
        m_actionAccountModify->setIcon( KIcon("configure") );
 
557
        mButtonAccountModify->setIcon( m_actionAccountModify->icon() );
 
558
        mButtonAccountModify->setText( m_actionAccountModify->text() );
 
559
        connect( m_actionAccountModify, SIGNAL(triggered(bool)), this, SLOT(slotModify()));
 
560
        connect( mButtonAccountModify, SIGNAL(clicked()), m_actionAccountModify, SLOT(trigger()) );
 
561
 
 
562
        // Remove account
 
563
        m_actionAccountRemove = new KAction( i18n( "&Remove Account" ), this );
 
564
        m_actionAccountRemove->setIcon( KIcon("edit-delete") );
 
565
        m_actionAccountRemove->setShortcut(KShortcut(Qt::Key_Delete));
 
566
        mButtonAccountRemove->setIcon( m_actionAccountRemove->icon() );
 
567
        mButtonAccountRemove->setText( m_actionAccountRemove->text() );
 
568
        connect( m_actionAccountRemove, SIGNAL(triggered(bool)), this, SLOT(removeAccount()) );
 
569
        connect( mButtonAccountRemove, SIGNAL(clicked()), m_actionAccountRemove, SLOT(trigger()) );
 
570
 
 
571
        // Switch identity for an account
 
572
        m_actionAccountSwitchIdentity = new KAction( i18n( "&Switch Identity..." ), this );
 
573
        mButtonAccountSwitchIdentity->setText( m_actionAccountSwitchIdentity->text() );
 
574
        connect( m_actionAccountSwitchIdentity, SIGNAL(triggered(bool)), this, SLOT(slotAccountSwitchIdentity()) );
 
575
        connect( mButtonAccountSwitchIdentity, SIGNAL(clicked()), m_actionAccountSwitchIdentity, SLOT(trigger()) );
 
576
 
 
577
        // Set/clear custom color for account
 
578
        m_actionAccountSetColor = new KAction( i18n( "Set C&olor..." ), this );
 
579
        mButtonAccountSetColor->setText( m_actionAccountSetColor->text() );
 
580
        connect( m_actionAccountSetColor, SIGNAL(triggered(bool)), this, SLOT(slotAccountSetColor()) );
 
581
        connect( mButtonAccountSetColor, SIGNAL(clicked()), m_actionAccountSetColor, SLOT(trigger()) );
 
582
 
 
583
        // Add identity
 
584
        m_actionIdentityAdd = new KAction( i18n( "Add &Identity..." ), this );
 
585
        m_actionIdentityAdd->setIcon( KIcon("list-add") );
 
586
        mButtonIdentityAdd->setIcon( m_actionIdentityAdd->icon() );
 
587
        mButtonIdentityAdd->setText( m_actionIdentityAdd->text() );
 
588
        connect( m_actionIdentityAdd, SIGNAL(triggered(bool)), this, SLOT(slotAddIdentity()) );
 
589
        connect( mButtonIdentityAdd, SIGNAL(clicked()), m_actionIdentityAdd, SLOT(trigger()) );
 
590
 
 
591
        // Copy identity
 
592
        m_actionIdentityCopy = new KAction( i18n( "&Copy Identity..." ), this );
 
593
        m_actionIdentityCopy->setIcon( KIcon("edit-copy") );
 
594
        mButtonIdentityCopy->setIcon( m_actionIdentityCopy->icon() );
 
595
        mButtonIdentityCopy->setText( m_actionIdentityCopy->text() );
 
596
        connect( m_actionIdentityCopy, SIGNAL(triggered(bool)), this, SLOT(slotCopyIdentity()) );
 
597
        connect( mButtonIdentityCopy, SIGNAL(clicked()), m_actionIdentityCopy, SLOT(trigger()) );
 
598
 
 
599
        // Modify identity
 
600
        m_actionIdentityModify = new KAction( i18n( "M&odify Identity..." ), this );
 
601
        m_actionIdentityModify->setIcon( KIcon("configure") );
 
602
        mButtonIdentityModify->setIcon( m_actionIdentityModify->icon() );
 
603
        mButtonIdentityModify->setText( m_actionIdentityModify->text() );
 
604
        connect( m_actionIdentityModify, SIGNAL(triggered(bool)), this, SLOT(slotModify()) );
 
605
        connect( mButtonIdentityModify, SIGNAL(clicked()), m_actionIdentityModify, SLOT(trigger()) );
 
606
 
 
607
        // Remove identity
 
608
        m_actionIdentityRemove = new KAction( i18n( "R&emove Identity" ), this );
 
609
        m_actionIdentityRemove->setIcon( KIcon("edit-delete") );
 
610
        mButtonIdentityRemove->setIcon( m_actionIdentityRemove->icon() );
 
611
        mButtonIdentityRemove->setText( m_actionIdentityRemove->text() );
 
612
        connect( m_actionIdentityRemove, SIGNAL(triggered(bool)), this, SLOT(removeIdentity()) );
 
613
        connect( mButtonIdentityRemove, SIGNAL(clicked()), m_actionIdentityRemove, SLOT(trigger()) );
 
614
 
 
615
        // Switch identity for an identity
 
616
        m_actionIdentitySetDefault = new KAction( i18n( "Set &Default" ), this );
 
617
        mButtonIdentitySetDefault->setText( m_actionIdentitySetDefault->text() );
 
618
        connect( m_actionIdentitySetDefault, SIGNAL(triggered(bool)), this, SLOT(slotSetDefaultIdentity()) );
 
619
        connect( mButtonIdentitySetDefault, SIGNAL(clicked()), m_actionIdentitySetDefault, SLOT(trigger()) );
 
620
}
 
621
 
 
622
void KopeteAccountConfig::configureMenus()
 
623
{
 
624
        // Account management context menu
 
625
        m_accountContextMenu = new KMenu ( this );
 
626
        m_accountContextMenu->addAction( m_actionAccountModify );
 
627
        m_accountContextMenu->addAction( m_actionAccountRemove );
 
628
        m_accountContextMenu->addAction( m_actionAccountSetColor );
 
629
 
 
630
        // Identity management context menu
 
631
        m_identityContextMenu = new KMenu ( this );
 
632
        m_identityContextMenu->addAction( m_actionAccountAdd );
 
633
        m_identityContextMenu->addSeparator();
 
634
        m_identityContextMenu->addAction( m_actionIdentityModify );
 
635
        m_identityContextMenu->addAction( m_actionIdentityRemove );
 
636
        m_identityContextMenu->addAction( m_actionIdentitySetDefault );
 
637
}
 
638
 
 
639
void KopeteAccountConfig::slotItemClicked( QTreeWidgetItem * item, int /*column*/ )
 
640
{
 
641
        KopeteAccountLVI *account = static_cast<KopeteAccountLVI*>( item );
 
642
        if ( account &&  account->parent() )
 
643
                account->account()->setExcludeConnect ( account->checkState(0) == Qt::Unchecked ? true : false );
 
644
}
 
645
 
 
646
 
 
647
#include "kopeteaccountconfig.moc"
 
648
 
 
649
// vim: set noet ts=4 sts=4 sw=4: