~ubuntu-branches/ubuntu/utopic/attica-kf5/utopic

« back to all changes in this revision

Viewing changes to src/achievement.cpp

  • Committer: Package Import Robot
  • Author(s): Maximiliano Curia
  • Date: 2014-07-15 10:53:09 UTC
  • Revision ID: package-import@ubuntu.com-20140715105309-nnjxenwcs6h4qznf
Tags: upstream-5.0.0
ImportĀ upstreamĀ versionĀ 5.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*
 
2
    This file is part of KDE.
 
3
 
 
4
    Copyright (c) 2011 Laszlo Papp <djszapi@archlinux.us>
 
5
 
 
6
    This library is free software; you can redistribute it and/or
 
7
    modify it under the terms of the GNU Lesser General Public
 
8
    License as published by the Free Software Foundation; either
 
9
    version 2.1 of the License, or (at your option) version 3, or any
 
10
    later version accepted by the membership of KDE e.V. (or its
 
11
    successor approved by the membership of KDE e.V.), which shall
 
12
    act as a proxy defined in Section 6 of version 3 of the license.
 
13
 
 
14
    This library is distributed in the hope that it will be useful,
 
15
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
17
    Lesser General Public License for more details.
 
18
 
 
19
    You should have received a copy of the GNU Lesser General Public
 
20
    License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
21
 
 
22
*/
 
23
 
 
24
#include "achievement.h"
 
25
 
 
26
using namespace Attica;
 
27
 
 
28
Achievement::Type Achievement::stringToAchievementType(const QString &achievementTypeString)
 
29
{
 
30
    if (achievementTypeString == QLatin1String("flowing")) {
 
31
        return Achievement::FlowingAchievement;
 
32
    } else if (achievementTypeString == QLatin1String("stepped")) {
 
33
        return Achievement::SteppedAchievement;
 
34
    } else if (achievementTypeString == QLatin1String("namedsteps")) {
 
35
        return Achievement::NamedstepsAchievement;
 
36
    } else if (achievementTypeString == QLatin1String("set")) {
 
37
        return Achievement::SetAchievement;
 
38
    }
 
39
 
 
40
    Q_ASSERT(false);
 
41
    return Achievement::FlowingAchievement;
 
42
}
 
43
 
 
44
QString Achievement::achievementTypeToString(const Achievement::Type type)
 
45
{
 
46
    switch (type) {
 
47
    case Achievement::FlowingAchievement:
 
48
        return QLatin1String("flowing");
 
49
        break;
 
50
    case Achievement::SteppedAchievement:
 
51
        return QLatin1String("stepped");
 
52
        break;
 
53
    case Achievement::NamedstepsAchievement:
 
54
        return QLatin1String("namedsteps");
 
55
        break;
 
56
    case Achievement::SetAchievement:
 
57
        return QLatin1String("set");
 
58
        break;
 
59
    }
 
60
 
 
61
    Q_ASSERT(false);
 
62
    return QString();
 
63
}
 
64
 
 
65
Achievement::Visibility Achievement::stringToAchievementVisibility(const QString &achievementVisibilityString)
 
66
{
 
67
    if (achievementVisibilityString == QLatin1String("visible")) {
 
68
        return Achievement::VisibleAchievement;
 
69
    } else if (achievementVisibilityString == QLatin1String("dependents")) {
 
70
        return Achievement::DependentsAchievement;
 
71
    } else if (achievementVisibilityString == QLatin1String("secret")) {
 
72
        return Achievement::SecretAchievement;
 
73
    }
 
74
 
 
75
    Q_ASSERT(false);
 
76
    return Achievement::VisibleAchievement;
 
77
}
 
78
 
 
79
QString Achievement::achievementVisibilityToString(const Achievement::Visibility visibility)
 
80
{
 
81
    switch (visibility) {
 
82
    case Achievement::VisibleAchievement:
 
83
        return QLatin1String("visible");
 
84
        break;
 
85
    case Achievement::DependentsAchievement:
 
86
        return QLatin1String("dependents");
 
87
        break;
 
88
    case Achievement::SecretAchievement:
 
89
        return QLatin1String("secret");
 
90
        break;
 
91
    }
 
92
 
 
93
    Q_ASSERT(false);
 
94
    return QString();
 
95
}
 
96
 
 
97
class Achievement::Private : public QSharedData
 
98
{
 
99
public:
 
100
    QString m_id;
 
101
    QString m_contentId;
 
102
    QString m_name;
 
103
    QString m_description;
 
104
    QString m_explanation;
 
105
    int m_points;
 
106
    QUrl m_image;
 
107
    QStringList m_dependencies;
 
108
    Achievement::Visibility m_visibility;
 
109
    Achievement::Type m_type;
 
110
    QStringList m_options;
 
111
    int m_steps;
 
112
    QVariant m_progress;
 
113
 
 
114
    Private()
 
115
        : m_points(0),
 
116
          m_steps(0)
 
117
    {
 
118
    }
 
119
};
 
120
 
 
121
Achievement::Achievement()
 
122
    : d(new Private)
 
123
{
 
124
}
 
125
 
 
126
Achievement::Achievement(const Achievement &other)
 
127
    : d(other.d)
 
128
{
 
129
}
 
130
 
 
131
Achievement &Achievement::operator=(const Attica::Achievement &other)
 
132
{
 
133
    d = other.d;
 
134
    return *this;
 
135
}
 
136
 
 
137
Achievement::~Achievement()
 
138
{
 
139
}
 
140
 
 
141
void Achievement::setId(const QString &id)
 
142
{
 
143
    d->m_id = id;
 
144
}
 
145
 
 
146
QString Achievement::id() const
 
147
{
 
148
    return d->m_id;
 
149
}
 
150
 
 
151
void Achievement::setContentId(const QString &contentId)
 
152
{
 
153
    d->m_contentId = contentId;
 
154
}
 
155
 
 
156
QString Achievement::contentId() const
 
157
{
 
158
    return d->m_contentId;
 
159
}
 
160
 
 
161
void Achievement::setName(const QString &name)
 
162
{
 
163
    d->m_name = name;
 
164
}
 
165
 
 
166
QString Achievement::name() const
 
167
{
 
168
    return d->m_name;
 
169
}
 
170
 
 
171
void Achievement::setDescription(const QString &description)
 
172
{
 
173
    d->m_description = description;
 
174
}
 
175
 
 
176
QString Achievement::description() const
 
177
{
 
178
    return d->m_description;
 
179
}
 
180
 
 
181
void Achievement::setExplanation(const QString &explanation)
 
182
{
 
183
    d->m_explanation = explanation;
 
184
}
 
185
 
 
186
QString Achievement::explanation() const
 
187
{
 
188
    return d->m_explanation;
 
189
}
 
190
 
 
191
void Achievement::setPoints(const int points)
 
192
{
 
193
    d->m_points = points;
 
194
}
 
195
 
 
196
int Achievement::points() const
 
197
{
 
198
    return d->m_points;
 
199
}
 
200
 
 
201
void Achievement::setImage(const QUrl &image)
 
202
{
 
203
    d->m_image = image;
 
204
}
 
205
 
 
206
QUrl Achievement::image() const
 
207
{
 
208
    return d->m_image;
 
209
}
 
210
 
 
211
void Achievement::setDependencies(const QStringList &dependencies)
 
212
{
 
213
    d->m_dependencies = dependencies;
 
214
}
 
215
 
 
216
void Achievement::addDependency(const QString &dependency)
 
217
{
 
218
    d->m_dependencies.append(dependency);
 
219
}
 
220
 
 
221
void Achievement::removeDependency(const QString &dependency)
 
222
{
 
223
    d->m_dependencies.removeOne(dependency);
 
224
}
 
225
 
 
226
QStringList Achievement::dependencies() const
 
227
{
 
228
    return d->m_dependencies;
 
229
}
 
230
 
 
231
void Achievement::setVisibility(Achievement::Visibility visibility)
 
232
{
 
233
    d->m_visibility = visibility;
 
234
}
 
235
 
 
236
Achievement::Visibility Achievement::visibility() const
 
237
{
 
238
    return d->m_visibility;
 
239
}
 
240
 
 
241
void Achievement::setType(Achievement::Type type)
 
242
{
 
243
    d->m_type = type;
 
244
}
 
245
 
 
246
Achievement::Type Achievement::type() const
 
247
{
 
248
    return d->m_type;
 
249
}
 
250
 
 
251
void Achievement::setOptions(const QStringList &options)
 
252
{
 
253
    d->m_options = options;
 
254
}
 
255
 
 
256
void Achievement::addOption(const QString &option)
 
257
{
 
258
    d->m_options.append(option);
 
259
}
 
260
 
 
261
void Achievement::removeOption(const QString &option)
 
262
{
 
263
    d->m_options.removeOne(option);
 
264
}
 
265
 
 
266
QStringList Achievement::options() const
 
267
{
 
268
    return d->m_options;
 
269
}
 
270
 
 
271
void Achievement::setSteps(const int steps)
 
272
{
 
273
    d->m_steps = steps;
 
274
}
 
275
 
 
276
int Achievement::steps() const
 
277
{
 
278
    return d->m_steps;
 
279
}
 
280
 
 
281
void Achievement::setProgress(const QVariant &progress)
 
282
{
 
283
    d->m_progress = progress;
 
284
}
 
285
 
 
286
QVariant Achievement::progress() const
 
287
{
 
288
    return d->m_progress;
 
289
}
 
290
 
 
291
bool Achievement::isValid() const
 
292
{
 
293
    return !(d->m_id.isEmpty());
 
294
}