← Back to branch summary

~ubuntu-branches/ubuntu/natty/knemo/natty

« back to all changes in this revision

Viewing changes to src/kcm/configdialog.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2011-02-22 16:36:22 UTC
  • mfrom: (1.1.13 upstream)
  • Revision ID: james.westby@ubuntu.com-20110222163622-d8i62gy1stn7tydv
Tags: 0.7.0-0ubuntu1
* New upstream release.
* Switch to source format 3.0 (quilt).
* Make knemo depend on libqt4-sql-sqlite.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/kcm/configdialog.cpp
1
1
/* This file is part of KNemo
2
2
   Copyright (C) 2004, 2006 Percy Leonhardt <percy@eris23.de>
3
 
   Copyright (C) 2009 John Stamp <jstamp@users.sourceforge.net>
 
3
   Copyright (C) 2009, 2010 John Stamp <jstamp@users.sourceforge.net>
4
4
 
5
5
   KNemo is free software; you can redistribute it and/or modify
6
6
   it under the terms of the GNU Library General Public License as
20
20
 
21
21
#include <QDBusInterface>
22
22
#include <QPainter>
 
23
#include <QSortFilterProxyModel>
 
24
#include <QStandardItemModel>
23
25
 
24
26
#include <KCalendarSystem>
25
27
#include <KColorScheme>
26
28
#include <KGenericFactory>
27
29
#include <KInputDialog>
 
30
#include <kio/global.h>
28
31
#include <KMessageBox>
29
32
#include <KNotifyConfigWidget>
30
33
#include <KStandardDirs>
 
34
#include <math.h>
31
35
 
32
36
#include "ui_configdlg.h"
33
37
#include "config-knemo.h"
34
38
#include "configdialog.h"
 
39
#include "statsconfig.h"
 
40
#include "warnconfig.h"
35
41
#include "themeconfig.h"
36
42
#include "utils.h"
37
43
 
38
 
#include <math.h>
39
44
#include <sys/socket.h>
40
45
#include <sys/types.h>
41
46
#include <ifaddrs.h>
52
57
K_EXPORT_PLUGIN(KNemoFactory("kcm_knemo"))
53
58
 
54
59
Q_DECLARE_METATYPE( KNemoTheme )
 
60
Q_DECLARE_METATYPE( StatsRule )
 
61
Q_DECLARE_METATYPE( WarnRule )
55
62
 
56
63
 
57
64
static bool themesLessThan( const KNemoTheme& s1, const KNemoTheme& s2 )
62
69
        return false;
63
70
}
64
71
 
 
72
static QString periodText( int c, int u )
 
73
{
 
74
    QString units;
 
75
    switch ( u )
 
76
    {
 
77
        case KNemoStats::Hour:
 
78
            units = i18np( "%1 hour", "%1 hours", c );
 
79
            break;
 
80
        case KNemoStats::Day:
 
81
            units = i18np( "%1 day", "%1 days", c );
 
82
            break;
 
83
        case KNemoStats::Week:
 
84
            units = i18np( "%1 week", "%1 weeks", c );
 
85
            break;
 
86
        case KNemoStats::Month:
 
87
            units = i18np( "%1 month", "%1 months", c );
 
88
            break;
 
89
        case KNemoStats::BillPeriod:
 
90
            units = i18np( "%1 billing period", "%1 billing periods", c );
 
91
            break;
 
92
        case KNemoStats::Year:
 
93
            units = i18np( "%1 year", "%1 years", c );
 
94
            break;
 
95
        default:
 
96
            units = i18n( "Invalid period" );
 
97
            ;;
 
98
    }
 
99
    return units;
 
100
}
 
101
 
 
102
void StatsRuleModel::setCalendar( const KCalendarSystem *cal )
 
103
{
 
104
    mCalendar = cal;
 
105
}
 
106
 
 
107
QString StatsRuleModel::dateText( const StatsRule &s )
 
108
{
 
109
    QString dateStr = mCalendar->formatDate( s.startDate, KLocale::LongDate );
 
110
    if ( !mCalendar->isValid( s.startDate ) )
 
111
        dateStr = i18n( "Invalid Date" );
 
112
    return dateStr;
 
113
}
 
114
 
 
115
QList<StatsRule> StatsRuleModel::getRules()
 
116
{
 
117
    QList<StatsRule> statsRules;
 
118
    for ( int i = 0; i < rowCount(); ++i )
 
119
    {
 
120
        statsRules << item( i, 0 )->data( Qt::UserRole ).value<StatsRule>();
 
121
    }
 
122
    return statsRules;
 
123
}
 
124
 
 
125
QModelIndex StatsRuleModel::addRule( const StatsRule &s )
 
126
{
 
127
    QList<QStandardItem*> items;
 
128
    QStandardItem *item = new QStandardItem( dateText( s ) );
 
129
    QVariant v;
 
130
    v.setValue( s );
 
131
    item->setData( v, Qt::UserRole );
 
132
    item->setData( s.startDate, Qt::UserRole + 1 );
 
133
    items << item;
 
134
 
 
135
    item = new QStandardItem( periodText( s.periodCount, s.periodUnits ) );
 
136
    items << item;
 
137
    appendRow( items );
 
138
    return indexFromItem (items[0] );
 
139
}
 
140
 
 
141
void StatsRuleModel::modifyRule( const QModelIndex &index, const StatsRule &s )
 
142
{
 
143
    QVariant v;
 
144
    v.setValue( s );
 
145
    item( index.row(), 0 )->setData( v, Qt::UserRole );
 
146
    item( index.row(), 0 )->setData( s.startDate, Qt::UserRole + 1 );
 
147
    item( index.row(), 0 )->setData( dateText( s ), Qt::DisplayRole );
 
148
    item( index.row(), 1 )->setData( periodText( s.periodCount, s.periodUnits ), Qt::DisplayRole );
 
149
}
 
150
 
 
151
QString WarnModel::ruleText( const WarnRule &warn )
 
152
{
 
153
    QString warnType;
 
154
    switch ( warn.trafficType )
 
155
    {
 
156
        case KNemoStats::Peak:
 
157
           warnType = i18n( "peak" );
 
158
           break;
 
159
        case KNemoStats::Offpeak:
 
160
           warnType = i18n( "off-peak" );
 
161
    }
 
162
    QString warnDirection;
 
163
    switch ( warn.trafficDirection )
 
164
    {
 
165
        case KNemoStats::TrafficIn:
 
166
           warnDirection = i18n( "incoming" );
 
167
           break;
 
168
        case KNemoStats::TrafficOut:
 
169
           warnDirection = i18n( "outgoing" );
 
170
           break;
 
171
        case KNemoStats::TrafficTotal:
 
172
           warnDirection = i18n( "incoming and outgoing" );
 
173
    }
 
174
    quint64 siz = warn.threshold * pow( 1024, warn.trafficUnits );
 
175
    QString text = QString( "%1 %2 traffic > %3" ).arg( warnType ).arg( warnDirection )
 
176
        .arg( KIO::convertSize( siz ) );
 
177
    return text.simplified();
 
178
}
 
179
 
 
180
QList<WarnRule> WarnModel::getRules()
 
181
{
 
182
    QList<WarnRule> warnRules;
 
183
    for ( int i = 0; i < rowCount(); ++i )
 
184
    {
 
185
        warnRules << item( i, 0 )->data( Qt::UserRole ).value<WarnRule>();
 
186
    }
 
187
    return warnRules;
 
188
}
 
189
 
 
190
QModelIndex WarnModel::addWarn( const WarnRule &warn )
 
191
{
 
192
    QList<QStandardItem*> items;
 
193
    QStandardItem *item = new QStandardItem( ruleText( warn ) );
 
194
    QVariant v;
 
195
    v.setValue( warn );
 
196
    item->setData( v, Qt::UserRole );
 
197
    items << item;
 
198
    item = new QStandardItem( periodText( warn.periodCount, warn.periodUnits ) );
 
199
    items << item;
 
200
    appendRow( items );
 
201
    return indexFromItem( items[0] );
 
202
}
 
203
 
 
204
void WarnModel::modifyWarn( const QModelIndex &index, const WarnRule &warn )
 
205
{
 
206
    QVariant v;
 
207
    v.setValue( warn );
 
208
    item( index.row(), 0 )->setData( v, Qt::UserRole );
 
209
    item( index.row(), 0 )->setData( ruleText( warn ), Qt::DisplayRole );
 
210
    item( index.row(), 1 )->setData( periodText( warn.periodCount, warn.periodUnits ), Qt::DisplayRole );
 
211
}
 
212
 
 
213
 
65
214
ConfigDialog::ConfigDialog( QWidget *parent, const QVariantList &args )
66
215
    : KCModule( KNemoFactory::componentData(), parent, args ),
67
216
      mLock( false ),
68
 
      mDlg( new Ui::ConfigDlg() )
 
217
      mDlg( new Ui::ConfigDlg() ),
 
218
      mCalendar( 0 )
69
219
{
70
220
    if ( KDE::versionMajor() >= 4 && KDE::versionMinor() >= 4 )
71
221
        mDefaultCalendarType = KGlobal::locale()->calendarType();
80
230
    QVBoxLayout* top = new QVBoxLayout( this );
81
231
    mDlg->setupUi( main );
82
232
    top->addWidget( main );
 
233
    statsModel = new StatsRuleModel( this );
 
234
    QStringList l;
 
235
    l << i18n( "Start Date" ) << i18n( "Period" );
 
236
    statsModel->setHorizontalHeaderLabels( l );
 
237
    QSortFilterProxyModel *proxy = new QSortFilterProxyModel( mDlg->statsView );
 
238
    proxy->setSourceModel( statsModel );
 
239
    proxy->setSortRole( Qt::UserRole + 1 );
 
240
    mDlg->statsView->setModel( proxy );
 
241
    mDlg->statsView->sortByColumn( 0, Qt::AscendingOrder );
 
242
 
 
243
    warnModel = new WarnModel( this );
 
244
    l.clear();
 
245
    l << i18n( "Alert" ) << i18n( "Period" );
 
246
    warnModel->setHorizontalHeaderLabels( l );
 
247
    mDlg->warnView->setModel( warnModel );
83
248
 
84
249
    QList<KNemoTheme> themes = findThemes();
85
250
    qSort( themes.begin(), themes.end(), themesLessThan );
108
273
    mDlg->comboBoxIconTheme->addItem( netloadTheme.name, QVariant::fromValue( netloadTheme ) );
109
274
    mDlg->comboBoxIconTheme->addItem( textTheme.name, QVariant::fromValue( textTheme ) );
110
275
 
111
 
    mDlg->warnType->addItem( i18n( "Hour" ), NotifyHour );
112
 
    mDlg->warnType->addItem( i18n( "Day" ), NotifyDay );
113
 
    mDlg->warnType->addItem( i18n( "Month" ), NotifyMonth );
114
 
    mDlg->warnType->addItem( i18n( "Rolling 24 hours" ), NotifyRoll24Hour );
115
 
    mDlg->warnType->addItem( i18n( "Rolling 7 days" ), NotifyRoll7Day );
116
 
    mDlg->warnType->addItem( i18n( "Rolling 30 days" ), NotifyRoll30Day );
117
 
 
118
 
    mDlg->warnUnits->addItem( i18n( "MiB" ), 2 );
119
 
    mDlg->warnUnits->addItem( i18n( "GiB" ), 3 );
120
 
 
121
276
    InterfaceSettings s;
122
277
    int index = findIndexFromName( s.iconTheme );
123
278
    if ( index < 0 )
179
334
    // Interface - Statistics
180
335
    connect( mDlg->checkBoxStatistics, SIGNAL( toggled( bool ) ),
181
336
             this, SLOT( checkBoxStatisticsToggled ( bool ) ) );
182
 
    connect( mDlg->checkBoxCustomBilling, SIGNAL( toggled( bool ) ),
183
 
             this, SLOT( checkBoxCustomBillingToggled( bool ) ) );
184
 
    connect( mDlg->billingStartInput, SIGNAL( dateEntered( const QDate& ) ),
185
 
             this, SLOT( billingStartInputChanged( const QDate& ) ) );
186
 
    connect( mDlg->billingMonthsInput, SIGNAL( valueChanged( int ) ),
187
 
             this, SLOT( billingMonthsInputChanged( int ) ) );
188
 
    connect( mDlg->warnThreshold, SIGNAL( valueChanged( double ) ),
189
 
             this, SLOT( warnThresholdChanged ( double ) ) );
190
 
    connect( mDlg->warnUnits, SIGNAL( activated( int ) ),
191
 
             this, SLOT( warnUnitsChanged( int ) ) );
192
 
    connect( mDlg->warnType, SIGNAL( activated( int ) ),
193
 
             this, SLOT( warnTypeChanged( int ) ) );
194
 
    connect( mDlg->warnRxTx, SIGNAL( toggled( bool ) ),
195
 
             this, SLOT( warnRxTxToggled ( bool ) ) );
 
337
    connect( mDlg->addStats, SIGNAL( clicked() ),
 
338
             this, SLOT( addStatsClicked() ) );
 
339
    connect( mDlg->modifyStats, SIGNAL( clicked() ),
 
340
             this, SLOT( modifyStatsClicked() ) );
 
341
    connect( mDlg->removeStats, SIGNAL( clicked() ),
 
342
             this, SLOT( removeStatsClicked() ) );
 
343
    connect( mDlg->addWarn, SIGNAL( clicked() ),
 
344
             this, SLOT( addWarnClicked() ) );
 
345
    connect( mDlg->modifyWarn, SIGNAL( clicked() ),
 
346
             this, SLOT( modifyWarnClicked() ) );
 
347
    connect( mDlg->removeWarn, SIGNAL( clicked() ),
 
348
             this, SLOT( removeWarnClicked() ) );
196
349
 
197
350
    // Interface - Context Menu
198
351
    connect( mDlg->listViewCommands, SIGNAL( currentItemChanged( QTreeWidgetItem*, QTreeWidgetItem* ) ),
230
383
    delete mDlg;
231
384
}
232
385
 
233
 
void ConfigDialog::setMaxDay()
234
 
{
235
 
    QDate date = QDate::currentDate();
236
 
    mMaxDay = mCalendar->daysInMonth( date );
237
 
    if ( mCalendar->isLeapYear( date ) )
238
 
        date = date.addDays( 0 - mCalendar->dayOfYear( date ) );
239
 
    int months = mCalendar->monthsInYear( date );
240
 
    for ( int i = 1; i < months; i++ )
241
 
    {
242
 
        QDate month;
243
 
        mCalendar->setYMD( month, mCalendar->year( date ), i, 1 );
244
 
        int days = mCalendar->daysInMonth( month );
245
 
        if ( days < mMaxDay )
246
 
            mMaxDay = days;
247
 
    }
248
 
}
249
 
 
250
386
void ConfigDialog::load()
251
387
{
252
388
    mSettingsMap.clear();
289
425
            KColorScheme scheme(QPalette::Active, KColorScheme::View);
290
426
            settings->colorDisabled = interfaceGroup.readEntry( conf_colorDisabled, scheme.foreground( KColorScheme::InactiveText ).color() );
291
427
            settings->colorUnavailable = interfaceGroup.readEntry( conf_colorUnavailable, scheme.foreground( KColorScheme::InactiveText ).color() );
 
428
            settings->colorBackground = scheme.foreground( KColorScheme::InactiveText ).color();
292
429
            settings->iconFont = interfaceGroup.readEntry( conf_iconFont, s.iconFont );
293
430
            settings->dynamicColor = interfaceGroup.readEntry( conf_dynamicColor, s.dynamicColor );
294
431
            settings->colorIncomingMax = interfaceGroup.readEntry( conf_colorIncomingMax, s.colorIncomingMax );
296
433
            settings->barScale = interfaceGroup.readEntry( conf_barScale, s.barScale );
297
434
            settings->inMaxRate = interfaceGroup.readEntry( conf_inMaxRate, s.inMaxRate );
298
435
            settings->outMaxRate = interfaceGroup.readEntry( conf_outMaxRate, s.outMaxRate );
 
436
            settings->calendar = interfaceGroup.readEntry( conf_calendar, mDefaultCalendarType );
299
437
            settings->activateStatistics = interfaceGroup.readEntry( conf_activateStatistics, s.activateStatistics );
300
 
            settings->customBilling = interfaceGroup.readEntry( conf_customBilling, s.customBilling );
301
 
            settings->calendar = interfaceGroup.readEntry( conf_calendar, mDefaultCalendarType );
302
 
            settings->billingMonths = clamp<int>(interfaceGroup.readEntry( conf_billingMonths, s.billingMonths ), 1, 6 );
303
 
            settings->warnThreshold = clamp<double>(interfaceGroup.readEntry( conf_billingWarnThresh, s.warnThreshold ), 0.0, 9999.0 );
304
 
            settings->warnUnits = clamp<int>(interfaceGroup.readEntry( conf_billingWarnUnits, s.warnUnits ), 2, 3 );
305
 
            settings->warnType = clamp<int>(interfaceGroup.readEntry( conf_billingWarnType, s.warnType ), 0, 5 );
306
 
            settings->warnTotalTraffic = interfaceGroup.readEntry( conf_billingWarnRxTx, s.warnTotalTraffic );
307
 
 
308
 
             // If no start date saved, default to first of month.
309
 
            mCalendar = KCalendarSystem::create( settings->calendar );
310
 
            QDate startDate = QDate::currentDate().addDays( 1 - mCalendar->day( QDate::currentDate() ) );
311
 
            settings->billingStart = interfaceGroup.readEntry( conf_billingStart, startDate );
312
 
 
313
 
            // If date is saved but very old, update it to current period
314
 
            QDate currentDate = QDate::currentDate();
315
 
            QDate nextMonthStart = settings->billingStart;
316
 
            if ( nextMonthStart <= currentDate )
317
 
            {
318
 
                int length = settings->billingMonths;
319
 
                while ( nextMonthStart <= currentDate )
320
 
                {
321
 
                    settings->billingStart = nextMonthStart;
322
 
                    for ( int i = 0; i < length; i++ )
323
 
                        nextMonthStart = nextMonthStart.addDays( mCalendar->daysInMonth( nextMonthStart ) );
 
438
            int statsRuleCount = interfaceGroup.readEntry( conf_statsRules, 0 );
 
439
            for ( int i = 0; i < statsRuleCount; ++i )
 
440
            {
 
441
                group = QString( "%1%2 #%3" ).arg( confg_statsRule ).arg( interface ).arg( i );
 
442
                if ( config->hasGroup( group ) )
 
443
                {
 
444
                    KConfigGroup statsGroup( config, group );
 
445
                    StatsRule stats;
 
446
 
 
447
                    stats.startDate = statsGroup.readEntry( conf_statsStartDate, QDate() );
 
448
                    stats.periodUnits = clamp<int>(statsGroup.readEntry( conf_statsPeriodUnits, stats.periodUnits ), KNemoStats::Day, KNemoStats::Year );
 
449
                    stats.periodCount = clamp<int>(statsGroup.readEntry( conf_statsPeriodCount, stats.periodCount ), 1, 1000 );
 
450
                    stats.logOffpeak = statsGroup.readEntry( conf_logOffpeak,stats.logOffpeak );
 
451
                    stats.offpeakStartTime = QTime::fromString( statsGroup.readEntry( conf_offpeakStartTime, stats.offpeakStartTime.toString( Qt::ISODate ) ), Qt::ISODate );
 
452
                    stats.offpeakEndTime = QTime::fromString( statsGroup.readEntry( conf_offpeakEndTime, stats.offpeakEndTime.toString( Qt::ISODate ) ), Qt::ISODate );
 
453
                    stats.weekendIsOffpeak = statsGroup.readEntry( conf_weekendIsOffpeak, stats.weekendIsOffpeak );
 
454
                    stats.weekendDayStart = statsGroup.readEntry( conf_weekendDayStart, stats.weekendDayStart );
 
455
                    stats.weekendDayEnd = statsGroup.readEntry( conf_weekendDayEnd, stats.weekendDayEnd );
 
456
                    stats.weekendTimeStart = QTime::fromString( statsGroup.readEntry( conf_weekendTimeStart, stats.weekendTimeStart.toString( Qt::ISODate ) ), Qt::ISODate );
 
457
                    stats.weekendTimeEnd = QTime::fromString( statsGroup.readEntry( conf_weekendTimeEnd, stats.weekendTimeEnd.toString( Qt::ISODate ) ), Qt::ISODate );
 
458
                    settings->statsRules << stats;
 
459
                }
 
460
            }
 
461
 
 
462
            int warnRuleCount = interfaceGroup.readEntry( conf_warnRules, 0 );
 
463
            for ( int i = 0; i < warnRuleCount; ++i )
 
464
            {
 
465
                group = QString( "%1%2 #%3" ).arg( confg_warnRule ).arg( interface ).arg( i );
 
466
                if ( config->hasGroup( group ) )
 
467
                {
 
468
                    KConfigGroup warnGroup( config, group );
 
469
                    WarnRule warn;
 
470
 
 
471
                    warn.periodUnits = clamp<int>(warnGroup.readEntry( conf_warnPeriodUnits, warn.periodUnits ), KNemoStats::Hour, KNemoStats::Year );
 
472
                    warn.periodCount = clamp<int>(warnGroup.readEntry( conf_warnPeriodCount, warn.periodCount ), 1, 1000 );
 
473
                    warn.trafficType = clamp<int>(warnGroup.readEntry( conf_warnTrafficType, warn.trafficType ), KNemoStats::Peak, KNemoStats::PeakOffpeak );
 
474
                    warn.trafficDirection = clamp<int>(warnGroup.readEntry( conf_warnTrafficDirection, warn.trafficDirection ), KNemoStats::TrafficIn, KNemoStats::TrafficTotal );
 
475
                    warn.trafficUnits = clamp<int>(warnGroup.readEntry( conf_warnTrafficUnits, warn.trafficUnits ), KNemoStats::UnitB, KNemoStats::UnitG );
 
476
                    warn.threshold = clamp<double>(warnGroup.readEntry( conf_warnThreshold, warn.threshold ), 0.0, 9999.0 );
 
477
                    warn.customText = warnGroup.readEntry( conf_warnCustomText, warn.customText ).trimmed();
 
478
 
 
479
                    settings->warnRules << warn;
324
480
                }
325
481
            }
326
482
 
400
556
        }
401
557
    }
402
558
 
 
559
    QStringList groupList = config->groupList();
 
560
    foreach ( QString tempDel, groupList )
 
561
    {
 
562
        if ( tempDel.contains( confg_statsRule ) || tempDel.contains( confg_warnRule ) )
 
563
            config->deleteGroup( tempDel );
 
564
    }
 
565
 
403
566
    foreach ( QString it, mSettingsMap.keys() )
404
567
    {
405
568
        list.append( it );
417
580
        QByteArray dayState = interfaceGroup.readEntry( conf_dayState, QByteArray() );
418
581
        QByteArray weekState = interfaceGroup.readEntry( conf_weekState, QByteArray() );
419
582
        QByteArray monthState = interfaceGroup.readEntry( conf_monthState, QByteArray() );
 
583
        QByteArray billingState = interfaceGroup.readEntry( conf_billingState, QByteArray() );
420
584
        QByteArray yearState = interfaceGroup.readEntry( conf_yearState, QByteArray() );
421
585
 
422
586
        // Make sure we don't get crufty commands left over
444
608
            interfaceGroup.writeEntry( conf_weekState, weekState );
445
609
        if ( !monthState.isNull() )
446
610
            interfaceGroup.writeEntry( conf_monthState, monthState );
 
611
        if ( !billingState.isNull() )
 
612
            interfaceGroup.writeEntry( conf_billingState, billingState );
447
613
        if ( !yearState.isNull() )
448
614
            interfaceGroup.writeEntry( conf_yearState, yearState );
449
615
 
482
648
            }
483
649
        }
484
650
        interfaceGroup.writeEntry( conf_activateStatistics, settings->activateStatistics );
485
 
        interfaceGroup.writeEntry( conf_customBilling, settings->customBilling );
486
 
        if ( settings->customBilling )
 
651
        interfaceGroup.writeEntry( conf_calendar, settings->calendar );
 
652
        interfaceGroup.writeEntry( conf_statsRules, settings->statsRules.count() );
 
653
        for ( int i = 0; i < settings->statsRules.count(); i++ )
487
654
        {
488
 
            interfaceGroup.writeEntry( conf_billingStart, mDlg->billingStartInput->date() );
489
 
            interfaceGroup.writeEntry( conf_billingMonths, settings->billingMonths );
490
 
            interfaceGroup.writeEntry( conf_calendar, settings->calendar );
 
655
            QString group = QString( "%1%2 #%3" ).arg( confg_statsRule ).arg( it ).arg( i );
 
656
            KConfigGroup statsGroup( config, group );
 
657
            statsGroup.writeEntry( conf_statsStartDate, settings->statsRules[i].startDate );
 
658
            statsGroup.writeEntry( conf_statsPeriodUnits, settings->statsRules[i].periodUnits );
 
659
            statsGroup.writeEntry( conf_statsPeriodCount, settings->statsRules[i].periodCount );
 
660
            statsGroup.writeEntry( conf_logOffpeak, settings->statsRules[i].logOffpeak );
 
661
            if ( settings->statsRules[i].logOffpeak )
 
662
            {
 
663
                statsGroup.writeEntry( conf_offpeakStartTime, settings->statsRules[i].offpeakStartTime.toString( Qt::ISODate ) );
 
664
                statsGroup.writeEntry( conf_offpeakEndTime, settings->statsRules[i].offpeakEndTime.toString( Qt::ISODate ) );
 
665
                statsGroup.writeEntry( conf_weekendIsOffpeak, settings->statsRules[i].weekendIsOffpeak );
 
666
                if ( settings->statsRules[i].weekendIsOffpeak )
 
667
                {
 
668
                    statsGroup.writeEntry( conf_weekendDayStart, settings->statsRules[i].weekendDayStart );
 
669
                    statsGroup.writeEntry( conf_weekendDayEnd, settings->statsRules[i].weekendDayEnd );
 
670
                    statsGroup.writeEntry( conf_weekendTimeStart, settings->statsRules[i].weekendTimeStart.toString( Qt::ISODate ) );
 
671
                    statsGroup.writeEntry( conf_weekendTimeEnd, settings->statsRules[i].weekendTimeEnd.toString( Qt::ISODate ) );
 
672
                }
 
673
            }
491
674
        }
492
 
        interfaceGroup.writeEntry( conf_billingWarnThresh, settings->warnThreshold );
493
 
        if ( settings->warnThreshold > 0 )
 
675
        interfaceGroup.writeEntry( conf_warnRules, settings->warnRules.count() );
 
676
        for ( int i = 0; i < settings->warnRules.count(); i++ )
494
677
        {
495
 
            interfaceGroup.writeEntry( conf_billingWarnUnits, settings->warnUnits );
496
 
            interfaceGroup.writeEntry( conf_billingWarnType, settings->warnType );
497
 
            interfaceGroup.writeEntry( conf_billingWarnRxTx, settings->warnTotalTraffic );
 
678
            QString group = QString( "%1%2 #%3" ).arg( confg_warnRule ).arg( it ).arg( i );
 
679
            KConfigGroup warnGroup( config, group );
 
680
            if ( settings->statsRules.count() == 0 && settings->warnRules[i].periodUnits == KNemoStats::BillPeriod )
 
681
            {
 
682
                warnGroup.writeEntry( conf_warnPeriodUnits, static_cast<int>(KNemoStats::Month) );
 
683
            }
 
684
            else
 
685
            {
 
686
                warnGroup.writeEntry( conf_warnPeriodUnits, settings->warnRules[i].periodUnits );
 
687
            }
 
688
            warnGroup.writeEntry( conf_warnPeriodCount, settings->warnRules[i].periodCount );
 
689
            warnGroup.writeEntry( conf_warnTrafficType, settings->warnRules[i].trafficType );
 
690
            warnGroup.writeEntry( conf_warnTrafficDirection, settings->warnRules[i].trafficDirection );
 
691
            warnGroup.writeEntry( conf_warnTrafficUnits, settings->warnRules[i].trafficUnits );
 
692
            warnGroup.writeEntry( conf_warnThreshold, settings->warnRules[i].threshold );
 
693
            warnGroup.writeEntry( conf_warnCustomText, settings->warnRules[i].customText.trimmed() );
498
694
        }
499
695
 
500
696
        interfaceGroup.writeEntry( conf_numCommands, settings->commands.size() );
571
767
    {
572
768
        InterfaceSettings* settings = new InterfaceSettings();
573
769
        QDate startDate = QDate::currentDate().addDays( 1 - mCalendar->day( QDate::currentDate() ) );
574
 
        settings->billingStart = startDate;
575
770
        KColorScheme scheme(QPalette::Active, KColorScheme::View);
576
771
        settings->colorDisabled = scheme.foreground( KColorScheme::InactiveText ).color();
577
772
        settings->colorUnavailable = scheme.foreground( KColorScheme::InactiveText ).color();
 
773
        settings->colorBackground = scheme.foreground( KColorScheme::InactiveText ).color();
578
774
        settings->iconFont = KGlobalSettings::generalFont();
579
775
        mSettingsMap.insert( interface, settings );
580
776
        mDlg->listBoxInterfaces->addItem( interface );
653
849
    return -1;
654
850
}
655
851
 
 
852
void ConfigDialog::updateWarnText( int oldCount )
 
853
{
 
854
    // If the billing periods go away, the warn period will change to months
 
855
    // This only changes the text displayed in the model, so it can change
 
856
    // back if a billing period reappears.
 
857
    if ( ! statsModel->rowCount() )
 
858
    {
 
859
        QList<WarnRule> warnRules = warnModel->getRules();
 
860
        for ( int i = 0; i < warnRules.count(); ++i )
 
861
        {
 
862
            if ( warnRules[i].periodUnits == KNemoStats::BillPeriod )
 
863
            {
 
864
                warnModel->item( i, 1 )->setData( periodText( warnRules[i].periodCount, KNemoStats::Month ), Qt::DisplayRole );
 
865
            }
 
866
        }
 
867
    }
 
868
    else if ( oldCount == 0 )
 
869
    {
 
870
        QList<WarnRule> warnRules = warnModel->getRules();
 
871
        for ( int i = 0; i < warnRules.count(); ++i )
 
872
        {
 
873
            if ( warnRules[i].periodUnits == KNemoStats::BillPeriod )
 
874
                warnModel->item( i, 1 )->setData( periodText( warnRules[i].periodCount, warnRules[i].periodUnits ), Qt::DisplayRole );
 
875
        }
 
876
    }
 
877
}
 
878
 
656
879
void ConfigDialog::updateControls( InterfaceSettings *settings )
657
880
{
658
881
    mLock = true;
676
899
    mDlg->comboHiding->setCurrentIndex( index );
677
900
    comboHidingChanged( index );
678
901
    mDlg->checkBoxStatistics->setChecked( settings->activateStatistics );
679
 
    mDlg->warnThreshold->setValue( settings->warnThreshold );
680
 
    index = mDlg->warnUnits->findData( settings->warnUnits );
681
 
    mDlg->warnUnits->setCurrentIndex( index );
682
 
    index = mDlg->warnType->findData( settings->warnType );
683
 
    mDlg->warnType->setCurrentIndex( index );
684
 
    if ( settings->warnTotalTraffic )
685
 
        mDlg->warnRxTx->setChecked( true );
686
 
    else
687
 
        mDlg->warnRx->setChecked( true );
688
 
    if ( settings->customBilling )
689
 
        mDlg->checkBoxCustomBilling->setChecked( true );
690
 
    else
691
 
        mDlg->checkBoxCustomBilling->setChecked( false );
692
902
 
 
903
    QString calType;
693
904
    if ( settings->calendar.isEmpty() )
694
905
    {
695
 
        // TODO: Test for a KDE release that contains SVN commit 1013534
696
 
        KGlobal::locale()->setCalendar( mDefaultCalendarType );
697
 
 
698
 
        mCalendar = KCalendarSystem::create( mDefaultCalendarType );
 
906
        calType = mDefaultCalendarType;
699
907
    }
700
908
    else
701
909
    {
702
 
        // TODO: Test for a KDE release that contains SVN commit 1013534
703
 
        KGlobal::locale()->setCalendar( settings->calendar );
704
 
 
705
 
        mCalendar = KCalendarSystem::create( settings->calendar );
706
 
    }
707
 
    setMaxDay();
708
 
    mDlg->billingStartInput->setDate( settings->billingStart );
 
910
        calType = settings->calendar;
 
911
    }
 
912
    if ( !mCalendar || mCalendar->calendarType() != calType )
 
913
        mCalendar = KCalendarSystem::create( calType );
 
914
 
 
915
    statsModel->removeRows(0, statsModel->rowCount() );
 
916
    statsModel->setCalendar( mCalendar );
 
917
    foreach( StatsRule s, settings->statsRules )
 
918
    {
 
919
        statsModel->addRule( s );
 
920
    }
 
921
    if ( statsModel->rowCount() )
 
922
    {
 
923
        QSortFilterProxyModel* proxy = static_cast<QSortFilterProxyModel*>(mDlg->statsView->model());
 
924
        QModelIndex index = statsModel->indexFromItem( statsModel->item( 0, 0 ) );
 
925
        mDlg->statsView->setCurrentIndex( proxy->mapFromSource( index ) );
 
926
    }
 
927
    mDlg->modifyStats->setEnabled( statsModel->rowCount() );
 
928
    mDlg->removeStats->setEnabled( statsModel->rowCount() );
 
929
 
 
930
    warnModel->removeRows(0, warnModel->rowCount() );
 
931
    foreach( WarnRule warn, settings->warnRules )
 
932
    {
 
933
        warnModel->addWarn( warn );
 
934
    }
 
935
    updateWarnText( statsModel->rowCount() );
 
936
 
 
937
    mDlg->modifyWarn->setEnabled( warnModel->rowCount() );
 
938
    mDlg->removeWarn->setEnabled( warnModel->rowCount() );
 
939
    if ( warnModel->rowCount() )
 
940
    {
 
941
        mDlg->warnView->setCurrentIndex( warnModel->indexFromItem ( warnModel->item( 0, 0 ) ) );
 
942
    }
709
943
 
710
944
    mDlg->listViewCommands->clear();
711
945
    QList<QTreeWidgetItem *>items;
761
995
        QListWidgetItem *item = new QListWidgetItem( ifname );
762
996
        mDlg->listBoxInterfaces->addItem( item );
763
997
        InterfaceSettings *settings = new InterfaceSettings();
764
 
        mCalendar = KCalendarSystem::create( mDefaultCalendarType );
765
 
        settings->billingStart = QDate::currentDate().addDays( 1 - mCalendar->day( QDate::currentDate() ) );
766
998
        KColorScheme scheme(QPalette::Active, KColorScheme::View);
767
999
        settings->colorDisabled = scheme.foreground( KColorScheme::InactiveText ).color();
768
1000
        settings->colorUnavailable = scheme.foreground( KColorScheme::InactiveText ).color();
 
1001
        settings->colorBackground = scheme.foreground( KColorScheme::InactiveText ).color();
769
1002
        settings->iconFont = KGlobalSettings::generalFont();
770
1003
        mSettingsMap.insert( ifname, settings );
771
1004
        mDlg->listBoxInterfaces->setCurrentRow( mDlg->listBoxInterfaces->row( item ) );
819
1052
        if ( mSettingsMap.contains( ifname ) )
820
1053
            continue;
821
1054
        InterfaceSettings* settings = new InterfaceSettings();
822
 
        mCalendar = KCalendarSystem::create( mDefaultCalendarType );
823
 
        settings->billingStart = QDate::currentDate().addDays( 1 - mCalendar->day( QDate::currentDate() ) );
824
1055
        KColorScheme scheme(QPalette::Active, KColorScheme::View);
825
1056
        settings->colorDisabled = scheme.foreground( KColorScheme::InactiveText ).color();
826
1057
        settings->colorUnavailable = scheme.foreground( KColorScheme::InactiveText ).color();
 
1058
        settings->colorBackground = scheme.foreground( KColorScheme::InactiveText ).color();
827
1059
        settings->iconFont = KGlobalSettings::generalFont();
828
1060
        mSettingsMap.insert( ifname, settings );
829
1061
        mDlg->listBoxInterfaces->addItem( ifname );
930
1162
    QLinearGradient outGrad( 3, 0, 10, 0 );
931
1163
    QLinearGradient topOutGrad( 3, 0, 10, 0 );
932
1164
 
933
 
    QColor topColor = mDlg->colorUnavailable->color();
934
 
    QColor topColorD = mDlg->colorUnavailable->color().darker();
 
1165
    QColor topColor = getItemSettings()->colorBackground;
 
1166
    QColor topColorD = getItemSettings()->colorBackground.darker();
935
1167
    topColor.setAlpha( 128 );
936
1168
    topColorD.setAlpha( 128 );
937
1169
    topInGrad.setColorAt(0, topColorD);
1117
1349
    if ( !settings )
1118
1350
        return;
1119
1351
 
1120
 
    ThemeConfig t( *settings );
1121
 
    if ( t.exec() )
 
1352
    ThemeConfig dlg( *settings );
 
1353
    if ( dlg.exec() )
1122
1354
    {
1123
 
        InterfaceSettings s = t.getSettings();
 
1355
        InterfaceSettings s = dlg.settings();
1124
1356
        settings->trafficThreshold = s.trafficThreshold;
1125
1357
        settings->dynamicColor = s.dynamicColor;
1126
1358
        settings->colorIncomingMax = s.colorIncomingMax;
1134
1366
    }
1135
1367
}
1136
1368
 
 
1369
void ConfigDialog::addStatsClicked()
 
1370
{
 
1371
    InterfaceSettings* settings = getItemSettings();
 
1372
    if ( !settings )
 
1373
        return;
 
1374
 
 
1375
    StatsRule rule;
 
1376
    int oldRuleCount = statsModel->rowCount();
 
1377
    StatsConfig dlg( settings, mCalendar, rule, true );
 
1378
    if ( dlg.exec() )
 
1379
    {
 
1380
        rule = dlg.settings();
 
1381
        QSortFilterProxyModel* proxy = static_cast<QSortFilterProxyModel*>(mDlg->statsView->model());
 
1382
        QModelIndex index = statsModel->addRule( rule );
 
1383
        mDlg->statsView->setCurrentIndex( proxy->mapFromSource( index ) );
 
1384
        settings->statsRules = statsModel->getRules();
 
1385
        mDlg->modifyStats->setEnabled( true );
 
1386
        mDlg->removeStats->setEnabled( true );
 
1387
        updateWarnText( oldRuleCount );
 
1388
        changed( true );
 
1389
    }
 
1390
}
 
1391
 
 
1392
void ConfigDialog::modifyStatsClicked()
 
1393
{
 
1394
    InterfaceSettings* settings = getItemSettings();
 
1395
    if ( !settings || mDlg->statsView->model()->rowCount() < 1 )
 
1396
        return;
 
1397
 
 
1398
    QModelIndex index = mDlg->statsView->selectionModel()->currentIndex();
 
1399
    if ( !index.isValid() )
 
1400
        return;
 
1401
    QSortFilterProxyModel* proxy = static_cast<QSortFilterProxyModel*>(mDlg->statsView->model());
 
1402
    index = proxy->mapToSource( index );
 
1403
    StatsRule s = statsModel->item( index.row(), 0 )->data( Qt::UserRole ).value<StatsRule>();
 
1404
    StatsConfig dlg( settings, mCalendar, s, false );
 
1405
    if ( dlg.exec() )
 
1406
    {
 
1407
        s = dlg.settings();
 
1408
        statsModel->modifyRule( index, s );
 
1409
        settings->statsRules = statsModel->getRules();
 
1410
        changed( true );
 
1411
    }
 
1412
}
 
1413
 
 
1414
void ConfigDialog::removeStatsClicked()
 
1415
{
 
1416
    InterfaceSettings* settings = getItemSettings();
 
1417
    if ( !settings || mDlg->statsView->model()->rowCount() < 1 )
 
1418
        return;
 
1419
 
 
1420
    QModelIndex index = mDlg->statsView->selectionModel()->currentIndex();
 
1421
    if ( !index.isValid() )
 
1422
        return;
 
1423
    QSortFilterProxyModel* proxy = static_cast<QSortFilterProxyModel*>(mDlg->statsView->model());
 
1424
    index = proxy->mapToSource( index );
 
1425
    statsModel->removeRow( index.row() );
 
1426
    settings->statsRules = statsModel->getRules();
 
1427
    mDlg->modifyStats->setEnabled( statsModel->rowCount() );
 
1428
    mDlg->removeStats->setEnabled( statsModel->rowCount() );
 
1429
    updateWarnText( statsModel->rowCount() );
 
1430
    changed( true );
 
1431
}
 
1432
 
 
1433
void ConfigDialog::addWarnClicked()
 
1434
{
 
1435
    InterfaceSettings* settings = getItemSettings();
 
1436
    if ( !settings )
 
1437
        return;
 
1438
 
 
1439
    WarnRule warn;
 
1440
    WarnConfig dlg( settings, warn, true );
 
1441
    if ( dlg.exec() )
 
1442
    {
 
1443
        warn = dlg.settings();
 
1444
        QModelIndex index = warnModel->addWarn( warn );
 
1445
        mDlg->warnView->setCurrentIndex( index );
 
1446
        settings->warnRules = warnModel->getRules();
 
1447
        changed( true );
 
1448
        mDlg->modifyWarn->setEnabled( true );
 
1449
        mDlg->removeWarn->setEnabled( true );
 
1450
    }
 
1451
}
 
1452
 
 
1453
void ConfigDialog::modifyWarnClicked()
 
1454
{
 
1455
    InterfaceSettings* settings = getItemSettings();
 
1456
    if ( !settings || mDlg->warnView->model()->rowCount() < 1 )
 
1457
        return;
 
1458
 
 
1459
    const QModelIndex index = mDlg->warnView->selectionModel()->currentIndex();
 
1460
    if ( !index.isValid() )
 
1461
        return;
 
1462
    WarnRule warn = mDlg->warnView->model()->data( index.sibling( index.row(), 0 ), Qt::UserRole ).value<WarnRule>();
 
1463
    WarnConfig dlg( settings, warn, false );
 
1464
    if ( dlg.exec() )
 
1465
    {
 
1466
        warn = dlg.settings();
 
1467
        warnModel->modifyWarn( index, warn );
 
1468
        settings->warnRules = warnModel->getRules();
 
1469
        changed( true );
 
1470
    }
 
1471
}
 
1472
 
 
1473
void ConfigDialog::removeWarnClicked()
 
1474
{
 
1475
    InterfaceSettings* settings = getItemSettings();
 
1476
    if ( !settings || mDlg->warnView->model()->rowCount() < 1 )
 
1477
        return;
 
1478
 
 
1479
    const QModelIndex index = mDlg->warnView->selectionModel()->currentIndex();
 
1480
    if ( !index.isValid() )
 
1481
        return;
 
1482
    warnModel->removeRow( index.row() );
 
1483
    settings->warnRules = warnModel->getRules();
 
1484
    mDlg->modifyWarn->setEnabled( warnModel->rowCount() );
 
1485
    mDlg->removeWarn->setEnabled( warnModel->rowCount() );
 
1486
    changed( true );
 
1487
}
 
1488
 
 
1489
 
1137
1490
 
1138
1491
/******************************************
1139
1492
 *                                        *
1151
1504
    if (!mLock) changed( true );
1152
1505
}
1153
1506
 
1154
 
void ConfigDialog::checkBoxCustomBillingToggled( bool on )
1155
 
{
1156
 
    InterfaceSettings* settings = getItemSettings();
1157
 
    if ( !settings )
1158
 
        return;
1159
 
 
1160
 
    settings->customBilling = on;
1161
 
    if ( on )
1162
 
        mDlg->warnType->setItemText( NotifyMonth, i18n( "Billing Period" ) );
1163
 
    else
1164
 
        mDlg->warnType->setItemText( NotifyMonth, i18n( "Month" ) );
1165
 
 
1166
 
    mDlg->billingStartInput->setDate( QDate::currentDate().addDays( 1 - mCalendar->day( QDate::currentDate() ) ) );
1167
 
    mDlg->billingMonthsInput->setValue( 1 );
1168
 
    if (!mLock) changed( true );
1169
 
}
1170
 
 
1171
 
void ConfigDialog::billingStartInputChanged( const QDate& date )
1172
 
{
1173
 
    InterfaceSettings* settings = getItemSettings();
1174
 
    if ( !settings )
1175
 
        return;
1176
 
 
1177
 
    // KDateEdit doesn't guarantee a valid date
1178
 
    if ( !date.isValid() ||
1179
 
         date > QDate::currentDate() ||
1180
 
         mCalendar->day( date ) > mMaxDay )
1181
 
    {
1182
 
        KMessageBox::error( this, i18n( "The billing day of the month can be any day from 1 - %1, and the complete date must be a valid, non-future date.", QString::number( mMaxDay ) ) );
1183
 
        mDlg->billingStartInput->setDate( settings->billingStart );
1184
 
    }
1185
 
    else
1186
 
    {
1187
 
        settings->billingStart = date;
1188
 
        if (!mLock) changed( true );
1189
 
    }
1190
 
}
1191
 
 
1192
 
void ConfigDialog::billingMonthsInputChanged( int value )
1193
 
{
1194
 
    InterfaceSettings* settings = getItemSettings();
1195
 
    if ( !settings )
1196
 
        return;
1197
 
 
1198
 
    settings->billingMonths = value;
1199
 
    if (!mLock) changed( true );
1200
 
}
1201
 
 
1202
 
void ConfigDialog::warnThresholdChanged( double val )
1203
 
{
1204
 
    InterfaceSettings* settings = getItemSettings();
1205
 
    if ( !settings )
1206
 
        return;
1207
 
 
1208
 
    settings->warnThreshold = round(val*10.0)/10.0;
1209
 
    // If single stepping through values and we go back to 0.0,
1210
 
    // we might not get the specialValueText
1211
 
    if ( val != settings->warnThreshold )
1212
 
        mDlg->warnThreshold->setValue( settings->warnThreshold );
1213
 
    bool enable = settings->warnThreshold > 0.0;
1214
 
    mDlg->warnRx->setEnabled( enable );
1215
 
    mDlg->warnRxTx->setEnabled( enable );
1216
 
    mDlg->warnUnits->setEnabled( enable );
1217
 
    mDlg->warnPer->setEnabled( enable );
1218
 
    mDlg->warnType->setEnabled( enable );
1219
 
    if (!mLock) changed( true );
1220
 
}
1221
 
 
1222
 
void ConfigDialog::warnUnitsChanged( int val )
1223
 
{
1224
 
    InterfaceSettings* settings = getItemSettings();
1225
 
    if ( !settings )
1226
 
        return;
1227
 
 
1228
 
    settings->warnUnits = mDlg->warnUnits->itemData( val ).toInt();
1229
 
    if (!mLock) changed( true );
1230
 
}
1231
 
 
1232
 
void ConfigDialog::warnTypeChanged( int val )
1233
 
{
1234
 
    InterfaceSettings* settings = getItemSettings();
1235
 
    if ( !settings )
1236
 
        return;
1237
 
 
1238
 
    settings->warnType = mDlg->warnType->itemData( val ).toInt();
1239
 
    if (!mLock) changed( true );
1240
 
}
1241
 
 
1242
 
void ConfigDialog::warnRxTxToggled( bool on )
1243
 
{
1244
 
    InterfaceSettings* settings = getItemSettings();
1245
 
    if ( !settings )
1246
 
        return;
1247
 
 
1248
 
    settings->warnTotalTraffic = on;
1249
 
    if (!mLock) changed( true );
1250
 
}
1251
 
 
1252
1507
 
1253
1508
 
1254
1509
/******************************************