Home | All Classes | Main Classes | Annotated | Grouped Classes | Functions

window.cpp Example File
widgets/sliders/window.cpp

    #include <QtGui>

    #include "window.h"

    Window::Window()
    {
        horizontalSliders = new SlidersGroup(Qt::Horizontal,
            tr("Horizontal sliders"), 0);
        verticalSliders = new SlidersGroup(Qt::Vertical,
            tr("Vertical sliders"), 0);

        pages = new QStackedWidget(this);
        pages->addWidget(horizontalSliders);
        pages->addWidget(verticalSliders);

        createControls(tr("Controls"));

        connect(horizontalSliders, SIGNAL(valueChanged(int)),
                verticalSliders, SLOT(setValue(int)));
        connect(verticalSliders, SIGNAL(valueChanged(int)),
                this, SLOT(setValue(int)));
        connect(this, SIGNAL(valueChanged(int)),
                horizontalSliders, SLOT(setValue(int)));

        connect(this, SIGNAL(minimumChanged(int)),
                horizontalSliders, SLOT(setMinimum(int)));
        connect(this, SIGNAL(maximumChanged(int)),
                horizontalSliders, SLOT(setMaximum(int)));
        connect(this, SIGNAL(appearanceInverted(bool)),
                horizontalSliders, SLOT(invertAppearance(bool)));
        connect(this, SIGNAL(controlsInverted(bool)),
                horizontalSliders, SLOT(invertControls(bool)));
        connect(this, SIGNAL(minimumChanged(int)),
                verticalSliders, SLOT(setMinimum(int)));
        connect(this, SIGNAL(maximumChanged(int)),
                verticalSliders, SLOT(setMaximum(int)));
        connect(this, SIGNAL(appearanceInverted(bool)),
                verticalSliders, SLOT(invertAppearance(bool)));
        connect(this, SIGNAL(controlsInverted(bool)),
                verticalSliders, SLOT(invertControls(bool)));

        QHBoxLayout *layout = new QHBoxLayout(this);
        layout->addWidget(controlsGroup);
        layout->addWidget(pages);

        setWindowTitle(tr("Sliders"));
    }

    void Window::createControls(const QString &title)
    {
        controlsGroup = new QGroupBox(title, this);

        QLabel *minimumLabel = new QLabel(tr("Minimum value"), controlsGroup);
        QLabel *maximumLabel = new QLabel(tr("Maximum value"), controlsGroup);
        QLabel *valueLabel = new QLabel(tr("Current value"), controlsGroup);

        QCheckBox *invertedAppearance = new QCheckBox(tr("Inverted appearance"),
                                                      controlsGroup);
        QCheckBox *invertedControls = new QCheckBox(tr("Inverted controls"),
                                                    controlsGroup);

        minimumSpinBox = new QSpinBox(controlsGroup);
        minimumSpinBox->setRange(-20, 20);
        minimumSpinBox->setSingleStep(1);
        minimumSpinBox->setValue(-20);

        maximumSpinBox = new QSpinBox(controlsGroup);
        maximumSpinBox->setRange(-20, 20);
        maximumSpinBox->setSingleStep(1);
        maximumSpinBox->setValue(20);

        valueSpinBox = new QSpinBox(controlsGroup);
        valueSpinBox->setRange(-20, 20);
        valueSpinBox->setSingleStep(1);
        valueSpinBox->setValue(10);

        orientationCombo = new QComboBox(controlsGroup);
        orientationCombo->insertItem(tr("Horizontal sliders"));
        orientationCombo->insertItem(tr("Vertical sliders"));

        connect(orientationCombo, SIGNAL(activated(int)),
                pages, SLOT(setCurrentIndex(int)));
        connect(valueSpinBox, SIGNAL(valueChanged(int)),
                this, SIGNAL(valueChanged(int)));
        connect(minimumSpinBox, SIGNAL(valueChanged(int)),
                this, SIGNAL(minimumChanged(int)));
        connect(maximumSpinBox, SIGNAL(valueChanged(int)),
                this, SIGNAL(maximumChanged(int)));
        connect(invertedAppearance, SIGNAL(toggled(bool)),
                this, SIGNAL(appearanceInverted(bool)));
        connect(invertedControls, SIGNAL(toggled(bool)),
                this, SIGNAL(controlsInverted(bool)));

        QGridLayout *controlsLayout = new QGridLayout(controlsGroup);
        controlsLayout->addWidget(minimumLabel, 0, 0);
        controlsLayout->addWidget(maximumLabel, 1, 0);
        controlsLayout->addWidget(valueLabel, 2, 0);
        controlsLayout->addWidget(minimumSpinBox, 0, 1);
        controlsLayout->addWidget(maximumSpinBox, 1, 1);
        controlsLayout->addWidget(valueSpinBox, 2, 1);
        controlsLayout->addWidget(invertedAppearance, 0, 2);
        controlsLayout->addWidget(invertedControls, 1, 2);
        controlsLayout->addWidget(orientationCombo, 3, 0, 1, 3);
    }

    void Window::setValue(int value)
    {
        valueSpinBox->setValue(value);
    }

    SlidersGroup::SlidersGroup(Qt::Orientation orientation, const QString &title,
                                 QWidget *parent)
        : QGroupBox(title, parent)
    {
        slider = new QSlider(orientation, this);
        slider->setFocusPolicy(Qt::ClickFocus);
        slider->setTickPosition(QSlider::TicksBothSides);
        slider->setTickInterval(10);
        slider->setRange(-20, 20);
        slider->setSingleStep(1);
        slider->setValue(0);

        scrollBar = new QScrollBar(orientation, this);
        scrollBar->setFocusPolicy(Qt::ClickFocus);
        scrollBar->setRange(-20, 20);
        scrollBar->setValue(0);

        dial = new QDial(this);
        dial->setRange(-20, 20);
        dial->setValue(0);

        connect(slider, SIGNAL(valueChanged(int)), scrollBar, SLOT(setValue(int)));
        connect(scrollBar, SIGNAL(valueChanged(int)), dial, SLOT(setValue(int)));
        connect(dial, SIGNAL(valueChanged(int)), this, SIGNAL(valueChanged(int)));

        QBoxLayout::Direction direction;

        if (orientation == Qt::Horizontal)
            direction = QBoxLayout::TopToBottom;
        else
            direction = QBoxLayout::LeftToRight;

        QBoxLayout *slidersLayout = new QBoxLayout(direction, this);
        slidersLayout->addWidget(slider);
        slidersLayout->addWidget(scrollBar);
        slidersLayout->addWidget(dial);
    }

    void SlidersGroup::setValue(int value)
    {
        slider->setValue(value);
    }

    void SlidersGroup::setMinimum(int value)
    {
        slider->setMinimum(value);
        scrollBar->setMinimum(value);
        dial->setMinimum(value);
    }

    void SlidersGroup::setMaximum(int value)
    {
        slider->setMaximum(value);
        scrollBar->setMaximum(value);
        dial->setMaximum(value);
    }

    void SlidersGroup::invertAppearance(bool invert)
    {
        slider->setInvertedAppearance(invert);
        scrollBar->setInvertedAppearance(invert);
        dial->setInvertedAppearance(invert);
    }

    void SlidersGroup::invertControls(bool invert)
    {
        slider->setInvertedControls(invert);
        scrollBar->setInvertedControls(invert);
        dial->setInvertedControls(invert);
    }


Copyright © 2004 Trolltech Trademarks
Qt 4.0.0-b1