← Back to branch summary

~ubuntu-branches/ubuntu/trusty/sflphone/trusty

« back to all changes in this revision

Viewing changes to kde/src/lib/audiocodecmodel.cpp

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (4.3.4 sid)
  • Revision ID: package-import@ubuntu.com-20140128182336-jrsv0k9u6cawc068
Tags: 1.3.0-1
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
kde/src/lib/audiocodecmodel.cpp
1
1
/****************************************************************************
2
 
 *   Copyright (C) 2012-2013 by Savoir-Faire Linux                          *
 
2
 *   Copyright (C) 2012-2014 by Savoir-Faire Linux                          *
3
3
 *   Author : Emmanuel Lepage Vallee <emmanuel.lepage@savoirfairelinux.com> *
4
4
 *                                                                          *
5
5
 *   This library is free software; you can redistribute it and/or          *
19
19
 
20
20
//Qt
21
21
#include <QtCore/QDebug>
 
22
#include <QtCore/QCoreApplication>
 
23
 
 
24
//SFLPhone
 
25
#include "account.h"
 
26
#include "dbus/configurationmanager.h"
22
27
 
23
28
///Constructor
24
 
AudioCodecModel::AudioCodecModel(QObject* parent) : QAbstractListModel(parent) {
25
 
 
 
29
AudioCodecModel::AudioCodecModel(Account* account) :
 
30
QAbstractListModel(account?(QObject*)account:(QObject*)QCoreApplication::instance()),m_pAccount(account)
 
31
{
 
32
   setObjectName("AudioCodecModel: "+account->id());
 
33
   QHash<int, QByteArray> roles = roleNames();
 
34
   roles.insert(AudioCodecModel::Role::ID        ,QByteArray("id"));
 
35
   roles.insert(AudioCodecModel::Role::NAME      ,QByteArray("name"));
 
36
   roles.insert(AudioCodecModel::Role::BITRATE   ,QByteArray("bitrate"));
 
37
   roles.insert(AudioCodecModel::Role::SAMPLERATE,QByteArray("samplerate"));
 
38
   setRoleNames(roles);
26
39
}
27
40
 
28
41
///Model data
29
 
QVariant AudioCodecModel::data(const QModelIndex& index, int role) const {
30
 
   if(index.column() == 0      && role == Qt::DisplayRole                   ) {
31
 
      return QVariant(m_lAudioCodecs[index.row()]->name);
32
 
   }
33
 
   else if(index.column() == 0 && role == Qt::CheckStateRole                ) {
34
 
      return QVariant(m_lEnabledCodecs[m_lAudioCodecs[index.row()]->id] ? Qt::Checked : Qt::Unchecked);
35
 
   }
36
 
   else if (index.column() == 0 && role == AudioCodecModel::NAME_ROLE       ) {
37
 
      return m_lAudioCodecs[index.row()]->name;
38
 
   }
39
 
   else if (index.column() == 0 && role == AudioCodecModel::BITRATE_ROLE    ) {
40
 
      return m_lAudioCodecs[index.row()]->bitrate;
41
 
   }
42
 
   else if (index.column() == 0 && role == AudioCodecModel::SAMPLERATE_ROLE ) {
43
 
      return m_lAudioCodecs[index.row()]->samplerate;
44
 
   }
45
 
   else if (index.column() == 0 && role == AudioCodecModel::ID_ROLE         ) {
46
 
      return m_lAudioCodecs[index.row()]->id;
 
42
QVariant AudioCodecModel::data(const QModelIndex& idx, int role) const {
 
43
   if(idx.column() == 0      && role == Qt::DisplayRole                   ) {
 
44
      return QVariant(m_lAudioCodecs[idx.row()]->name);
 
45
   }
 
46
   else if(idx.column() == 0 && role == Qt::CheckStateRole                ) {
 
47
      return QVariant(m_lEnabledCodecs[m_lAudioCodecs[idx.row()]->id] ? Qt::Checked : Qt::Unchecked);
 
48
   }
 
49
   else if (idx.column() == 0 && role == AudioCodecModel::Role::NAME       ) {
 
50
      return m_lAudioCodecs[idx.row()]->name;
 
51
   }
 
52
   else if (idx.column() == 0 && role == AudioCodecModel::Role::BITRATE    ) {
 
53
      return m_lAudioCodecs[idx.row()]->bitrate;
 
54
   }
 
55
   else if (idx.column() == 0 && role == AudioCodecModel::Role::SAMPLERATE ) {
 
56
      return m_lAudioCodecs[idx.row()]->samplerate;
 
57
   }
 
58
   else if (idx.column() == 0 && role == AudioCodecModel::Role::ID         ) {
 
59
      return m_lAudioCodecs[idx.row()]->id;
47
60
   }
48
61
   return QVariant();
49
62
}
50
63
 
51
64
///Number of audio codecs
52
 
int AudioCodecModel::rowCount(const QModelIndex& parent) const {
53
 
   Q_UNUSED(parent)
 
65
int AudioCodecModel::rowCount(const QModelIndex& par) const {
 
66
   Q_UNUSED(par)
54
67
   return m_lAudioCodecs.size();
55
68
}
56
69
 
57
70
///Model flags
58
 
Qt::ItemFlags AudioCodecModel::flags(const QModelIndex& index) const {
59
 
   if (index.column() == 0)
60
 
      return QAbstractItemModel::flags(index) | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable;
61
 
   return QAbstractItemModel::flags(index);
 
71
Qt::ItemFlags AudioCodecModel::flags(const QModelIndex& idx) const {
 
72
   if (idx.column() == 0)
 
73
      return QAbstractItemModel::flags(idx) | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 
74
   return QAbstractItemModel::flags(idx);
62
75
}
63
76
 
64
77
///Set audio codec data
65
 
bool AudioCodecModel::setData( const QModelIndex& index, const QVariant &value, int role) {
66
 
   if (index.column() == 0 && role == AudioCodecModel::NAME_ROLE) {
67
 
      m_lAudioCodecs[index.row()]->name = value.toString();
68
 
      emit dataChanged(index, index);
69
 
      return true;
70
 
   }
71
 
   else if (index.column() == 0 && role == AudioCodecModel::BITRATE_ROLE) {
72
 
      m_lAudioCodecs[index.row()]->bitrate = value.toString();
73
 
      emit dataChanged(index, index);
74
 
      return true;
75
 
   }
76
 
   else if(index.column() == 0 && role == Qt::CheckStateRole) {
77
 
      m_lEnabledCodecs[m_lAudioCodecs[index.row()]->id] = value.toBool();
78
 
      emit dataChanged(index, index);
79
 
      return true;
80
 
   }
81
 
   else if (index.column() == 0 && role == AudioCodecModel::SAMPLERATE_ROLE) {
82
 
      m_lAudioCodecs[index.row()]->samplerate = value.toString();
83
 
      emit dataChanged(index, index);
84
 
      return true;
85
 
   }
86
 
   else if (index.column() == 0 && role == AudioCodecModel::ID_ROLE) {
87
 
      m_lAudioCodecs[index.row()]->id = value.toInt();
88
 
      emit dataChanged(index, index);
 
78
bool AudioCodecModel::setData( const QModelIndex& idx, const QVariant &value, int role) {
 
79
   if (idx.column() == 0 && role == AudioCodecModel::NAME) {
 
80
      m_lAudioCodecs[idx.row()]->name = value.toString();
 
81
      emit dataChanged(idx, idx);
 
82
      return true;
 
83
   }
 
84
   else if (idx.column() == 0 && role == AudioCodecModel::BITRATE) {
 
85
      m_lAudioCodecs[idx.row()]->bitrate = value.toString();
 
86
      emit dataChanged(idx, idx);
 
87
      return true;
 
88
   }
 
89
   else if(idx.column() == 0 && role == Qt::CheckStateRole) {
 
90
      m_lEnabledCodecs[m_lAudioCodecs[idx.row()]->id] = value.toBool();
 
91
      emit dataChanged(idx, idx);
 
92
      return true;
 
93
   }
 
94
   else if (idx.column() == 0 && role == AudioCodecModel::SAMPLERATE) {
 
95
      m_lAudioCodecs[idx.row()]->samplerate = value.toString();
 
96
      emit dataChanged(idx, idx);
 
97
      return true;
 
98
   }
 
99
   else if (idx.column() == 0 && role == AudioCodecModel::ID) {
 
100
      m_lAudioCodecs[idx.row()]->id = value.toInt();
 
101
      emit dataChanged(idx, idx);
89
102
      return true;
90
103
   }
91
104
   return false;
100
113
 
101
114
///Remove audio codec at 'idx'
102
115
void AudioCodecModel::removeAudioCodec(QModelIndex idx) {
103
 
   qDebug() << "REMOVING" << idx.row() << m_lAudioCodecs.size();
104
116
   if (idx.isValid()) {
 
117
      AudioCodecData* d = m_lAudioCodecs[idx.row()];
105
118
      m_lAudioCodecs.removeAt(idx.row());
 
119
      delete d;
106
120
      emit dataChanged(idx, index(m_lAudioCodecs.size()-1,0));
107
 
      qDebug() << "DONE" << m_lAudioCodecs.size();
108
121
   }
109
122
   else {
110
123
      qDebug() << "Failed to remove an invalid audio codec";
114
127
///Remove everything
115
128
void AudioCodecModel::clear()
116
129
{
117
 
   foreach(AudioCodecData* data, m_lAudioCodecs) {
118
 
      delete data;
 
130
   while(m_lAudioCodecs.size()) {
 
131
      AudioCodecData* d = m_lAudioCodecs[0];
 
132
      m_lAudioCodecs.removeAt(0);
 
133
      delete d;
119
134
   }
120
135
   m_lAudioCodecs.clear  ();
121
136
   m_lEnabledCodecs.clear();
125
140
bool AudioCodecModel::moveUp(QModelIndex idx)
126
141
{
127
142
   if(idx.row() > 0 && idx.row() <= rowCount()) {
128
 
      AudioCodecData* data = m_lAudioCodecs[idx.row()];
 
143
      AudioCodecData* data2 = m_lAudioCodecs[idx.row()];
129
144
      m_lAudioCodecs.removeAt(idx.row());
130
 
      m_lAudioCodecs.insert(idx.row() - 1, data);
 
145
      m_lAudioCodecs.insert(idx.row() - 1, data2);
131
146
      emit dataChanged(index(idx.row() - 1, 0, QModelIndex()), index(idx.row(), 0, QModelIndex()));
132
147
      return true;
133
148
   }
138
153
bool AudioCodecModel::moveDown(QModelIndex idx)
139
154
{
140
155
   if(idx.row() >= 0 && idx.row() < rowCount()) {
141
 
      AudioCodecData* data = m_lAudioCodecs[idx.row()];
 
156
      AudioCodecData* data2 = m_lAudioCodecs[idx.row()];
142
157
      m_lAudioCodecs.removeAt(idx.row());
143
 
      m_lAudioCodecs.insert(idx.row() + 1, data);
 
158
      m_lAudioCodecs.insert(idx.row() + 1, data2);
144
159
      emit dataChanged(index(idx.row(), 0, QModelIndex()), index(idx.row() + 1, 0, QModelIndex()));
145
160
      return true;
146
161
   }
147
162
   return false;
148
163
}
 
164
 
 
165
///Reload the codeclist
 
166
void AudioCodecModel::reload()
 
167
{
 
168
   ConfigurationManagerInterface& configurationManager = DBus::ConfigurationManager::instance();
 
169
   QVector<int> codecIdList = configurationManager.getAudioCodecList();
 
170
   if (!m_pAccount->isNew()) {
 
171
      QVector<int> activeCodecList = configurationManager.getActiveAudioCodecList(m_pAccount->id());
 
172
      QStringList tmpNameList;
 
173
 
 
174
      foreach (const int aCodec, activeCodecList) {
 
175
         if (!findCodec(aCodec)) {
 
176
            QStringList codec = configurationManager.getAudioCodecDetails(aCodec);
 
177
            QModelIndex idx = addAudioCodec();
 
178
            setData(idx,codec[0]     ,AudioCodecModel::Role::NAME       );
 
179
            setData(idx,codec[1]     ,AudioCodecModel::Role::SAMPLERATE );
 
180
            setData(idx,codec[2]     ,AudioCodecModel::Role::BITRATE    );
 
181
            setData(idx,aCodec       ,AudioCodecModel::Role::ID         );
 
182
            setData(idx, Qt::Checked ,Qt::CheckStateRole               );
 
183
            if (codecIdList.indexOf(aCodec)!=-1)
 
184
               codecIdList.remove(codecIdList.indexOf(aCodec));
 
185
         }
 
186
      }
 
187
   }
 
188
 
 
189
   foreach (const int aCodec, codecIdList) {
 
190
      if (!findCodec(aCodec)) {
 
191
         const QStringList codec = configurationManager.getAudioCodecDetails(aCodec);
 
192
         QModelIndex idx = addAudioCodec();
 
193
         setData(idx,codec[0],AudioCodecModel::Role::NAME       );
 
194
         setData(idx,codec[1],AudioCodecModel::Role::SAMPLERATE );
 
195
         setData(idx,codec[2],AudioCodecModel::Role::BITRATE    );
 
196
         setData(idx,aCodec  ,AudioCodecModel::Role::ID         );
 
197
         setData(idx, Qt::Unchecked ,Qt::CheckStateRole);
 
198
      }
 
199
   }
 
200
}
 
201
 
 
202
///Save details
 
203
void AudioCodecModel::save()
 
204
{
 
205
   QStringList _codecList;
 
206
   for (int i=0; i < rowCount();i++) {
 
207
      QModelIndex idx = index(i,0);
 
208
      if (data(idx,Qt::CheckStateRole) == Qt::Checked) {
 
209
         _codecList << data(idx,AudioCodecModel::Role::ID).toString();
 
210
      }
 
211
   }
 
212
 
 
213
   ConfigurationManagerInterface & configurationManager = DBus::ConfigurationManager::instance();
 
214
   configurationManager.setActiveAudioCodecList(_codecList, m_pAccount->id());
 
215
}
 
216
 
 
217
///Check is a codec is already in the list
 
218
bool AudioCodecModel::findCodec(int id)
 
219
{
 
220
   foreach(AudioCodecData* data, m_lAudioCodecs) {
 
221
      if (data->id == id)
 
222
         return true;
 
223
   }
 
224
   return false;
 
225
}