← Back to branch summary

~ubuntu-branches/ubuntu/wily/psi/wily-proposed

« back to all changes in this revision

Viewing changes to src/psiiconset.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jan Niehusmann
  • Date: 2008-08-28 18:46:52 UTC
  • mfrom: (1.2.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20080828184652-iiik12dl91nq7cdi
Tags: 0.12-2
http://bugs.debian.org/494352
Uploading to unstable (Closes: Bug#494352)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/psiiconset.cpp
25
25
#include "anim.h"
26
26
#include "applicationinfo.h"
27
27
 
 
28
#include "psioptions.h"
 
29
 
28
30
#include <QFileInfo>
29
 
#include <Q3Dict>
30
 
#include <Q3PtrList>
31
31
#include <QCoreApplication>
 
32
#include <QSet>
32
33
 
33
34
using namespace XMPP;
34
35
 
42
43
        PsiIconset *psi;
43
44
public:
44
45
        Iconset system;
 
46
        QString cur_system, cur_status;
 
47
        QStringList cur_emoticons;
 
48
        QMap<QString, QString> cur_service_status;
 
49
        QMap<QString, QString> cur_custom_status;
45
50
 
46
51
        Private(PsiIconset *_psi) {
47
52
                psi = _psi;
97
102
                                PsiIcon *toIcon = (PsiIcon *)to->icon(icon->name());
98
103
                                if ( toIcon ) {
99
104
                                        if ( icon->anim() ) {
 
105
                                                // setAnim and setImpix both
 
106
                                                //   emit pixmapChanged(),
 
107
                                                //   however we only want this
 
108
                                                //   to happen once, and only
 
109
                                                //   after both functions have
 
110
                                                //   been processed.  so we
 
111
                                                //   block signals during the
 
112
                                                //   first call.
 
113
                                                bool b = toIcon->blockSignals(true);
100
114
                                                toIcon->setAnim  ( *icon->anim(), false );
 
115
                                                toIcon->blockSignals(b);
101
116
                                                toIcon->setImpix ( icon->impix(), false );
102
117
                                        }
103
118
                                        else {
 
119
                                                // same as above
 
120
                                                bool b = toIcon->blockSignals(true);
104
121
                                                toIcon->setAnim  ( Anim(),        false );
 
122
                                                toIcon->blockSignals(b);
105
123
                                                toIcon->setImpix ( icon->impix(), false );
106
124
                                        }
107
125
                                }
119
137
                PsiIcon *icon = (PsiIcon *)IconsetFactory::iconPtr(iconName);
120
138
 
121
139
                // second level -- transport icon
122
 
                if ( jid.user().isEmpty() || option.useTransportIconsForContacts ) {
 
140
                if ( jid.user().isEmpty() || PsiOptions::instance()->getOption("options.ui.contactlist.use-transport-icons").toBool() ) {
123
141
                        QMap<QString, QRegExp> services;
124
142
                        services["aim"]         = QRegExp("^aim");
125
143
                        services["gadugadu"]    = QRegExp("^gg");
130
148
 
131
149
                        bool found = false;
132
150
 
133
 
                        QMap<QString, QRegExp>::Iterator it = services.begin();
134
 
                        for ( ; it != services.end(); ++it) {
135
 
                                QRegExp rx = it.data();
136
 
                                if ( rx.search(jid.host()) != -1 ) {
137
 
                                        // get the iconset name of the current service
138
 
                                        QMap<QString, QString>::Iterator it2 = option.serviceRosterIconset.find(it.key());
139
 
                                        if ( it2 != option.serviceRosterIconset.end() ) {
140
 
                                                Iconset *is = psi->roster.find(it2.data());
 
151
                        
 
152
                        foreach(QVariant serviceV, PsiOptions::instance()->mapKeyList("options.iconsets.service-status")) {
 
153
                                QString service = serviceV.toString();
 
154
                                if (services.contains(service)) {
 
155
                                        if (services[service].search(jid.host()) != -1 ) {
 
156
                                                Iconset *is = psi->roster.find(
 
157
                                                                PsiOptions::instance()->getOption(
 
158
                                                                PsiOptions::instance()->mapLookup("options.iconsets.service-status", service)+".iconset").toString());
141
159
                                                if ( is ) {
142
160
                                                        PsiIcon *i = (PsiIcon *)is->icon(iconName);
143
161
                                                        if ( i ) {
149
167
                                        }
150
168
                                }
151
169
                        }
 
170
                        
152
171
 
153
172
                        // let's try the default transport iconset then...
154
173
                        if ( !found && jid.user().isEmpty() ) {
155
 
                                Iconset *is = psi->roster.find(option.serviceRosterIconset["transport"]);
156
 
                                if ( is ) {
157
 
                                        PsiIcon *i = (PsiIcon *)is->icon(iconName);
158
 
                                        if ( i )
159
 
                                                icon = i;
 
174
                                if (PsiOptions::instance()->mapKeyList("options.iconsets.service-status").contains("transport")) {
 
175
                                        Iconset *is = psi->roster.find(
 
176
                                                                PsiOptions::instance()->getOption(
 
177
                                                                PsiOptions::instance()->mapLookup("options.iconsets.service-status", "transport")+".iconset").toString());                        
 
178
                                        if ( is ) {
 
179
                                                PsiIcon *i = (PsiIcon *)is->icon(iconName);
 
180
                                                if ( i )
 
181
                                                        icon = i;
 
182
                                        }
160
183
                                }
161
184
                        }
162
185
                }
163
186
 
164
187
                // third level -- custom icons
165
 
                QMap<QString, QString>::Iterator it = option.customRosterIconset.begin();
166
 
                for ( ; it != option.customRosterIconset.end(); ++it) {
167
 
                        QRegExp rx = QRegExp(it.key());
 
188
                
 
189
                QStringList customicons = PsiOptions::instance()->getChildOptionNames("options.iconsets.custom-status", true, true);
 
190
                foreach(QString base, customicons) {
 
191
                        QRegExp rx = QRegExp(PsiOptions::instance()->getOption(base + ".regexp").toString());
168
192
                        if ( rx.search(jid.userHost()) != -1 ) {
169
 
                                Iconset *is = psi->roster.find(it.data());
 
193
                                Iconset *is = psi->roster.find(PsiOptions::instance()->getOption(base + ".iconset").toString());
170
194
                                if ( is ) {
171
195
                                        PsiIcon *i = (PsiIcon *)is->icon(iconName);
172
196
                                        if ( i )
183
207
                Iconset def;
184
208
                *ok = def.load(":/iconsets/system/default");
185
209
 
186
 
                if ( option.systemIconset != "default" ) {
 
210
                if ( PsiOptions::instance()->getOption("options.iconsets.system").toString() != "default" ) {
187
211
                        Iconset is;
188
 
                        is.load ( iconsetPath("system/" + option.systemIconset) );
 
212
                        is.load ( iconsetPath("system/" + PsiOptions::instance()->getOption("options.iconsets.system").toString()) );
189
213
 
190
214
                        loadIconset(&def, &is);
191
215
                }
200
224
                Iconset *def = new Iconset;
201
225
                *ok = def->load (":/iconsets/roster/default");
202
226
 
203
 
                if ( option.defaultRosterIconset != "default" ) {
 
227
                if ( PsiOptions::instance()->getOption("options.iconsets.status").toString() != "default" ) {
204
228
                        Iconset is;
205
 
                        is.load ( iconsetPath("roster/" + option.defaultRosterIconset) );
 
229
                        is.load ( iconsetPath("roster/" + PsiOptions::instance()->getOption("options.iconsets.status").toString()) );
206
230
 
207
231
                        loadIconset(def, &is);
208
232
                }
216
240
        {
217
241
                Q3PtrList<Iconset> emo;
218
242
 
219
 
                foreach(QString name, option.emoticons) {
 
243
                foreach(QString name, PsiOptions::instance()->getOption("options.iconsets.emoticons").toStringList()) {
220
244
                        Iconset *is = new Iconset;
221
245
                        if ( is->load ( iconsetPath("emoticons/" + name) ) ) {
222
246
                                PsiIconset::removeAnimation(is);
235
259
        : QObject(QCoreApplication::instance())
236
260
{
237
261
        d = new Private(this);
 
262
        connect(PsiOptions::instance(), SIGNAL(optionChanged(const QString&)), SLOT(optionChanged(const QString&)));
238
263
}
239
264
 
240
265
PsiIconset::~PsiIconset()
244
269
 
245
270
bool PsiIconset::loadSystem()
246
271
{
247
 
        bool ok;
248
 
        Iconset sys = d->systemIconset(&ok);
249
 
        d->loadIconset( &d->system, &sys );
250
 
 
251
 
        //d->system = d->systemIconset();
252
 
        d->system.addToFactory();
 
272
        bool ok = true;
 
273
        QString cur_system = PsiOptions::instance()->getOption("options.iconsets.system").toString();
 
274
        if (d->cur_system != cur_system) {
 
275
                Iconset sys = d->systemIconset(&ok);
 
276
                d->loadIconset(&d->system, &sys);
 
277
 
 
278
                //d->system = d->systemIconset();
 
279
                d->system.addToFactory();
 
280
 
 
281
                d->cur_system = cur_system;
 
282
        }
253
283
 
254
284
        return ok;
255
285
}
256
286
 
257
 
bool PsiIconset::loadAll()
 
287
bool PsiIconset::loadRoster()
258
288
{
259
 
        if ( !loadSystem() )
260
 
                return false;
261
 
 
262
 
        bool ok;
263
 
 
264
289
        // load roster
265
290
        roster.clear();
266
291
 
267
292
        // default roster iconset
 
293
        bool ok;
268
294
        Iconset *def = d->defaultRosterIconset(&ok);
269
295
        def->addToFactory();
270
 
        roster.insert (option.defaultRosterIconset, def);
 
296
        roster.insert(PsiOptions::instance()->getOption("options.iconsets.status").toString(), def);
 
297
 
 
298
        d->cur_status = PsiOptions::instance()->getOption("options.iconsets.status").toString();
271
299
 
272
300
        // load only necessary roster iconsets
273
 
        QStringList rosterIconsets;
274
 
 
275
 
        QMap<QString, QString>::Iterator it = option.serviceRosterIconset.begin();
276
 
        for ( ; it != option.serviceRosterIconset.end(); ++it)
277
 
                if ( rosterIconsets.findIndex( it.data() ) == -1 )
278
 
                        rosterIconsets << it.data();
279
 
 
280
 
        it = option.customRosterIconset.begin();
281
 
        for ( ; it != option.customRosterIconset.end(); ++it)
282
 
                if ( rosterIconsets.findIndex( it.data() ) == -1 )
283
 
                        rosterIconsets << it.data();
284
 
 
285
 
        QStringList::Iterator it2 = rosterIconsets.begin();
286
 
        for ( ; it2 != rosterIconsets.end(); ++it2) {
287
 
                if ( *it2 == option.defaultRosterIconset )
 
301
        QSet<QString> rosterIconsets;
 
302
        d->cur_service_status.clear();
 
303
 
 
304
        foreach(QVariant service, PsiOptions::instance()->mapKeyList("options.iconsets.service-status")) {
 
305
                QString val = PsiOptions::instance()->getOption(
 
306
                                  PsiOptions::instance()->mapLookup("options.iconsets.service-status", service) + ".iconset").toString();
 
307
                rosterIconsets << val;
 
308
                d->cur_service_status.insert(service.toString(), val);
 
309
        }
 
310
 
 
311
        QStringList customicons = PsiOptions::instance()->getChildOptionNames("options.iconsets.custom-status", true, true);
 
312
        d->cur_custom_status.clear();
 
313
        foreach(QString base, customicons) {
 
314
                QString regexp = PsiOptions::instance()->getOption(base + ".regexp").toString();
 
315
                QString iconset = PsiOptions::instance()->getOption(base + ".iconset").toString();
 
316
                rosterIconsets << iconset;
 
317
                d->cur_custom_status.insert(regexp, iconset);
 
318
        }
 
319
 
 
320
        foreach(QString it2, rosterIconsets) {
 
321
                if (it2 == PsiOptions::instance()->getOption("options.iconsets.status").toString()) {
288
322
                        continue;
 
323
                }
289
324
 
290
325
                Iconset *is = new Iconset;
291
 
                if ( is->load (d->iconsetPath("roster/" + *it2)) ) {
292
 
                        is->addToFactory ();
293
 
                        d->stripFirstAnimFrame( *is );
294
 
                        roster.insert (*it2, is);
295
 
                }
296
 
                else
297
 
                     delete is;
 
326
                if (is->load(d->iconsetPath("roster/" + it2))) {
 
327
                        is->addToFactory();
 
328
                        d->stripFirstAnimFrame(*is);
 
329
                        roster.insert(it2, is);
 
330
                }
 
331
                else {
 
332
                        delete is;
 
333
                }
298
334
        }
299
335
 
300
 
        // load emoticons
301
 
        emoticons.clear();
302
 
        emoticons = d->emoticons();
303
 
 
304
336
        return ok;
305
337
}
306
338
 
307
 
bool PsiIconset::optionsChanged(const Options *old)
308
 
{
309
 
        bool ok = loadSystem();
310
 
 
 
339
void PsiIconset::loadEmoticons()
 
340
{
 
341
        QStringList cur_emoticons = PsiOptions::instance()->getOption("options.iconsets.emoticons").toStringList();
 
342
        if (d->cur_emoticons != cur_emoticons) {
 
343
                emoticons.clear();
 
344
                emoticons = d->emoticons();
 
345
 
 
346
                d->cur_emoticons = cur_emoticons;
 
347
                emit emoticonsChanged();
 
348
        }
 
349
}
 
350
 
 
351
bool PsiIconset::loadAll()
 
352
{
 
353
        if (!loadSystem() || !loadRoster())
 
354
                return false;
 
355
 
 
356
        loadEmoticons();
 
357
        return true;
 
358
}
 
359
 
 
360
void PsiIconset::optionChanged(const QString& option)
 
361
{
 
362
        if (option == "options.iconsets.system") {
 
363
                loadSystem();
 
364
        }
 
365
        else if (option == "options.iconsets.emoticons") {
 
366
                loadEmoticons();
 
367
        }
 
368
 
 
369
        // currently we rely on PsiCon calling reloadRoster() when
 
370
        // all options are already applied. otherwise we risk the chance
 
371
        // being called too many times
 
372
 
 
373
        // else if (option == "options.iconsets.status"                   ||
 
374
        //          option.startsWith("options.iconsets.service-status.") ||
 
375
        //          option.startsWith("options.iconsets.custom-status."))
 
376
        // {
 
377
        //      reloadRoster();
 
378
        // }
 
379
}
 
380
 
 
381
void PsiIconset::reloadRoster()
 
382
{
 
383
        bool ok;
 
384
        QString cur_status = PsiOptions::instance()->getOption("options.iconsets.status").toString();
311
385
        // default roster iconset
312
 
        if ( old->defaultRosterIconset != option.defaultRosterIconset ) {
 
386
        if (d->cur_status != cur_status) {
313
387
                Iconset *newDef = d->defaultRosterIconset(&ok);
314
 
                Iconset *oldDef = roster[old->defaultRosterIconset];
315
 
                d->loadIconset( oldDef, newDef );
 
388
                Iconset *oldDef = roster[d->cur_status];
 
389
                d->loadIconset(oldDef, newDef);
316
390
 
317
391
                roster.setAutoDelete(false);
318
 
                roster.remove(old->defaultRosterIconset);
 
392
                roster.remove(d->cur_status);
319
393
                roster.setAutoDelete(true);
320
394
 
321
 
                roster.insert (option.defaultRosterIconset, oldDef);
 
395
                roster.insert(cur_status, oldDef);
322
396
                delete newDef;
 
397
                d->cur_status = cur_status;
 
398
        }
 
399
 
 
400
        QMap<QString, QString> cur_service_status;
 
401
        QMap<QString, QString> cur_custom_status;
 
402
 
 
403
        foreach(QVariant service, PsiOptions::instance()->mapKeyList("options.iconsets.service-status")) {
 
404
                QString val = PsiOptions::instance()->getOption(
 
405
                                  PsiOptions::instance()->mapLookup("options.iconsets.service-status", service) + ".iconset").toString();
 
406
                cur_service_status.insert(service.toString(), val);
 
407
        }
 
408
 
 
409
        QStringList customicons = PsiOptions::instance()->getChildOptionNames("options.iconsets.custom-status", true, true);
 
410
        foreach(QString base, customicons) {
 
411
                QString regexp = PsiOptions::instance()->getOption(base + ".regexp").toString();
 
412
                QString iconset = PsiOptions::instance()->getOption(base + ".iconset").toString();
 
413
                cur_custom_status.insert(regexp, iconset);
323
414
        }
324
415
 
325
416
        // service&custom roster iconsets
326
 
        if (  operator!=(old->serviceRosterIconset,option.serviceRosterIconset) || operator!=(old->customRosterIconset,option.customRosterIconset)) {
 
417
        if (operator!=(d->cur_service_status, cur_service_status) || operator!=(d->cur_custom_status, cur_custom_status)) {
327
418
                QStringList rosterIconsets;
328
 
 
329
 
                QMap<QString, QString>::Iterator it = option.serviceRosterIconset.begin();
330
 
                for ( ; it != option.serviceRosterIconset.end(); ++it)
331
 
                        if ( rosterIconsets.findIndex( it.data() ) == -1 )
332
 
                                rosterIconsets << it.data();
333
 
 
334
 
                it = option.customRosterIconset.begin();
335
 
                for ( ; it != option.customRosterIconset.end(); ++it)
336
 
                        if ( rosterIconsets.findIndex( it.data() ) == -1 )
337
 
                                rosterIconsets << it.data();
338
 
 
 
419
        
 
420
                QMap<QString, QString>::Iterator it = cur_service_status.begin();
 
421
                for (; it != cur_service_status.end(); ++it)
 
422
                        if (rosterIconsets.findIndex(it.data()) == -1)
 
423
                                rosterIconsets << it.data();
 
424
        
 
425
                it = cur_custom_status.begin();
 
426
                for (; it != cur_custom_status.end(); ++it)
 
427
                        if (rosterIconsets.findIndex(it.data()) == -1)
 
428
                                rosterIconsets << it.data();
 
429
        
339
430
                QStringList::Iterator it2 = rosterIconsets.begin();
340
 
                for ( ; it2 != rosterIconsets.end(); ++it2) {
341
 
                        if ( *it2 == option.defaultRosterIconset )
 
431
                for (; it2 != rosterIconsets.end(); ++it2) {
 
432
                        if (*it2 == PsiOptions::instance()->getOption("options.iconsets.status").toString())
342
433
                                continue;
343
 
 
 
434
        
344
435
                        Iconset *is = new Iconset;
345
 
                        if ( is->load (d->iconsetPath("roster/" + *it2)) ) {
346
 
                                d->stripFirstAnimFrame( *is );
 
436
                        if (is->load(d->iconsetPath("roster/" + *it2))) {
 
437
                                d->stripFirstAnimFrame(*is);
347
438
                                Iconset *oldis = roster[*it2];
348
 
 
349
 
                                if ( oldis )
350
 
                                        d->loadIconset( oldis, is );
 
439
        
 
440
                                if (oldis)
 
441
                                        d->loadIconset(oldis, is);
351
442
                                else {
352
 
                                        is->addToFactory ();
353
 
                                        roster.insert (*it2, is);
 
443
                                        is->addToFactory();
 
444
                                        roster.insert(*it2, is);
354
445
                                }
355
446
                        }
356
447
                        else
358
449
                }
359
450
 
360
451
                bool clear = false;
361
 
                while ( !clear ) {
 
452
                while (!clear) {
362
453
                        clear = true;
363
 
 
364
 
                        Q3DictIterator<Iconset> it3 ( roster );
365
 
                        for ( ; it3.current(); ++it3) {
 
454
        
 
455
                        Q3DictIterator<Iconset> it3(roster);
 
456
                        for (; it3.current(); ++it3) {
366
457
                                QString name = it3.currentKey();
367
 
                                if ( name == option.defaultRosterIconset )
 
458
                                if (name == PsiOptions::instance()->getOption("options.iconsets.status").toString())
368
459
                                        continue;
369
460
 
370
 
                                it2 = rosterIconsets.find( name );
371
 
                                if ( it2 == rosterIconsets.end() ) {
 
461
                                it2 = rosterIconsets.find(name);
 
462
                                if (it2 == rosterIconsets.end()) {
372
463
                                        // remove redundant iconset
373
 
                                        roster.remove( name );
 
464
                                        roster.remove(name);
374
465
                                        clear = false;
375
466
                                        break;
376
467
                                }
377
468
                        }
378
469
                }
379
 
        }
380
 
 
381
 
        // load emoticons
382
 
        if ( old->emoticons != option.emoticons ) {
383
 
                emoticons.clear();
384
 
                emoticons = d->emoticons();
385
 
        }
386
 
 
387
 
        return old->defaultRosterIconset != option.defaultRosterIconset;
 
470
 
 
471
                d->cur_service_status = cur_service_status;
 
472
                d->cur_custom_status  = cur_custom_status;
 
473
        }
388
474
}
389
475
 
390
476
PsiIcon *PsiIconset::event2icon(PsiEvent *e)
483
569
PsiIcon *PsiIconset::transportStatusPtr(QString name, int s)
484
570
{
485
571
        PsiIcon *icon = 0;
486
 
 
487
 
        QMap<QString, QString>::Iterator it = option.serviceRosterIconset.begin();
488
 
        for ( ; it != option.serviceRosterIconset.end(); ++it) {
489
 
                if (name == it.key()) {
490
 
                        Iconset *is = roster.find(it.data());
491
 
                        if ( is ) {
492
 
                                icon = (PsiIcon *)is->icon(status2name(s));
493
 
                                if ( icon )
494
 
                                        break;
495
 
                        }
 
572
        
 
573
        QVariantList serviceicons = PsiOptions::instance()->mapKeyList("options.iconsets.service-status");
 
574
        if (serviceicons.contains(name)) {
 
575
                Iconset *is = roster.find(
 
576
                                                        PsiOptions::instance()->getOption(
 
577
                                                        PsiOptions::instance()->mapLookup("options.iconsets.service-status", name)+".iconset").toString());
 
578
                if ( is ) {
 
579
                        icon = (PsiIcon *)is->icon(status2name(s));
496
580
                }
497
581
        }
498
582