← Back to branch summary

~ci-train-bot/ubuntuone-credentials/ubuntuone-credentials-ubuntu-zesty-2205

« back to all changes in this revision

Viewing changes to keyring/keyring_signal_mapper.cpp

  • Committer: Diego Sarmentero
  • Date: 2013-03-07 14:07:48 UTC
  • Revision ID: diego.sarmentero@gmail.com-20130307140748-5nud45oos0mx63r0
new folder structure

Show diffs side-by-side

added added

removed removed

Lines of Context:
keyring/keyring_signal_mapper.cpp
1
 
/**
2
 
 *
3
 
 * Copyright 2013 Canonical Ltd.
4
 
 * Author: Manuel de la Pena <manuel.delapena@canonical.com>
5
 
 *
6
 
 * This program is free software: you can redistribute it and/or modify it
7
 
 * under the terms of the GNU General Public License version 3, as published
8
 
 * by the Free Software Foundation.
9
 
 *
10
 
 * This program is distributed in the hope that it will be useful, but
11
 
 * WITHOUT ANY WARRANTY; without even the implied warranties of
12
 
 * MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
13
 
 * PURPOSE.  See the GNU General Public License for more details.
14
 
 *
15
 
 * You should have received a copy of the GNU General Public License along
16
 
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
17
 
 *
18
 
 * In addition, as a special exception, the copyright holders give
19
 
 * permission to link the code of portions of this program with the
20
 
 * OpenSSL library under certain conditions as described in each
21
 
 * individual source file, and distribute linked combinations
22
 
 * including the two.
23
 
 * You must obey the GNU General Public License in all respects
24
 
 * for all of the code used other than OpenSSL.  If you modify
25
 
 * file(s) with this exception, you may extend this exception to your
26
 
 * version of the file(s), but you are not obligated to do so.  If you
27
 
 * do not wish to do so, delete this exception statement from your
28
 
 * version.  If you delete this exception statement from all source
29
 
 * files in the program, then also delete it here.
30
 
 */
31
 
 
32
 
#include "keyring_signal_mapper.h"
33
 
 
34
 
 
35
 
namespace keyring
36
 
{
37
 
 
38
 
KeyringSignalMapper::_init KeyringSignalMapper::_initializer;
39
 
 
40
 
class KeyringSignalMapperPrivate
41
 
{
42
 
    Q_DECLARE_PUBLIC(KeyringSignalMapper)
43
 
 public:
44
 
    KeyringSignalMapperPrivate(KeyringSignalMapper* parent) :
45
 
        q_ptr(parent) {}
46
 
 
47
 
    void _q_senderDestroyed() {
48
 
        Q_Q(KeyringSignalMapper);
49
 
        q->removeMappings(q->sender());
50
 
    }
51
 
    QHash<QObject*, int> intHash;
52
 
    QHash<QObject*, QString> stringHash;
53
 
    QHash<QObject*, QWidget*> widgetHash;
54
 
    QHash<QObject*, QObject*> objectHash;
55
 
 
56
 
private:
57
 
    KeyringSignalMapper* q_ptr;
58
 
};
59
 
 
60
 
KeyringSignalMapper::KeyringSignalMapper(QObject *parent) :
61
 
    QObject(parent),
62
 
    d_ptr(new KeyringSignalMapperPrivate(this))
63
 
{
64
 
}
65
 
 
66
 
KeyringSignalMapper::~KeyringSignalMapper()
67
 
{
68
 
}
69
 
 
70
 
void KeyringSignalMapper::setMapping(QObject* sender, int id)
71
 
{
72
 
    Q_D(KeyringSignalMapper);
73
 
    d->intHash.insert(sender, id);
74
 
    connect(sender, SIGNAL(destroyed()), this, SLOT(_q_senderDestroyed()));
75
 
}
76
 
 
77
 
void KeyringSignalMapper::setMapping(QObject* sender, const QString &text)
78
 
{
79
 
    Q_D(KeyringSignalMapper);
80
 
    d->stringHash.insert(sender, text);
81
 
    connect(sender, SIGNAL(destroyed()), this, SLOT(_q_senderDestroyed()));
82
 
}
83
 
 
84
 
void KeyringSignalMapper::setMapping(QObject* sender, QWidget *widget)
85
 
{
86
 
    Q_D(KeyringSignalMapper);
87
 
    d->widgetHash.insert(sender, widget);
88
 
    connect(sender, SIGNAL(destroyed()), this, SLOT(_q_senderDestroyed()));
89
 
}
90
 
 
91
 
void KeyringSignalMapper::setMapping(QObject* sender, QObject *object)
92
 
{
93
 
    Q_D(KeyringSignalMapper);
94
 
    d->objectHash.insert(sender, object);
95
 
    connect(sender, SIGNAL(destroyed()), this, SLOT(_q_senderDestroyed()));
96
 
}
97
 
 
98
 
QObject* KeyringSignalMapper::mapping(int id) const
99
 
{
100
 
    Q_D(const KeyringSignalMapper);
101
 
    return d->intHash.key(id);
102
 
}
103
 
 
104
 
QObject* KeyringSignalMapper::mapping(const QString& id) const
105
 
{
106
 
    Q_D(const KeyringSignalMapper);
107
 
    return d->stringHash.key(id);
108
 
}
109
 
 
110
 
QObject* KeyringSignalMapper::mapping(QWidget* widget) const
111
 
{
112
 
    Q_D(const KeyringSignalMapper);
113
 
    return d->widgetHash.key(widget);
114
 
}
115
 
 
116
 
QObject* KeyringSignalMapper::mapping(QObject* object) const
117
 
{
118
 
    Q_D(const KeyringSignalMapper);
119
 
    return d->objectHash.key(object);
120
 
}
121
 
 
122
 
void KeyringSignalMapper::removeMappings(QObject* sender)
123
 
{
124
 
    Q_D(KeyringSignalMapper);
125
 
 
126
 
    d->intHash.remove(sender);
127
 
    d->stringHash.remove(sender);
128
 
    d->widgetHash.remove(sender);
129
 
    d->objectHash.remove(sender);
130
 
}
131
 
 
132
 
void KeyringSignalMapper::map(bool dismissed, const QDBusVariant result)
133
 
{
134
 
    map(dismissed, result, sender());
135
 
}
136
 
 
137
 
void KeyringSignalMapper::map(bool dismissed, const QDBusVariant result, QObject* sender)
138
 
{
139
 
    Q_D(KeyringSignalMapper);
140
 
    if (d->intHash.contains(sender))
141
 
        emit mapped(dismissed, result, d->intHash.value(sender));
142
 
    if (d->stringHash.contains(sender))
143
 
        emit mapped(dismissed, result, d->stringHash.value(sender));
144
 
    if (d->widgetHash.contains(sender))
145
 
        emit mapped(dismissed, result, d->widgetHash.value(sender));
146
 
    if (d->objectHash.contains(sender))
147
 
        emit mapped(dismissed, result, d->objectHash.value(sender));
148
 
}
149
 
 
150
 
QList<QObject*> KeyringSignalMapper::intMaps()
151
 
{
152
 
    Q_D(KeyringSignalMapper);
153
 
    return d->intHash.keys();
154
 
}
155
 
 
156
 
QList<QObject*> KeyringSignalMapper::stringMaps()
157
 
{
158
 
    Q_D(KeyringSignalMapper);
159
 
    return d->stringHash.keys();
160
 
}
161
 
 
162
 
QList<QObject*> KeyringSignalMapper::widgetMaps()
163
 
{
164
 
    Q_D(KeyringSignalMapper);
165
 
    return d->widgetHash.keys();
166
 
}
167
 
 
168
 
QList<QObject*> KeyringSignalMapper::objectMaps()
169
 
{
170
 
    Q_D(KeyringSignalMapper);
171
 
    return d->objectHash.keys();
172
 
}
173
 
 
174
 
 
175
 
} // keyring
176
 
 
177
 
#include "moc_keyring_signal_mapper.cpp"