← Back to branch summary

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

« back to all changes in this revision

Viewing changes to kde/src/lib/credentialmodel.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/credentialmodel.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          *
18
18
#include "credentialmodel.h"
19
19
 
20
20
#include <QtCore/QDebug>
 
21
#include <QtCore/QCoreApplication>
21
22
 
22
23
///Constructor
23
 
CredentialModel::CredentialModel(QObject* parent) : QAbstractListModel(parent) {
 
24
CredentialModel::CredentialModel(QObject* par) : QAbstractListModel(par?par:QCoreApplication::instance())
 
25
{
 
26
   QHash<int, QByteArray> roles = roleNames();
 
27
   roles.insert(CredentialModel::Role::NAME    ,QByteArray("name"));
 
28
   roles.insert(CredentialModel::Role::PASSWORD,QByteArray("password"));
 
29
   roles.insert(CredentialModel::Role::REALM   ,QByteArray("realm"));
 
30
   setRoleNames(roles);
 
31
}
24
32
 
 
33
CredentialModel::~CredentialModel()
 
34
{
 
35
   foreach (CredentialData2* data, m_lCredentials) {
 
36
      delete data;
 
37
   }
25
38
}
26
39
 
27
40
///Model data
28
 
QVariant CredentialModel::data(const QModelIndex& index, int role) const {
29
 
   if (index.column() == 0) {
 
41
QVariant CredentialModel::data(const QModelIndex& idx, int role) const {
 
42
   if (idx.column() == 0) {
30
43
      switch (role) {
31
44
         case Qt::DisplayRole:
32
 
            return QVariant(m_lCredentials[index.row()]->name);
33
 
            break;
34
 
         case CredentialModel::NAME_ROLE:
35
 
            return m_lCredentials[index.row()]->name;
36
 
            break;
37
 
         case CredentialModel::PASSWORD_ROLE:
38
 
            return m_lCredentials[index.row()]->password;
39
 
            break;
40
 
         case CredentialModel::REALM_ROLE:
41
 
            return m_lCredentials[index.row()]->realm;
 
45
            return QVariant(m_lCredentials[idx.row()]->name);
 
46
            break;
 
47
         case CredentialModel::Role::NAME:
 
48
            return m_lCredentials[idx.row()]->name;
 
49
            break;
 
50
         case CredentialModel::Role::PASSWORD:
 
51
            return m_lCredentials[idx.row()]->password;
 
52
            break;
 
53
         case CredentialModel::Role::REALM:
 
54
            return m_lCredentials[idx.row()]->realm;
 
55
            break;
 
56
         default:
42
57
            break;
43
58
      }
44
59
   }
46
61
}
47
62
 
48
63
///Number of credentials
49
 
int CredentialModel::rowCount(const QModelIndex& parent) const {
50
 
   Q_UNUSED(parent)
 
64
int CredentialModel::rowCount(const QModelIndex& par) const {
 
65
   Q_UNUSED(par)
51
66
   return m_lCredentials.size();
52
67
}
53
68
 
54
69
///Model flags
55
 
Qt::ItemFlags CredentialModel::flags(const QModelIndex& index) const {
56
 
   if (index.column() == 0)
57
 
      return QAbstractItemModel::flags(index) /*| Qt::ItemIsUserCheckable*/ | Qt::ItemIsEnabled | Qt::ItemIsSelectable;
58
 
   return QAbstractItemModel::flags(index);
 
70
Qt::ItemFlags CredentialModel::flags(const QModelIndex& idx) const {
 
71
   if (idx.column() == 0)
 
72
      return QAbstractItemModel::flags(idx) /*| Qt::ItemIsUserCheckable*/ | Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 
73
   return QAbstractItemModel::flags(idx);
59
74
}
60
75
 
61
76
///Set credential data
62
 
bool CredentialModel::setData( const QModelIndex& index, const QVariant &value, int role) {
63
 
   if (index.column() == 0 && role == CredentialModel::NAME_ROLE) {
64
 
      m_lCredentials[index.row()]->name = value.toString();
65
 
      emit dataChanged(index, index);
66
 
      return true;
67
 
   }
68
 
   else if (index.column() == 0 && role == CredentialModel::PASSWORD_ROLE) {
69
 
      m_lCredentials[index.row()]->password = value.toString();
70
 
      emit dataChanged(index, index);
71
 
      return true;
72
 
   }
73
 
   else if (index.column() == 0 && role == CredentialModel::REALM_ROLE) {
74
 
      m_lCredentials[index.row()]->realm = value.toString();
75
 
      emit dataChanged(index, index);
 
77
bool CredentialModel::setData( const QModelIndex& idx, const QVariant &value, int role) {
 
78
   if (!idx.isValid() || idx.row() > m_lCredentials.size()-1)
 
79
      return false;
 
80
   if (idx.column() == 0 && role == CredentialModel::Role::NAME) {
 
81
      m_lCredentials[idx.row()]->name = value.toString();
 
82
      emit dataChanged(idx, idx);
 
83
      return true;
 
84
   }
 
85
   else if (idx.column() == 0 && role == CredentialModel::Role::PASSWORD) {
 
86
      m_lCredentials[idx.row()]->password = value.toString();
 
87
      emit dataChanged(idx, idx);
 
88
      return true;
 
89
   }
 
90
   else if (idx.column() == 0 && role == CredentialModel::Role::REALM) {
 
91
      m_lCredentials[idx.row()]->realm = value.toString();
 
92
      emit dataChanged(idx, idx);
76
93
      return true;
77
94
   }
78
95
   return false;
101
118
///Remove everything
102
119
void CredentialModel::clear()
103
120
{
104
 
   foreach(CredentialData2* data, m_lCredentials) {
105
 
      delete data;
 
121
   foreach(CredentialData2* data2, m_lCredentials) {
 
122
      delete data2;
106
123
   }
107
124
   m_lCredentials.clear();
108
125
}