GCC Code Coverage Report
Directory: src/ Exec Total Coverage
File: src/gui/widgets/tabs/setup_theme.cpp Lines: 149 245 60.8 %
Date: 2018-07-14 Branches: 220 804 27.4 %

Line Branch Exec Source
1
/*
2
 *  The ManaPlus Client
3
 *  Copyright (C) 2009  The Mana World Development Team
4
 *  Copyright (C) 2009-2010  Andrei Karas
5
 *  Copyright (C) 2011-2018  The ManaPlus Developers
6
 *
7
 *  This file is part of The ManaPlus Client.
8
 *
9
 *  This program is free software; you can redistribute it and/or modify
10
 *  it under the terms of the GNU General Public License as published by
11
 *  the Free Software Foundation; either version 2 of the License, or
12
 *  any later version.
13
 *
14
 *  This program 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
17
 *  GNU General Public License for more details.
18
 *
19
 *  You should have received a copy of the GNU General Public License
20
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
21
 */
22
23
#include "gui/widgets/tabs/setup_theme.h"
24
25
#include "gui/gui.h"
26
#include "gui/themeinfo.h"
27
28
#include "gui/windows/okdialog.h"
29
30
#include "gui/models/fontsizechoicelistmodel.h"
31
#include "gui/models/fontsmodel.h"
32
#include "gui/models/langlistmodel.h"
33
#include "gui/models/themesmodel.h"
34
35
#include "gui/widgets/button.h"
36
#include "gui/widgets/containerplacer.h"
37
#include "gui/widgets/createwidget.h"
38
#include "gui/widgets/dropdown.h"
39
#include "gui/widgets/label.h"
40
#include "gui/widgets/layouthelper.h"
41
42
#include "configuration.h"
43
44
#include "utils/delete2.h"
45
46
#include "debug.h"
47
48
const char* ACTION_THEME = "theme";
49
const char* ACTION_FONT = "font";
50
const char* ACTION_LANG = "lang";
51
const char* ACTION_BOLD_FONT = "bold font";
52
const char* ACTION_PARTICLE_FONT = "particle font";
53
const char* ACTION_HELP_FONT = "help font";
54
const char* ACTION_SECURE_FONT = "secure font";
55
const char* ACTION_NPC_FONT = "npc font";
56
const char* ACTION_JAPAN_FONT = "japanese font";
57
const char* ACTION_CHINA_FONT = "chinese font";
58
const char* ACTION_INFO = "info";
59
60
2
Setup_Theme::Setup_Theme(const Widget2 *const widget) :
61
    SetupTab(widget),
62
    // TRANSLATORS: theme settings label
63

4
    mThemeLabel(new Label(this, _("Gui theme"))),
64

2
    mThemesModel(new ThemesModel),
65
2
    mThemeDropDown(new DropDown(this, mThemesModel,
66

6
        false, Modal_false, nullptr, std::string())),
67
    mTheme(config.getStringValue("theme")),
68
2
    mInfo(Theme::loadInfo(mTheme)),
69

2
    mFontsModel(new FontsModel),
70
    // TRANSLATORS: theme settings label
71

4
    mFontLabel(new Label(this, _("Main Font"))),
72
2
    mFontDropDown(new DropDown(this, mFontsModel,
73

6
        false, Modal_false, nullptr, std::string())),
74
    mFont(config.getStringValue("font")),
75

2
    mLangListModel(new LangListModel),
76
    // TRANSLATORS: theme settings label
77

4
    mLangLabel(new Label(this, _("Language"))),
78
2
    mLangDropDown(new DropDown(this, mLangListModel,
79

6
        true, Modal_false, nullptr, std::string())),
80
    mLang(config.getStringValue("lang")),
81
    // TRANSLATORS: theme settings label
82

4
    mBoldFontLabel(new Label(this, _("Bold font"))),
83
2
    mBoldFontDropDown(new DropDown(this, mFontsModel,
84

6
        false, Modal_false, nullptr, std::string())),
85
    mBoldFont(config.getStringValue("boldFont")),
86
    // TRANSLATORS: theme settings label
87

4
    mParticleFontLabel(new Label(this, _("Particle font"))),
88
2
    mParticleFontDropDown(new DropDown(this, mFontsModel,
89

6
        false, Modal_false, nullptr, std::string())),
90
    mParticleFont(config.getStringValue("particleFont")),
91
    // TRANSLATORS: theme settings label
92

4
    mHelpFontLabel(new Label(this, _("Help font"))),
93
2
    mHelpFontDropDown(new DropDown(this, mFontsModel,
94

6
        false, Modal_false, nullptr, std::string())),
95
    mHelpFont(config.getStringValue("helpFont")),
96
    // TRANSLATORS: theme settings label
97

4
    mSecureFontLabel(new Label(this, _("Secure font"))),
98
2
    mSecureFontDropDown(new DropDown(this, mFontsModel,
99

6
        false, Modal_false, nullptr, std::string())),
100
    mSecureFont(config.getStringValue("secureFont")),
101
    // TRANSLATORS: theme settings label
102

4
    mNpcFontLabel(new Label(this, _("Npc font"))),
103
2
    mNpcFontDropDown(new DropDown(this, mFontsModel,
104

6
        false, Modal_false, nullptr, std::string())),
105
    mNpcFont(config.getStringValue("npcFont")),
106
    // TRANSLATORS: theme settings label
107

4
    mJapanFontLabel(new Label(this, _("Japanese font"))),
108
2
    mJapanFontDropDown(new DropDown(this, mFontsModel,
109

6
        false, Modal_false, nullptr, std::string())),
110
    mJapanFont(config.getStringValue("japanFont")),
111
    // TRANSLATORS: theme settings label
112

4
    mChinaFontLabel(new Label(this, _("Chinese font"))),
113
2
    mChinaFontDropDown(new DropDown(this, mFontsModel,
114

6
        false, Modal_false, nullptr, std::string())),
115
    mChinaFont(config.getStringValue("chinaFont")),
116
4
    mFontSizeListModel(new FontSizeChoiceListModel),
117
    // TRANSLATORS: theme settings label
118

4
    mFontSizeLabel(new Label(this, _("Font size"))),
119

8
    mFontSize(config.getIntValue("fontSize")),
120
2
    mFontSizeDropDown(new DropDown(this, mFontSizeListModel,
121

6
        false, Modal_false, nullptr, std::string())),
122
4
    mNpcFontSizeListModel(new FontSizeChoiceListModel),
123
    // TRANSLATORS: theme settings label
124

4
    mNpcFontSizeLabel(new Label(this, _("Npc font size"))),
125

8
    mNpcFontSize(config.getIntValue("npcfontSize")),
126
2
    mNpcFontSizeDropDown(new DropDown(this, mNpcFontSizeListModel,
127

6
        false, Modal_false, nullptr, std::string())),
128
    // TRANSLATORS: button name with information about selected theme
129

4
    mInfoButton(new Button(this, _("i"), ACTION_INFO, BUTTON_SKIN, this)),
130

















236
    mThemeInfo()
131
{
132
    // TRANSLATORS: theme settings tab name
133
10
    setName(_("Theme"));
134
135
10
    mThemeDropDown->setActionEventId(ACTION_THEME);
136
2
    mThemeDropDown->addActionListener(this);
137
10
    mFontDropDown->setActionEventId(ACTION_FONT);
138
2
    mFontDropDown->addActionListener(this);
139
8
    mLangDropDown->setActionEventId(ACTION_LANG);
140
2
    mLangDropDown->addActionListener(this);
141
10
    mBoldFontDropDown->setActionEventId(ACTION_BOLD_FONT);
142
2
    mBoldFontDropDown->addActionListener(this);
143
10
    mParticleFontDropDown->setActionEventId(ACTION_PARTICLE_FONT);
144
2
    mParticleFontDropDown->addActionListener(this);
145
10
    mHelpFontDropDown->setActionEventId(ACTION_HELP_FONT);
146
2
    mHelpFontDropDown->addActionListener(this);
147
10
    mSecureFontDropDown->setActionEventId(ACTION_SECURE_FONT);
148
2
    mSecureFontDropDown->addActionListener(this);
149
10
    mNpcFontDropDown->setActionEventId(ACTION_NPC_FONT);
150
2
    mNpcFontDropDown->addActionListener(this);
151
10
    mJapanFontDropDown->setActionEventId(ACTION_JAPAN_FONT);
152
2
    mJapanFontDropDown->addActionListener(this);
153
10
    mChinaFontDropDown->setActionEventId(ACTION_CHINA_FONT);
154
2
    mChinaFontDropDown->addActionListener(this);
155
2
    mFontSizeDropDown->setSelected(mFontSize - 9);
156
2
    mFontSizeDropDown->adjustHeight();
157
2
    mNpcFontSizeDropDown->setSelected(mNpcFontSize - 9);
158
2
    mNpcFontSizeDropDown->adjustHeight();
159
160
2
    const std::string skin = Theme::getThemeName();
161
2
    if (!skin.empty())
162
2
        mThemeDropDown->setSelectedString(skin);
163
    else
164
        mThemeDropDown->setSelected(0);
165
166

10
    const std::string str = config.getStringValue("lang");
167
2
    for (int f = 0; f < langs_count; f ++)
168
    {
169
2
        if (LANG_NAME[f].value == str)
170
        {
171
2
            mLangDropDown->setSelected(f);
172
            break;
173
        }
174
    }
175
176
4
    mFontDropDown->setSelectedString(getFileName(
177

12
        config.getStringValue("font")));
178
4
    mBoldFontDropDown->setSelectedString(getFileName(
179

12
        config.getStringValue("boldFont")));
180
4
    mParticleFontDropDown->setSelectedString(getFileName(
181

12
        config.getStringValue("particleFont")));
182
4
    mHelpFontDropDown->setSelectedString(getFileName(
183

12
        config.getStringValue("helpFont")));
184
4
    mSecureFontDropDown->setSelectedString(getFileName(
185

12
        config.getStringValue("secureFont")));
186
4
    mNpcFontDropDown->setSelectedString(getFileName(
187

12
        config.getStringValue("npcFont")));
188
4
    mJapanFontDropDown->setSelectedString(getFileName(
189

12
        config.getStringValue("japanFont")));
190
4
    mChinaFontDropDown->setSelectedString(getFileName(
191

12
        config.getStringValue("chinaFont")));
192
193
2
    updateInfo();
194
195
    // Do the layout
196
4
    LayoutHelper h(this);
197
2
    ContainerPlacer place = h.getPlacer(0, 0);
198
199
2
    place(0, 0, mThemeLabel, 5, 1);
200
2
    place(0, 1, mLangLabel, 5, 1);
201
2
    place(0, 2, mFontSizeLabel, 5, 1);
202
2
    place(0, 3, mNpcFontSizeLabel, 5, 1);
203
2
    place(0, 4, mFontLabel, 5, 1);
204
2
    place(0, 5, mBoldFontLabel, 5, 1);
205
2
    place(0, 6, mParticleFontLabel, 5, 1);
206
2
    place(0, 7, mHelpFontLabel, 5, 1);
207
2
    place(0, 8, mSecureFontLabel, 5, 1);
208
2
    place(0, 9, mNpcFontLabel, 5, 1);
209
2
    place(0, 10, mJapanFontLabel, 5, 1);
210
2
    place(0, 11, mChinaFontLabel, 5, 1);
211
212

2
    place(6, 0, mThemeDropDown, 10, 1);
213

2
    place(6, 1, mLangDropDown, 10, 1);
214

2
    place(6, 2, mFontSizeDropDown, 10, 1);
215

2
    place(6, 3, mNpcFontSizeDropDown, 10, 1);
216

2
    place(6, 4, mFontDropDown, 10, 1);
217

2
    place(6, 5, mBoldFontDropDown, 10, 1);
218

2
    place(6, 6, mParticleFontDropDown, 10, 1);
219

2
    place(6, 7, mHelpFontDropDown, 10, 1);
220

2
    place(6, 8, mSecureFontDropDown, 10, 1);
221

2
    place(6, 9, mNpcFontDropDown, 10, 1);
222

2
    place(6, 10, mJapanFontDropDown, 10, 1);
223

2
    place(6, 11, mChinaFontDropDown, 10, 1);
224
225
2
    place(17, 0, mInfoButton, 1, 1);
226
227
2
    int size = mainGraphics->mWidth - 10;
228
2
    const int maxWidth = mFontSize * 30 + 290;
229
2
    if (size < 465)
230
        size = 465;
231
2
    else if (size > maxWidth)
232
        size = maxWidth;
233
234
2
    setDimension(Rect(0, 0, size, 500));
235
2
}
236
237
28
Setup_Theme::~Setup_Theme()
238
{
239
2
    delete2(mInfo);
240
4
    delete2(mThemesModel);
241
4
    delete2(mFontsModel);
242
4
    delete2(mFontSizeListModel);
243
4
    delete2(mNpcFontSizeListModel);
244
2
    delete2(mLangListModel);
245
2
    delete2(mInfo);
246
4
}
247
248
2
void Setup_Theme::updateInfo()
249
{
250
2
    delete mInfo;
251
2
    mInfo = Theme::loadInfo(mTheme);
252
2
    if (mInfo != nullptr)
253
    {
254
        // TRANSLATORS: theme name
255
10
        mThemeInfo = std::string(_("Name: ")).append(mInfo->name)
256
            // TRANSLATORS: theme copyright
257

4
            .append("\n").append(_("Copyright:")).append("\n")
258
6
            .append(mInfo->copyright);
259
    }
260
    else
261
    {
262
        mThemeInfo.clear();
263
    }
264

14
    replaceAll(mThemeInfo, "\\n", "\n");
265
6
    mInfoButton->setEnabled(!mThemeInfo.empty());
266
2
}
267
268
void Setup_Theme::action(const ActionEvent &event)
269
{
270
    const std::string &eventId = event.getId();
271
    if (eventId == ACTION_THEME)
272
    {
273
        if (mThemeDropDown->getSelected() == 0)
274
            mTheme.clear();
275
        else
276
            mTheme = mThemeDropDown->getSelectedString();
277
        updateInfo();
278
    }
279
    else if (eventId == ACTION_FONT)
280
    {
281
        mFont = mFontDropDown->getSelectedString();
282
    }
283
    else if (eventId == ACTION_LANG)
284
    {
285
        const int id = mLangDropDown->getSelected();
286
        if (id < 0 || id >= langs_count)
287
            mLang.clear();
288
        else
289
            mLang = LANG_NAME[id].value;
290
    }
291
    else if (eventId == ACTION_BOLD_FONT)
292
    {
293
        mBoldFont = mBoldFontDropDown->getSelectedString();
294
    }
295
    else if (eventId == ACTION_PARTICLE_FONT)
296
    {
297
        mParticleFont = mParticleFontDropDown->getSelectedString();
298
    }
299
    else if (eventId == ACTION_HELP_FONT)
300
    {
301
        mHelpFont = mHelpFontDropDown->getSelectedString();
302
    }
303
    else if (eventId == ACTION_SECURE_FONT)
304
    {
305
        mSecureFont = mSecureFontDropDown->getSelectedString();
306
    }
307
    else if (eventId == ACTION_NPC_FONT)
308
    {
309
        mNpcFont = mNpcFontDropDown->getSelectedString();
310
    }
311
    else if (eventId == ACTION_JAPAN_FONT)
312
    {
313
        mJapanFont = mJapanFontDropDown->getSelectedString();
314
    }
315
    else if (eventId == ACTION_CHINA_FONT)
316
    {
317
        mChinaFont = mChinaFontDropDown->getSelectedString();
318
    }
319
    else if (eventId == ACTION_INFO)
320
    {
321
        CREATEWIDGET(OkDialog,
322
            // TRANSLATORS: theme info dialog header
323
            _("Theme info"),
324
            mThemeInfo,
325
            // TRANSLATORS: ok dialog button
326
            _("OK"),
327
            DialogType::OK,
328
            Modal_true,
329
            ShowCenter_true,
330
            nullptr,
331
            600);
332
    }
333
}
334
335
void Setup_Theme::cancel()
336
{
337
    mTheme = config.getStringValue("theme");
338
    mLang = config.getStringValue("lang");
339
    mFont = getFileName(config.getStringValue("font"));
340
    mBoldFont = getFileName(config.getStringValue("boldFont"));
341
    mParticleFont = getFileName(config.getStringValue("particleFont"));
342
    mHelpFont = getFileName(config.getStringValue("helpFont"));
343
    mSecureFont = getFileName(config.getStringValue("secureFont"));
344
    mNpcFont = getFileName(config.getStringValue("npcFont"));
345
    mJapanFont = getFileName(config.getStringValue("japanFont"));
346
    mChinaFont = getFileName(config.getStringValue("chinaFont"));
347
}
348
349
#define updateField(name1, name2) if (!mInfo->name1.empty()) \
350
    name2 = mInfo->name1;
351
352
void Setup_Theme::apply()
353
{
354
    if (config.getStringValue("theme") != mTheme)
355
    {
356
        CREATEWIDGET(OkDialog,
357
            // TRANSLATORS: theme message dialog
358
            _("Theme Changed"),
359
            // TRANSLATORS: ok dialog message
360
            _("Restart your client for the change to take effect."),
361
            // TRANSLATORS: ok dialog button
362
            _("OK"),
363
            DialogType::OK,
364
            Modal_true,
365
            ShowCenter_true,
366
            nullptr,
367
            260);
368
    }
369
370
    config.setValue("selectedSkin", "");
371
    if (config.getStringValue("theme") != mTheme && (mInfo != nullptr))
372
    {
373
        updateField(font, mFont);
374
        updateField(boldFont, mBoldFont);
375
        updateField(particleFont, mParticleFont);
376
        updateField(helpFont, mHelpFont);
377
        updateField(secureFont, mSecureFont);
378
        updateField(npcFont, mNpcFont);
379
        updateField(japanFont, mJapanFont);
380
        updateField(chinaFont, mChinaFont);
381
        if (mInfo->fontSize != 0)
382
        {
383
            const int size = mInfo->fontSize - 9;
384
            if (size >= 0)
385
                mFontSizeDropDown->setSelected(size);
386
        }
387
        if (mInfo->npcfontSize != 0)
388
        {
389
            const int size = mInfo->npcfontSize - 9;
390
            if (size >= 0)
391
                mNpcFontSizeDropDown->setSelected(size);
392
        }
393
        if (mInfo->guiAlpha > 0.01F)
394
            config.setValue("guialpha", mInfo->guiAlpha);
395
    }
396
    config.setValue("theme", mTheme);
397
    config.setValue("lang", mLang);
398
    if (config.getValue("font", "dejavusans.ttf") != mFont
399
        || config.getValue("boldFont", "dejavusans-bold.ttf") != mBoldFont
400
        || config.getValue("particleFont", "dejavusans.ttf") != mParticleFont
401
        || config.getValue("helpFont", "dejavusansmono.ttf") != mHelpFont
402
        || config.getValue("secureFont", "dejavusansmono.ttf") != mSecureFont
403
        || config.getValue("npcFont", "dejavusans.ttf") != mNpcFont
404
        || config.getValue("japanFont", "mplus-1p-regular.ttf") != mJapanFont
405
        || config.getValue("chinaFont", "fonts/wqy-microhei.ttf")
406
        != mChinaFont
407
        || config.getIntValue("fontSize")
408
        != CAST_S32(mFontSizeDropDown->getSelected()) + 9
409
        || config.getIntValue("npcfontSize")
410
        != CAST_S32(mNpcFontSizeDropDown->getSelected()) + 9)
411
    {
412
        config.setValue("font", "fonts/" + getFileName(mFont));
413
        config.setValue("boldFont", "fonts/" + getFileName(mBoldFont));
414
        config.setValue("particleFont", "fonts/" + getFileName(mParticleFont));
415
        config.setValue("helpFont", "fonts/" + getFileName(mHelpFont));
416
        config.setValue("secureFont", "fonts/" + getFileName(mSecureFont));
417
        config.setValue("npcFont", "fonts/" + getFileName(mNpcFont));
418
        config.setValue("japanFont", "fonts/" + getFileName(mJapanFont));
419
        config.setValue("chinaFont", "fonts/" + getFileName(mChinaFont));
420
        config.setValue("fontSize", mFontSizeDropDown->getSelected() + 9);
421
        config.setValue("npcfontSize",
422
            mNpcFontSizeDropDown->getSelected() + 9);
423
        gui->updateFonts();
424
    }
425

3
}
426
427
#undef updateField