setupitem.cpp

Go to the documentation of this file.

/*
 *  The ManaPlus Client
 *  Copyright (C) 2011-2019  The ManaPlus Developers
 *  Copyright (C) 2019-2021  Andrei Karas
 *
 *  This file is part of The ManaPlus Client.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "gui/widgets/setupitem.h"
 
#include "configuration.h"
#include "soundmanager.h"
 
#include "gui/gui.h"
 
#include "gui/fonts/font.h"
 
#include "gui/models/listmodel.h"
 
#include "gui/windows/editdialog.h"
 
#include "gui/widgets/button.h"
#include "gui/widgets/checkbox.h"
#include "gui/widgets/createwidget.h"
#include "gui/widgets/dropdown.h"
#include "gui/widgets/horizontcontainer.h"
#include "gui/widgets/inttextfield.h"
#include "gui/widgets/label.h"
#include "gui/widgets/slider.h"
#include "gui/widgets/sliderlist.h"
#include "gui/widgets/vertcontainer.h"
 
#include "gui/widgets/tabs/setuptabscroll.h"
 
#include "utils/base64.h"
#include "utils/gettext.h"
#include "utils/stdmove.h"
#include "utils/mathutils.h"
 
#include "debug.h"
 
SetupItem::SetupItem(const std::string &restrict text,
                     const std::string &restrict description,
                     const std::string &restrict keyName,
                     SetupTabScroll *restrict const parent,
                     const std::string &restrict eventName,
                     const MainConfig mainConfig) :
    ActionListener(),
    Widget2(parent),
    mText(text),
    mDescription(description),
    mKeyName(keyName),
    mParent(parent),
    mEventName(eventName),
    mValue(),
    mDefault(),
    mWidget(nullptr),
    mTempWidgets(),
    mValueType(VBOOL),
    mMainConfig(mainConfig),
    mUseDefault(false)
{
}
 
SetupItem::SetupItem(const std::string &restrict text,
                     const std::string &restrict description,
                     const std::string &restrict keyName,
                     SetupTabScroll *restrict const parent,
                     const std::string &restrict eventName,
                     const std::string &restrict def,
                     const MainConfig mainConfig) :
    ActionListener(),
    Widget2(parent),
    mText(text),
    mDescription(description),
    mKeyName(keyName),
    mParent(parent),
    mEventName(eventName),
    mValue(),
    mDefault(def),
    mWidget(nullptr),
    mTempWidgets(),
    mValueType(VBOOL),
    mMainConfig(mainConfig),
    mUseDefault(true)
{
}
 
SetupItem::~SetupItem()
{
}
 
Configuration *SetupItem::getConfig() const
{
    if (mMainConfig == MainConfig_true)
        return &config;
    return &serverConfig;
}
 
void SetupItem::load()
{
    if (mKeyName.empty())
        return;
 
    const Configuration *const cfg = getConfig();
    if (mUseDefault)
    {
        mValue = cfg->getValue(mKeyName, mDefault);
    }
    else
    {
        switch (mValueType)
        {
            case VBOOL:
                if (cfg->getBoolValue(mKeyName))
                    mValue = "1";
                else
                    mValue = "0";
                break;
            case VSTR:
            default:
                mValue = cfg->getStringValue(mKeyName);
                break;
            case VINT:
                mValue = toString(cfg->getIntValue(mKeyName));
                break;
            case VNONE:
                break;
        }
    }
}
 
void SetupItem::save()
{
    if (mKeyName.empty())
        return;
 
    Configuration *const cfg = getConfig();
    cfg->setValue(mKeyName, mValue);
}
 
std::string SetupItem::getActionEventId() const
{
    if (mWidget == nullptr)
        return std::string();
 
    return mWidget->getActionEventId();
}
 
void SetupItem::action(const ActionEvent &event)
{
    if (mWidget == nullptr)
        return;
 
    if (event.getId() == mWidget->getActionEventId())
        doAction();
}
 
void SetupItem::doAction()
{
    fromWidget();
}
 
void SetupItem::apply(const std::string &eventName A_UNUSED)
{
    save();
}
 
void SetupItem::cancel(const std::string &eventName A_UNUSED)
{
    load();
    toWidget();
}
 
void SetupItem::externalUpdated(const std::string &eventName A_UNUSED)
{
    load();
    toWidget();
}
 
void SetupItem::externalUnloaded(const std::string &eventName A_UNUSED)
{
}
 
void SetupItem::fixFirstItemSize(Widget *const widget)
{
    if (widget == nullptr)
        return;
    const int maxSize = mParent->getPreferredFirstItemSize();
    if (widget->getWidth() < maxSize)
        widget->setWidth(maxSize);
}
 
void SetupItem::rereadValue()
{
    load();
    toWidget();
}
 
SetupItemCheckBox::SetupItemCheckBox(const std::string &restrict text,
                                     const std::string &restrict description,
                                     const std::string &restrict keyName,
                                     SetupTabScroll *restrict const parent,
                                     const std::string &restrict eventName,
                                     const MainConfig mainConfig) :
    SetupItem(text, description, keyName, parent, eventName, mainConfig),
    mCheckBox(nullptr)
{
    createControls();
}
 
SetupItemCheckBox::SetupItemCheckBox(const std::string &restrict text,
                                     const std::string &restrict description,
                                     const std::string &restrict keyName,
                                     SetupTabScroll *restrict const parent,
                                     const std::string &restrict eventName,
                                     const std::string &restrict def,
                                     const MainConfig mainConfig) :
    SetupItem(text, description, keyName, parent, eventName, def, mainConfig),
    mCheckBox(nullptr)
{
    createControls();
}
 
SetupItemCheckBox::~SetupItemCheckBox()
{
    mWidget = nullptr;
}
 
void SetupItemCheckBox::createControls()
{
    load();
    mCheckBox = new CheckBox(this, mText, mValue != "0", mParent, mEventName);
    mCheckBox->setToolTip(mDescription);
    mWidget = mCheckBox;
    mParent->getContainer()->add1(mWidget, -1);
    mParent->addControl(this);
    mParent->addActionListener(this);
    mWidget->addActionListener(this);
}
 
void SetupItemCheckBox::fromWidget()
{
    if (mCheckBox == nullptr)
        return;
 
    if (mCheckBox->isSelected())
        mValue = "1";
    else
        mValue = "0";
}
 
void SetupItemCheckBox::toWidget()
{
    if (mCheckBox == nullptr)
        return;
 
    mCheckBox->setSelected(mValue != "0");
}
 
 
SetupItemTextField::SetupItemTextField(const std::string &restrict text,
                                       const std::string &restrict description,
                                       const std::string &restrict keyName,
                                       SetupTabScroll *restrict const parent,
                                       const std::string &restrict eventName,
                                       const MainConfig mainConfig,
                                       const UseBase64 useBase64) :
    SetupItem(text, description, keyName, parent, eventName, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mTextField(nullptr),
    mButton(nullptr),
    mEditDialog(nullptr),
    mUseBase64(useBase64)
{
    mValueType = VSTR;
    createControls();
}
 
SetupItemTextField::SetupItemTextField(const std::string &restrict text,
                                       const std::string &restrict description,
                                       const std::string &restrict keyName,
                                       SetupTabScroll *restrict const parent,
                                       const std::string &restrict eventName,
                                       const std::string &restrict def,
                                       const MainConfig mainConfig,
                                       const UseBase64 useBase64) :
    SetupItem(text, description, keyName, parent, eventName, def, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mTextField(nullptr),
    mButton(nullptr),
    mEditDialog(nullptr),
    mUseBase64(useBase64)
{
    mValueType = VSTR;
    createControls();
}
 
SetupItemTextField::~SetupItemTextField()
{
    mHorizont = nullptr;
    mWidget = nullptr;
    mTextField = nullptr;
    mLabel = nullptr;
    mButton = nullptr;
}
 
void SetupItemTextField::save()
{
    if (mUseBase64 == UseBase64_true)
    {
        std::string normalValue = mValue;
        mValue = encodeBase64String(mValue);
        SetupItem::save();
        mValue = STD_MOVE(normalValue);
    }
    else
    {
        SetupItem::save();
    }
}
 
void SetupItemTextField::cancel(const std::string &eventName A_UNUSED)
{
    load();
    if (mUseBase64 == UseBase64_true)
        mValue = decodeBase64String(mValue);
    toWidget();
}
 
void SetupItemTextField::externalUpdated(const std::string &eventName A_UNUSED)
{
    load();
    if (mUseBase64 == UseBase64_true)
        mValue = decodeBase64String(mValue);
    toWidget();
}
 
void SetupItemTextField::rereadValue()
{
    load();
    if (mUseBase64 == UseBase64_true)
        mValue = decodeBase64String(mValue);
    toWidget();
}
 
void SetupItemTextField::createControls()
{
    load();
    if (mUseBase64 == UseBase64_true)
        mValue = decodeBase64String(mValue);
    mHorizont = new HorizontContainer(this, 32, 2);
 
    mLabel = new Label(this, mText);
    mLabel->setToolTip(mDescription);
    mTextField = new TextField(this,
        mValue,
        LoseFocusOnTab_true,
        mParent,
        mEventName,
        false);
    mButton = new Button(this,
        // TRANSLATORS: setup item button
        _("Edit"),
        mEventName + "_EDIT",
        BUTTON_SKIN,
        mParent);
    mWidget = mTextField;
    mTextField->setWidth(200);
    fixFirstItemSize(mLabel);
    mHorizont->add(mLabel);
    mHorizont->add(mTextField);
    mHorizont->add(mButton);
 
    mParent->getContainer()->add2(mHorizont, true, 4);
    mParent->addControl(this);
    mParent->addControl(this, mEventName + "_EDIT");
    mParent->addControl(this, mEventName + "_EDIT_OK");
    mParent->addActionListener(this);
    mWidget->addActionListener(this);
    mButton->addActionListener(this);
}
 
void SetupItemTextField::fromWidget()
{
    if (mTextField == nullptr)
        return;
 
    mValue = mTextField->getText();
}
 
void SetupItemTextField::toWidget()
{
    if (mTextField == nullptr)
        return;
 
    mTextField->setText(mValue);
}
 
void SetupItemTextField::action(const ActionEvent &event)
{
    if (mTextField == nullptr)
        return;
 
    const std::string &eventId = event.getId();
    if ((mWidget != nullptr) && eventId == mWidget->getActionEventId())
    {
        fromWidget();
    }
    else if (eventId == mEventName + "_EDIT")
    {
        mEditDialog = CREATEWIDGETR(EditDialog,
            mText,
            mTextField->getText(),
            mEventName + "_EDIT_OK",
            300,
            nullptr,
            Modal_true);
        mEditDialog->addActionListener(this);
    }
    else if (eventId == mEventName + "_EDIT_OK")
    {
        mTextField->setText(mEditDialog->getMsg());
        mEditDialog = nullptr;
    }
}
 
void SetupItemTextField::apply(const std::string &eventName)
{
    if (eventName != mEventName)
        return;
 
    fromWidget();
    save();
}
 
SetupItemIntTextField::SetupItemIntTextField(const std::string &restrict text,
                                             const std::string &restrict
                                             description,
                                             const std::string &restrict
                                             keyName,
                                             SetupTabScroll *restrict
                                             const parent,
                                             const std::string &restrict
                                             eventName,
                                             const int min, const int max,
                                             const MainConfig mainConfig) :
    SetupItem(text, description, keyName, parent, eventName, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mTextField(nullptr),
    mButton(nullptr),
    mEditDialog(nullptr),
    mMin(min),
    mMax(max)
{
    mValueType = VSTR;
    createControls();
}
 
SetupItemIntTextField::SetupItemIntTextField(const std::string &restrict text,
                                             const std::string &restrict
                                             description,
                                             const std::string &restrict
                                             keyName,
                                             SetupTabScroll *restrict
                                             const parent,
                                             const std::string &restrict
                                             eventName,
                                             const int min, const int max,
                                             const std::string &restrict def,
                                             const MainConfig mainConfig) :
    SetupItem(text, description, keyName, parent, eventName, def, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mTextField(nullptr),
    mButton(nullptr),
    mEditDialog(nullptr),
    mMin(min),
    mMax(max)
{
    mValueType = VSTR;
    createControls();
}
 
SetupItemIntTextField::~SetupItemIntTextField()
{
    mHorizont = nullptr;
    mWidget = nullptr;
    mTextField = nullptr;
    mLabel = nullptr;
    mButton = nullptr;
}
 
void SetupItemIntTextField::createControls()
{
    load();
    mHorizont = new HorizontContainer(this, 32, 2);
 
    mLabel = new Label(this, mText);
    mLabel->setToolTip(mDescription);
    mTextField = new IntTextField(this, atoi(mValue.c_str()),
        mMin, mMax, Enable_true, 30);
    mTextField->setActionEventId(mEventName);
    mTextField->addActionListener(mParent);
 
    mButton = new Button(this,
        // TRANSLATORS: setup item button
        _("Edit"),
        mEventName + "_EDIT",
        BUTTON_SKIN,
        mParent);
    mWidget = mTextField;
    mTextField->setWidth(50);
    fixFirstItemSize(mLabel);
    mHorizont->add(mLabel);
    mHorizont->add(mTextField);
    mHorizont->add(mButton);
 
    mParent->getContainer()->add2(mHorizont, true, 4);
    mParent->addControl(this);
    mParent->addControl(this, mEventName + "_EDIT");
    mParent->addControl(this, mEventName + "_EDIT_OK");
    mParent->addActionListener(this);
    mWidget->addActionListener(this);
    mButton->addActionListener(this);
}
 
void SetupItemIntTextField::fromWidget()
{
    if (mTextField == nullptr)
        return;
 
    mValue = mTextField->getText();
}
 
void SetupItemIntTextField::toWidget()
{
    if (mTextField == nullptr)
        return;
 
    mTextField->setText(mValue);
}
 
void SetupItemIntTextField::action(const ActionEvent &event)
{
    if (mTextField == nullptr)
        return;
 
    const std::string &eventId = event.getId();
    if ((mWidget != nullptr) && eventId == mWidget->getActionEventId())
    {
        fromWidget();
    }
    else if (eventId == mEventName + "_EDIT")
    {
        mEditDialog = CREATEWIDGETR(EditDialog,
            mText,
            mTextField->getText(),
            mEventName + "_EDIT_OK",
            300,
            nullptr,
            Modal_true);
        mEditDialog->addActionListener(this);
    }
    else if (eventId == mEventName + "_EDIT_OK")
    {
        mTextField->setValue(atoi(mEditDialog->getMsg().c_str()));
        mEditDialog = nullptr;
    }
}
 
void SetupItemIntTextField::apply(const std::string &eventName)
{
    if (eventName != mEventName)
        return;
 
    fromWidget();
    save();
}
 
 
SetupItemLabel::SetupItemLabel(const std::string &restrict text,
                               const std::string &restrict description,
                               SetupTabScroll *restrict const parent,
                               const Separator separator) :
    SetupItem(text, description, "", parent, "", "", MainConfig_true),
    mLabel(nullptr),
    mIsSeparator(separator)
{
    mValueType = VNONE;
    createControls();
}
 
SetupItemLabel::~SetupItemLabel()
{
    mWidget = nullptr;
    mLabel = nullptr;
}
 
void SetupItemLabel::createControls()
{
    if (mIsSeparator == Separator_true)
    {
        const std::string str(" \342\200\225\342\200\225\342\200\225"
            "\342\200\225\342\200\225 ");
        mLabel = new Label(this, std::string(str).append(mText).append(str));
    }
    else
    {
        mLabel = new Label(this, mText);
    }
    mLabel->setToolTip(mDescription);
 
    mWidget = mLabel;
    mParent->getContainer()->add1(mWidget, -1);
    mParent->addControl(this);
    mParent->addActionListener(this);
    mWidget->addActionListener(this);
}
 
void SetupItemLabel::fromWidget()
{
}
 
void SetupItemLabel::toWidget()
{
}
 
void SetupItemLabel::action(const ActionEvent &event A_UNUSED)
{
}
 
void SetupItemLabel::apply(const std::string &eventName A_UNUSED)
{
}
 
 
SetupItemDropDown::SetupItemDropDown(const std::string &restrict text,
                                     const std::string &restrict description,
                                     const std::string &restrict keyName,
                                     SetupTabScroll *restrict const parent,
                                     const std::string &restrict eventName,
                                     ListModel *restrict const model,
                                     const int width,
                                     const MainConfig mainConfig) :
    SetupItem(text, description, keyName, parent, eventName, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mModel(model),
    mDropDown(nullptr),
    mWidth(width)
{
    mValueType = VSTR;
    createControls();
}
 
SetupItemDropDown::SetupItemDropDown(const std::string &restrict text,
                                     const std::string &restrict description,
                                     const std::string &restrict keyName,
                                     SetupTabScroll *restrict const parent,
                                     const std::string &restrict eventName,
                                     ListModel *restrict const model,
                                     const int width,
                                     const std::string &restrict def,
                                     const MainConfig mainConfig) :
    SetupItem(text, description, keyName, parent, eventName, def, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mModel(model),
    mDropDown(nullptr),
    mWidth(width)
{
    mValueType = VSTR;
    createControls();
}
 
SetupItemDropDown::~SetupItemDropDown()
{
    mHorizont = nullptr;
    mWidget = nullptr;
    mModel = nullptr;
    mDropDown = nullptr;
    mLabel = nullptr;
}
 
void SetupItemDropDown::createControls()
{
    load();
    mHorizont = new HorizontContainer(this, 32, 2);
 
    mLabel = new Label(this, mText);
    mLabel->setToolTip(mDescription);
    mDropDown = new DropDown(this,
        mModel,
        false,
        Modal_false,
        nullptr,
        std::string());
    mDropDown->setActionEventId(mEventName);
    mDropDown->addActionListener(mParent);
    mDropDown->setWidth(mWidth);
    mDropDown->setSelected(selectionByValue());
 
    mWidget = mDropDown;
    if (!mText.empty())
        fixFirstItemSize(mLabel);
    mHorizont->add(mLabel);
    mHorizont->add(mDropDown);
 
    mParent->getContainer()->add2(mHorizont, true, 4);
    mParent->addControl(this);
    mParent->addActionListener(this);
    mWidget->addActionListener(this);
}
 
int SetupItemDropDown::selectionByValue()
{
    return atoi(mValue.c_str());
}
 
void SetupItemDropDown::fromWidget()
{
    if (mDropDown == nullptr)
        return;
 
    mValue = toString(mDropDown->getSelected());
}
 
void SetupItemDropDown::toWidget()
{
    if (mDropDown == nullptr)
        return;
 
    mDropDown->setSelected(selectionByValue());
}
 
 
SetupItemDropDownStr::SetupItemDropDownStr(const std::string &restrict text,
                                           const std::string &restrict
                                           description,
                                           const std::string &restrict keyName,
                                           SetupTabScroll *restrict const
                                           parent,
                                           const std::string &restrict
                                           eventName,
                                           ListModel *restrict const model,
                                           const int width,
                                           const MainConfig mainConfig) :
    SetupItem(text, description, keyName, parent, eventName, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mModel(model),
    mDropDown(nullptr),
    mWidth(width)
{
    mValueType = VSTR;
    createControls();
}
 
SetupItemDropDownStr::SetupItemDropDownStr(const std::string &restrict text,
                                           const std::string &restrict
                                           description,
                                           const std::string &restrict keyName,
                                           SetupTabScroll *restrict const
                                           parent,
                                           const std::string &restrict
                                           eventName,
                                           ListModel *restrict const model,
                                           const int width,
                                           const std::string &restrict def,
                                           const MainConfig mainConfig) :
    SetupItem(text, description, keyName, parent, eventName, def, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mModel(model),
    mDropDown(nullptr),
    mWidth(width)
{
    mValueType = VSTR;
    createControls();
}
 
SetupItemDropDownStr::~SetupItemDropDownStr()
{
    mHorizont = nullptr;
    mWidget = nullptr;
    mModel = nullptr;
    mDropDown = nullptr;
    mLabel = nullptr;
}
 
void SetupItemDropDownStr::createControls()
{
    load();
    mHorizont = new HorizontContainer(this, 32, 2);
 
    mLabel = new Label(this, mText);
    mLabel->setToolTip(mDescription);
    mDropDown = new DropDown(this,
        mModel,
        false,
        Modal_false,
        nullptr,
        std::string());
    mDropDown->setActionEventId(mEventName);
    mDropDown->addActionListener(mParent);
    mDropDown->setWidth(mWidth);
    mDropDown->setSelected(selectionByValue());
 
    mWidget = mDropDown;
    if (!mText.empty())
        fixFirstItemSize(mLabel);
    mHorizont->add(mLabel);
    mHorizont->add(mDropDown);
 
    mParent->getContainer()->add2(mHorizont, true, 4);
    mParent->addControl(this);
    mParent->addActionListener(this);
    mWidget->addActionListener(this);
}
 
int SetupItemDropDownStr::selectionByValue()
{
    const int sz = mModel->getNumberOfElements();
    for (int f = 0; f < sz; f ++)
    {
        if (mModel->getElementAt(f) == mValue)
        {
            return f;
        }
    }
    return 0;
}
 
void SetupItemDropDownStr::fromWidget()
{
    if (mDropDown == nullptr)
        return;
 
    const int sel = mDropDown->getSelected();
    // use first element in model as empty string
    if (sel == 0 || sel >= mModel->getNumberOfElements())
        mValue.clear();
    else
        mValue = mModel->getElementAt(sel);
}
 
void SetupItemDropDownStr::toWidget()
{
    if (mDropDown == nullptr)
        return;
 
    mDropDown->setSelected(selectionByValue());
}
 
 
SetupItemSlider::SetupItemSlider(const std::string &restrict text,
                                 const std::string &restrict description,
                                 const std::string &restrict keyName,
                                 SetupTabScroll *restrict const parent,
                                 const std::string &restrict eventName,
                                 const double min,
                                 const double max,
                                 const double step,
                                 const int width,
                                 const OnTheFly onTheFly,
                                 const MainConfig mainConfig) :
    SetupItem(text, description, keyName, parent, eventName, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mSlider(nullptr),
    mMin(min),
    mMax(max),
    mStep(step),
    mWidth(width),
    mOnTheFly(onTheFly)
{
    mValueType = VSTR;
    createControls();
}
 
SetupItemSlider::SetupItemSlider(const std::string &restrict text,
                                 const std::string &restrict description,
                                 const std::string &restrict keyName,
                                 SetupTabScroll *restrict const parent,
                                 const std::string &restrict eventName,
                                 const double min,
                                 const double max,
                                 const double step,
                                 const std::string &restrict def,
                                 const int width,
                                 const OnTheFly onTheFly,
                                 const MainConfig mainConfig) :
    SetupItem(text, description, keyName, parent, eventName, def, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mSlider(nullptr),
    mMin(min),
    mMax(max),
    mStep(step),
    mWidth(width),
    mOnTheFly(onTheFly)
{
    mValueType = VSTR;
    createControls();
}
 
SetupItemSlider::~SetupItemSlider()
{
    mHorizont = nullptr;
    mWidget = nullptr;
    mSlider = nullptr;
    mLabel = nullptr;
}
 
void SetupItemSlider::createControls()
{
    load();
    mHorizont = new HorizontContainer(this, 32, 2);
 
    mLabel = new Label(this, mText);
    mLabel->setToolTip(mDescription);
    mSlider = new Slider(this, mMin, mMax, mStep);
    mSlider->setActionEventId(mEventName);
    mSlider->addActionListener(mParent);
    mSlider->setValue(atof(mValue.c_str()));
    mSlider->setHeight(30);
 
    mWidget = mSlider;
    mSlider->setWidth(mWidth);
    mSlider->setHeight(40);
    fixFirstItemSize(mLabel);
    mHorizont->add(mLabel);
    mHorizont->add(mSlider, -10);
 
    mParent->getContainer()->add2(mHorizont, true, 4);
    mParent->addControl(this);
    mParent->addActionListener(this);
    mWidget->addActionListener(this);
}
 
void SetupItemSlider::fromWidget()
{
    if (mSlider == nullptr)
        return;
 
    mValue = toString(mSlider->getValue());
}
 
void SetupItemSlider::toWidget()
{
    if (mSlider == nullptr)
        return;
 
    mSlider->setValue(atof(mValue.c_str()));
}
 
void SetupItemSlider::action(const ActionEvent &event A_UNUSED)
{
    fromWidget();
    if (mOnTheFly == OnTheFly_true)
        save();
}
 
void SetupItemSlider::apply(const std::string &eventName)
{
    if (eventName != mEventName)
        return;
 
    fromWidget();
    save();
}
 
 
SetupItemSlider2::SetupItemSlider2(const std::string &restrict text,
                                   const std::string &restrict description,
                                   const std::string &restrict keyName,
                                   SetupTabScroll *restrict const parent,
                                   const std::string &restrict eventName,
                                   const int min,
                                   const int max,
                                   const int step,
                                   SetupItemNames *restrict const values,
                                   const OnTheFly onTheFly,
                                   const MainConfig mainConfig,
                                   const DoNotAlign doNotAlign) :
    SetupItem(text, description, keyName, parent, eventName, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mLabel2(nullptr),
    mSlider(nullptr),
    mValues(values),
    mMin(min),
    mMax(max),
    mStep(step),
    mInvertValue(0),
    mInvert(false),
    mOnTheFly(onTheFly),
    mDoNotAlign(doNotAlign)
{
    mValueType = VSTR;
    createControls();
}
 
SetupItemSlider2::SetupItemSlider2(const std::string &restrict text,
                                   const std::string &restrict description,
                                   const std::string &restrict keyName,
                                   SetupTabScroll *restrict const parent,
                                   const std::string &restrict eventName,
                                   const int min,
                                   const int max,
                                   const int step,
                                   SetupItemNames *restrict const values,
                                   const std::string &restrict def,
                                   const OnTheFly onTheFly,
                                   const MainConfig mainConfig,
                                   const DoNotAlign doNotAlign) :
    SetupItem(text, description, keyName, parent, eventName, def, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mLabel2(nullptr),
    mSlider(nullptr),
    mValues(values),
    mMin(min),
    mMax(max),
    mStep(step),
    mInvertValue(0),
    mInvert(false),
    mOnTheFly(onTheFly),
    mDoNotAlign(doNotAlign)
{
    mValueType = VSTR;
    createControls();
}
 
SetupItemSlider2::~SetupItemSlider2()
{
    mHorizont = nullptr;
    mWidget = nullptr;
    mSlider = nullptr;
    mLabel = nullptr;
}
 
void SetupItemSlider2::createControls()
{
    load();
    mHorizont = new HorizontContainer(this, 32, 2);
 
    const int width = getMaxWidth();
 
    mLabel = new Label(this, mText);
    mLabel->setToolTip(mDescription);
    mLabel2 = new Label(this, "");
    mLabel2->setWidth(width);
    mSlider = new Slider(this, mMin, mMax, mStep);
    mSlider->setActionEventId(mEventName);
    mSlider->addActionListener(mParent);
    mSlider->setValue(atof(mValue.c_str()));
    mSlider->setHeight(30);
 
    mWidget = mSlider;
    mSlider->setWidth(150);
    mSlider->setHeight(40);
    if (mDoNotAlign == DoNotAlign_false)
        fixFirstItemSize(mLabel);
    mHorizont->add(mLabel);
    mHorizont->add(mSlider, -10);
    mHorizont->add(mLabel2);
 
    mParent->getContainer()->add2(mHorizont, true, 4);
    mParent->addControl(this);
    mParent->addActionListener(this);
    mWidget->addActionListener(this);
    updateLabel();
}
 
int SetupItemSlider2::getMaxWidth()
{
    if ((mValues == nullptr) || (gui == nullptr))
        return 1;
 
    int maxWidth = 0;
    SetupItemNamesConstIter it = mValues->begin();
    const SetupItemNamesConstIter it_end = mValues->end();
    const Font *const font = gui->getFont();
 
    while (it != it_end)
    {
        const int w = font->getWidth(*it);
        if (w > maxWidth)
            maxWidth = w;
 
        ++ it;
    }
    return maxWidth;
}
 
void SetupItemSlider2::fromWidget()
{
    if (mSlider == nullptr)
        return;
 
    int val = roundDouble(mSlider->getValue());
    if (mInvert)
        val = mInvertValue - val;
    mValue = toString(val);
}
 
void SetupItemSlider2::toWidget()
{
    if (mSlider == nullptr)
        return;
 
    int val = roundDouble(atof(mValue.c_str()));
    if (mInvert)
        val = mInvertValue - val;
    mSlider->setValue(val);
    updateLabel();
}
 
void SetupItemSlider2::action(const ActionEvent &event A_UNUSED)
{
    fromWidget();
    updateLabel();
    if (mOnTheFly == OnTheFly_true)
        save();
}
 
void SetupItemSlider2::updateLabel()
{
    int val = CAST_S32(mSlider->getValue()) - mMin;
    if (val < 0)
    {
        val = 0;
    }
    else
    {
        const int sz = CAST_S32(mValues->size());
        if (val >= sz)
            val = sz - 1;
    }
    std::string str = mValues->at(val);
    mLabel2->setCaption(str);
}
 
void SetupItemSlider2::apply(const std::string &eventName)
{
    if (eventName != mEventName)
        return;
 
    fromWidget();
    save();
}
 
void SetupItemSlider2::setInvertValue(const int v)
{
    mInvert = true;
    mInvertValue = v;
    toWidget();
}
 
 
SetupItemSliderList::SetupItemSliderList(const std::string &restrict text,
                                         const std::string &restrict
                                         description,
                                         const std::string &restrict keyName,
                                         SetupTabScroll *restrict const parent,
                                         const std::string &restrict eventName,
                                         ListModel *restrict const model,
                                         const int width,
                                         const OnTheFly onTheFly,
                                         const MainConfig mainConfig) :
    SetupItem(text, description, keyName, parent, eventName, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mSlider(nullptr),
    mModel(model),
    mWidth(width),
    mOnTheFly(onTheFly)
{
    mValueType = VSTR;
}
 
SetupItemSliderList::SetupItemSliderList(const std::string &restrict text,
                                         const std::string &restrict
                                         description,
                                         const std::string &restrict keyName,
                                         SetupTabScroll *restrict const parent,
                                         const std::string &restrict eventName,
                                         ListModel *restrict const model,
                                         const std::string &restrict def,
                                         const int width,
                                         const OnTheFly onTheFly,
                                         const MainConfig mainConfig) :
    SetupItem(text, description, keyName, parent, eventName, def, mainConfig),
    mHorizont(nullptr),
    mLabel(nullptr),
    mSlider(nullptr),
    mModel(model),
    mWidth(width),
    mOnTheFly(onTheFly)
{
    mValueType = VSTR;
}
 
SetupItemSliderList::~SetupItemSliderList()
{
    mHorizont = nullptr;
    mWidget = nullptr;
    mSlider = nullptr;
    mLabel = nullptr;
}
 
void SetupItemSliderList::createControls()
{
    load();
    mHorizont = new HorizontContainer(this, 32, 2);
 
    mLabel = new Label(this, mText);
    mLabel->setToolTip(mDescription);
    mSlider = new SliderList(this, mModel);
    mSlider->postInit2(mParent, mEventName);
    mSlider->setSelectedString(mValue);
    mSlider->adjustSize();
 
    mWidget = mSlider;
    fixFirstItemSize(mLabel);
    mHorizont->add(mLabel, 5);
    mHorizont->add(mSlider);
 
    addMoreControls();
 
    mParent->getContainer()->add2(mHorizont, true, 4);
    mParent->addControl(this);
    mParent->addActionListener(this);
    mWidget->addActionListener(this);
}
 
void SetupItemSliderList::fromWidget()
{
    if (mSlider == nullptr)
        return;
 
    mValue = mSlider->getSelectedString();
}
 
void SetupItemSliderList::toWidget()
{
    if (mSlider == nullptr)
        return;
 
    mSlider->setSelectedString(mValue);
}
 
void SetupItemSliderList::action(const ActionEvent &event A_UNUSED)
{
    fromWidget();
    if (mOnTheFly == OnTheFly_true)
        save();
}
 
void SetupItemSliderList::apply(const std::string &eventName)
{
    if (eventName != mEventName)
        return;
 
    fromWidget();
    save();
}
 
SetupItemSound::SetupItemSound(const std::string &restrict text,
                               const std::string &restrict description,
                               const std::string &restrict keyName,
                               SetupTabScroll *restrict const parent,
                               const std::string &restrict eventName,
                               ListModel *restrict const model,
                               const int width,
                               const OnTheFly onTheFly,
                               const MainConfig mainConfig) :
    SetupItemSliderList(text, description, keyName, parent, eventName,
                        model, width, onTheFly, mainConfig),
    mButton(nullptr)
{
    createControls();
}
 
void SetupItemSound::addMoreControls()
{
    mButton = new Button(this,
        BUTTON_PLAY,
        16, 16,
        mEventName + "_PLAY",
        BUTTON_SKIN,
        this);
    if (mHorizont != nullptr)
        mHorizont->add(mButton);
}
 
void SetupItemSound::action(const ActionEvent &event)
{
    if (event.getId() == mEventName + "_PLAY")
    {
        if ((mSlider != nullptr) && (mSlider->getSelected() != 0))
        {
            soundManager.playGuiSfx(pathJoin(branding.getStringValue(
                "systemsounds"),
                mSlider->getSelectedString()).append(".ogg"));
        }
    }
    else
    {
        SetupItemSliderList::action(event);
    }
}
 
SetupItemSliderInt::SetupItemSliderInt(const std::string &restrict text,
                                       const std::string &restrict description,
                                       const std::string &restrict keyName,
                                       SetupTabScroll *restrict const parent,
                                       const std::string &restrict eventName,
                                       ListModel *restrict const model,
                                       const int min,
                                       const int width,
                                       const OnTheFly onTheFly,
                                       const MainConfig mainConfig) :
    SetupItemSliderList(text, description, keyName, parent, eventName,
                        model, width, onTheFly, mainConfig),
    mMin(min)
{
    createControls();
}
 
void SetupItemSliderInt::addMoreControls()
{
    toWidget();
}
 
void SetupItemSliderInt::fromWidget()
{
    if (mSlider == nullptr)
        return;
 
    mValue = toString(mSlider->getSelected() + mMin);
}
 
void SetupItemSliderInt::toWidget()
{
    if (mSlider == nullptr)
        return;
 
    mSlider->setSelected(atoi(mValue.c_str()) - mMin);
}