C++ (Cpp) setConfigurationPageの例

コード例 #1

KisChalkOpOption::KisChalkOpOption()
        : KisPaintOpOption(i18n("Brush size"), false)
{
    m_checkable = false;
    m_options = new KisChalkOpOptionsWidget();
    setConfigurationPage(m_options);
}

コード例 #2

ファイル: kis_compositeop_option.cpp プロジェクト: ChrisJong/krita

KisCompositeOpOption::KisCompositeOpOption(bool createConfigWidget):
    KisPaintOpOption(KisPaintOpOption::GENERAL, true),
    m_createConfigWidget(createConfigWidget),
    m_eraserMode(false)
{
    m_checkable         = false;
    m_currCompositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();

    if (createConfigWidget) {
        QWidget* widget = new QWidget();

        Ui_wdgCompositeOpOption ui;
        ui.setupUi(widget);
        ui.bnEraser->setIcon(KisIconUtils::loadIcon("draw-eraser"));

        m_label    = ui.lbChoosenMode;
        m_list     = ui.list;
        m_bnEraser = ui.bnEraser;

        setConfigurationPage(widget);

        connect(ui.list    , SIGNAL(clicked(const QModelIndex&)), this, SLOT(slotCompositeOpChanged(const QModelIndex&)));
        connect(ui.bnEraser, SIGNAL(toggled(bool))                , this, SLOT(slotEraserToggled(bool)));
    }

    setObjectName("KisCompositeOpOption");

}

コード例 #3

ファイル: kis_pressure_mirror_option_widget.cpp プロジェクト: KDE/calligra-history

KisPressureMirrorOptionWidget::KisPressureMirrorOptionWidget()
    : KisCurveOptionWidget(new KisPressureMirrorOption())
{
    QWidget* w = new QWidget;
    m_horizontalMirror = new QCheckBox(i18n("Horizontally"));
    m_horizontalMirror->setChecked(false);
    m_verticalMirror = new QCheckBox(i18n("Vertically"));
    m_verticalMirror->setChecked(false);
    
    connect(m_horizontalMirror, SIGNAL(toggled(bool)),SLOT(horizontalMirrorChanged(bool)));
    connect(m_verticalMirror, SIGNAL(toggled(bool)),SLOT(verticalMirrorChanged(bool)));
    
    QHBoxLayout* hl = new QHBoxLayout;
    hl->addWidget(m_horizontalMirror);
    hl->addWidget(m_verticalMirror);

    QVBoxLayout* vl = new QVBoxLayout;
    vl->addLayout(hl);
    vl->addWidget(curveWidget());

    w->setLayout(vl);
    setConfigurationPage(w);
    horizontalMirrorChanged(m_horizontalMirror->isChecked());
    verticalMirrorChanged(m_verticalMirror->isChecked());
}

コード例 #4

ファイル: kis_pressure_scatter_option_widget.cpp プロジェクト: abhishekmurthy/Calligra

KisPressureScatterOptionWidget::KisPressureScatterOptionWidget()
    : KisCurveOptionWidget(new KisPressureScatterOption())
{
    QWidget* w = new QWidget;
    m_axisX = new QCheckBox(i18n("Axis X"));
    m_axisX->setChecked(true);
    m_axisY = new QCheckBox(i18n("Axis Y"));
    m_axisY->setChecked(true);
    
    QLabel* scatterLbl = new QLabel(i18n("Scatter amount"));
    
    QHBoxLayout* hl = new QHBoxLayout;
    hl->addWidget(scatterLbl);
    hl->addWidget(m_axisX);
    hl->addWidget(m_axisY);
    
    QVBoxLayout* vl = new QVBoxLayout;
    vl->setMargin(0);
    vl->addLayout(hl);
    vl->addWidget(curveWidget());

    w->setLayout(vl);

    connect(m_axisX, SIGNAL(toggled(bool)),SLOT(xAxisEnabled(bool)));
    connect(m_axisY, SIGNAL(toggled(bool)),SLOT(yAxisEnabled(bool)));

    setConfigurationPage(w);
    
    xAxisEnabled(m_axisX->isChecked());
    yAxisEnabled(m_axisY->isChecked());
}

コード例 #5

ファイル: kis_filter_option.cpp プロジェクト: KDE/krita

KisFilterOption::KisFilterOption()
    : KisPaintOpOption(KisPaintOpOption::FILTER, true)
{
    setObjectName("KisFilterOption");

    m_checkable = false;

    m_filterOptionWidget = new KisFilterOptionWidget();
    m_filterOptionWidget->hide();
    setConfigurationPage(m_filterOptionWidget);

    m_layout = new QGridLayout(m_filterOptionWidget->grpFilterOptions);

    // Check which filters support painting
    QList<QString> l = KisFilterRegistry::instance()->keys();
    QList<KoID> l2;
    QList<QString>::iterator it;
    for (it = l.begin(); it !=  l.end(); ++it) {
        KisFilterSP f = KisFilterRegistry::instance()->value((*it));
        if (f->supportsPainting()) {
            l2.push_back(KoID(*it, f->name()));
        }
    }
    m_filterOptionWidget->filtersList->setIDList(l2);
    connect(m_filterOptionWidget->filtersList, SIGNAL(activated(const KoID &)), SLOT(setCurrentFilter(const KoID &)));
    if (!l2.empty()) {
        setCurrentFilter(l2.first());
    }

    connect(m_filterOptionWidget->checkBoxSmudgeMode, SIGNAL(stateChanged(int)), this, SLOT(emitSettingChanged()));
}

コード例 #6

ファイル: kis_compositeop_option.cpp プロジェクト: abhishekmurthy/Calligra

KisCompositeOpOption::KisCompositeOpOption(bool createConfigWidget):
    KisPaintOpOption(i18n("Blending Mode"), KisPaintOpOption::brushCategory(), true),
    m_createConfigWidget(createConfigWidget)
{
    m_checkable         = false;
    m_prevCompositeOpID = KoCompositeOpRegistry::instance().getDefaultCompositeOp().id();
    m_currCompositeOpID = m_prevCompositeOpID;
    
    if(createConfigWidget) {
        QWidget* widget = new QWidget();
        
        Ui_wdgCompositeOpOption ui;
        ui.setupUi(widget);
        ui.bnEraser->setIcon(koIcon("draw-eraser"));
        
        m_label    = ui.lbChoosenMode;
        m_list     = ui.list;
        m_bnEraser = ui.bnEraser;
        
        setConfigurationPage(widget);
        
        connect(ui.list    , SIGNAL(activated(const QModelIndex&)), this, SLOT(slotCompositeOpChanged(const QModelIndex&)));
        connect(ui.bnEraser, SIGNAL(toggled(bool))                , this, SLOT(slotEraserToggled(bool)));
    }
}

コード例 #7

KisGridShapeOption::KisGridShapeOption()
    : KisPaintOpOption(i18n("Particle type"), KisPaintOpOption::generalCategory(), false)
{
    m_checkable = false;
    m_options = new KisShapeOptionsWidget();
    connect(m_options->shapeCBox, SIGNAL(currentIndexChanged(int)), SIGNAL(sigSettingChanged()));
    setConfigurationPage(m_options);
}

コード例 #8

KisBidirectionalMixingOption::KisBidirectionalMixingOption()
        : KisPaintOpOption(i18n("Mixing"), false)
{
    m_checkable = true;
    m_optionWidget = new QLabel(i18n("The mixing option mixes the paint on the brush with that on the canvas."));
    m_optionWidget->hide();
    setConfigurationPage(m_optionWidget);
}

コード例 #9

ファイル: kis_sprayop_option.cpp プロジェクト: ChrisJong/krita

KisSprayOpOption::KisSprayOpOption()
    : KisPaintOpOption(KisPaintOpOption::GENERAL, false)
{
    setObjectName("KisSprayOpOption");

    m_checkable = false;
    m_options = new KisSprayOpOptionsWidget();

    m_options->diameterSpinBox->setRange(1, 1000, 0);
    m_options->diameterSpinBox->setValue(100);
    m_options->diameterSpinBox->setExponentRatio(1.5);
    m_options->diameterSpinBox->setSuffix(i18n(" px"));

    m_options->aspectSPBox->setRange(0.0, 2.0, 2);
    m_options->aspectSPBox->setValue(1.0);

    m_options->rotationSPBox->setRange(0.0, 360.0, 0);
    m_options->rotationSPBox->setValue(0.0);
    m_options->rotationSPBox->setSuffix(QChar(Qt::Key_degree));

    m_options->scaleSpin->setRange(0.0, 10.0, 2);
    m_options->scaleSpin->setValue(1.0);

    m_options->spacingSpin->setRange(0.0, 5.0, 2);
    m_options->spacingSpin->setValue(0.5);

    m_options->coverageSpin->setRange(0.0, 100.0, 1);
    m_options->coverageSpin->setValue(0.1);
    m_options->coverageSpin->setSuffix("%");


    m_options->particlesSpinBox->setRange(1.0, 1000.0, 0);
    m_options->particlesSpinBox->setValue(12);
    m_options->particlesSpinBox->setExponentRatio(3.0);

    m_options->jitterMovementSpin->setRange(0.0,5.0, 1);
    m_options->jitterMovementSpin->setValue(1.0);


    connect(m_options->diameterSpinBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->coverageSpin, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->jitterMovementSpin, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->spacingSpin, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->scaleSpin, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->particlesSpinBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->countRadioButton, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
    connect(m_options->densityRadioButton, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
    connect(m_options->gaussianBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
    connect(m_options->aspectSPBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->rotationSPBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->jitterMoveBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));

    connect(m_options->countRadioButton, SIGNAL(toggled(bool)), m_options->particlesSpinBox, SLOT(setEnabled(bool)));
    connect(m_options->densityRadioButton, SIGNAL(toggled(bool)), m_options->coverageSpin, SLOT(setEnabled(bool)));
    connect(m_options->jitterMoveBox, SIGNAL(toggled(bool)), m_options->jitterMovementSpin, SLOT(setEnabled(bool)));

    setConfigurationPage(m_options);
}

コード例 #10

KisAirbrushOption::KisAirbrushOption(bool enabled)
    : KisPaintOpOption(i18n("Airbrush"), KisPaintOpOption::colorCategory(), enabled)
{
    m_checkable = true;
    m_optionWidget = new KisAirbrushWidget();
    connect(m_optionWidget->sliderRate, SIGNAL(valueChanged(int)), SIGNAL(sigSettingChanged()));

    setConfigurationPage(m_optionWidget);
}

コード例 #11

ファイル: kis_airbrush_option.cpp プロジェクト: KDE/krita

KisAirbrushOption::KisAirbrushOption(bool enabled)
    : KisPaintOpOption(KisPaintOpOption::COLOR, enabled)
{
    setObjectName("KisAirBrushOption");
    m_checkable = true;
    m_optionWidget = new KisAirbrushWidget();
    connect(m_optionWidget->sliderRate, SIGNAL(valueChanged(int)), SLOT(emitSettingChanged()));
    setConfigurationPage(m_optionWidget);
}

コード例 #12

KisDuplicateOpOption::KisDuplicateOpOption()
        : KisPaintOpOption(i18n("Painting Mode"), false)
{
    m_checkable = false;
    m_optionWidget = new KisDuplicateOpOptionsWidget();
    connect(m_optionWidget->cbHealing, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_optionWidget->cbPerspective, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
        
    setConfigurationPage(m_optionWidget);
}

コード例 #13

ファイル: kis_brush_option_widget.cpp プロジェクト: abhishekmurthy/Calligra

KisBrushOptionWidget::KisBrushOptionWidget()
        : KisPaintOpOption(i18n("Brush Tip"), KisPaintOpOption::brushCategory(), true)
{
    m_checkable = false;
    m_brushSelectionWidget = new KisBrushSelectionWidget();
    connect(m_brushSelectionWidget, SIGNAL(sigPrecisionChanged()), SIGNAL(sigSettingChanged()));
    connect(m_brushSelectionWidget, SIGNAL(sigBrushChanged()), SLOT(brushChanged()));
    m_brushSelectionWidget->hide();
    setConfigurationPage(m_brushSelectionWidget);
    m_brushOption.setBrush(brush());
}

コード例 #14

ファイル: kis_brush_size_option.cpp プロジェクト: IGLOU-EU/krita

KisBrushSizeOption::KisBrushSizeOption()
    : KisPaintOpOption(KisPaintOpOption::GENERAL, false)
{
    setObjectName("KisBrushSizeOption");

    m_checkable = false;
    m_options = new KisBrushSizeOptionsWidget();


    // init slider values
    m_options->diameter->setRange(1.0, 1000, 0);
    m_options->diameter->setValue(20);
    m_options->diameter->setExponentRatio(3.0);
    m_options->diameter->setSuffix(" px");

    m_options->aspectBox->setRange(0.01, 2.0, 2);
    m_options->aspectBox->setValue(1.0);
    m_options->aspectBox->setExponentRatio(1.0);


    m_options->scale->setRange(0.01, 10.0, 2);
    m_options->scale->setValue(1.0);

    m_options->spacing->setRange(0.01, 5.0, 2);
    m_options->spacing->setValue(0.3);


    m_options->rotationBox->setRange(0.0, 360.0, 0);
    m_options->rotationBox->setValue(0.0);
    m_options->rotationBox->setSuffix(QChar(Qt::Key_degree));


    m_options->densityBox->setRange(0.0, 100.0, 0);
    m_options->densityBox->setValue(100);
    m_options->densityBox->setSuffix("%");


    m_options->jitterMove->setRange(0.0, 5.0, 2);
    m_options->jitterMove->setValue(0.0);

    connect(m_options->diameter, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->scale, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->aspectBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->spacing, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->rotationBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->densityBox, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->jitterMove, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->jitterMoveBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));

    connect(m_options->jitterMoveBox, SIGNAL(toggled(bool)), m_options->jitterMove, SLOT(setEnabled(bool)));
    setConfigurationPage(m_options);
}

コード例 #15

ファイル: kis_hairy_shape_option.cpp プロジェクト: KDE/calligra-history

KisHairyShapeOption::KisHairyShapeOption()
        : KisPaintOpOption(i18n("Brush shape"), KisPaintOpOption::brushCategory(), false)
{
    m_checkable = false;
    m_options = new KisShapeOptionsWidget();

    connect(m_options->oneDimBrushBtn, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->twoDimBrushBtn, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->radiusSpinBox, SIGNAL(valueChanged(int)), SIGNAL(sigSettingChanged()));
    connect(m_options->sigmaSpinBox, SIGNAL(valueChanged(double)), SIGNAL(sigSettingChanged()));

    setConfigurationPage(m_options);
}

コード例 #16

ファイル: kis_duplicateop_option.cpp プロジェクト: ChrisJong/krita

KisDuplicateOpOption::KisDuplicateOpOption()
    : KisPaintOpOption(KisPaintOpOption::COLOR, false)
{
    setObjectName("KisDuplicateOpOption");

    m_checkable = false;
    m_optionWidget = new KisDuplicateOpOptionsWidget();

    connect(m_optionWidget->cbHealing, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
    connect(m_optionWidget->cbPerspective, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
    connect(m_optionWidget->cbSourcePoint, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
    connect(m_optionWidget->chkCloneProjection, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));

    setConfigurationPage(m_optionWidget);
}

コード例 #17

ファイル: kis_curve_line_option.cpp プロジェクト: IGLOU-EU/krita

KisCurveOpOption::KisCurveOpOption()
    : KisPaintOpOption(KisPaintOpOption::GENERAL, false)
{
    m_checkable = false;
    m_options = new KisCurveOpOptionsWidget();

    connect(m_options->connectionCHBox, SIGNAL(toggled(bool)), this, SLOT(emitSettingChanged()));
    connect(m_options->smoothingCHBox, SIGNAL(toggled(bool)), this, SLOT(emitSettingChanged()));
    connect(m_options->historySizeSlider, SIGNAL(valueChanged(qreal)), this, SLOT(emitSettingChanged()));
    connect(m_options->lineWidthSlider, SIGNAL(valueChanged(qreal)), this, SLOT(emitSettingChanged()));
    connect(m_options->curvesOpacitySlider, SIGNAL(valueChanged(qreal)), this, SLOT(emitSettingChanged()));

    setConfigurationPage(m_options);

    setObjectName("KisCurveOpOption");
}

コード例 #18

ファイル: kis_hatching_preferences.cpp プロジェクト: KDE/calligra-history

KisHatchingPreferences::KisHatchingPreferences()
: KisPaintOpOption(i18n("Hatching preferences"), KisPaintOpOption::brushCategory(), false)
{
    m_checkable = false;
    m_options = new KisHatchingPreferencesWidget();

    /*
    connect(m_options->trigonometryAlgebraRadioButton, SIGNAL(clicked(bool)),SIGNAL(sigSettingChanged()));
    connect(m_options->scratchOffRadioButton, SIGNAL(clicked(bool)),SIGNAL(sigSettingChanged()));
    */
    
    connect(m_options->antialiasCheckBox, SIGNAL(clicked(bool)),SIGNAL(sigSettingChanged()));
    connect(m_options->opaqueBackgroundCheckBox, SIGNAL(clicked(bool)),SIGNAL(sigSettingChanged()));
    connect(m_options->subpixelPrecisionCheckBox, SIGNAL(clicked(bool)),SIGNAL(sigSettingChanged()));
    
    setConfigurationPage(m_options);
}

コード例 #19

KisHairyBristleOption::KisHairyBristleOption()
    : KisPaintOpOption(i18n("Bristle options"), KisPaintOpOption::generalCategory(), false)
{
    m_checkable = false;
    m_options = new KisBristleOptionsWidget();

    // signals
    connect(m_options->mousePressureCBox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->thresholdCBox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->rndBox, SIGNAL(valueChanged(qreal)), SIGNAL(sigSettingChanged()));
    connect(m_options->scaleBox, SIGNAL(valueChanged(qreal)), SIGNAL(sigSettingChanged()));
    connect(m_options->shearBox, SIGNAL(valueChanged(qreal)), SIGNAL(sigSettingChanged()));
    connect(m_options->densityBox, SIGNAL(valueChanged(qreal)), SIGNAL(sigSettingChanged()));
    connect(m_options->connectedCBox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->antialiasCBox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->compositingCBox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    setConfigurationPage(m_options);
}

コード例 #20

KisSketchOpOption::KisSketchOpOption()
    : KisPaintOpOption(i18n("Brush size"), KisPaintOpOption::generalCategory(), false)
{
    m_checkable = false;
    m_options = new KisSketchOpOptionsWidget();
    connect(m_options->offsetSPBox, SIGNAL(valueChanged(double)), SIGNAL(sigSettingChanged()));
    connect(m_options->lineWidthSPBox, SIGNAL(valueChanged(double)), SIGNAL(sigSettingChanged()));
    connect(m_options->densitySPBox, SIGNAL(valueChanged(double)), SIGNAL(sigSettingChanged()));
    connect(m_options->simpleModeCHBox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->connectionCHBox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->magnetifyCHBox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->randomRGBCHbox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->randomOpacityCHbox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->distanceDensityCHBox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->distanceOpacityCHbox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));

    setConfigurationPage(m_options);
}

コード例 #21

ファイル: kis_pressure_flow_opacity_option_widget.cpp プロジェクト: ChrisJong/krita

KisFlowOpacityOptionWidget::KisFlowOpacityOptionWidget():
    KisCurveOptionWidget(new KisFlowOpacityOption(0), i18n("Transparent"), i18n("Opaque"), true)
{
    setObjectName("KisFlowOpacityOptionWidget");

    QWidget* widget = new QWidget();

    Ui_wdgFlowOpacityOption ui;
    ui.setupUi(widget);
    ui.layout->addWidget(curveWidget());

    m_opacitySlider = ui.opacitySlider;
    m_opacitySlider->setRange(0.0, 1.0, 2);
    m_opacitySlider->setValue(1.0);

    setConfigurationPage(widget);

    connect(m_opacitySlider, SIGNAL(valueChanged(qreal)), SLOT(slotSliderValueChanged()));
}

コード例 #22

ファイル: kis_hatching_preferences.cpp プロジェクト: KDE/krita

KisHatchingPreferences::KisHatchingPreferences()
    : KisPaintOpOption(KisPaintOpOption::GENERAL, false)
{
    setObjectName("KisHatchingPreferences");

    m_checkable = false;
    m_options = new KisHatchingPreferencesWidget();

    /*
    connect(m_options->trigonometryAlgebraRadioButton, SIGNAL(clicked(bool)),SLOT(emitSettingChanged()));
    connect(m_options->scratchOffRadioButton, SIGNAL(clicked(bool)),SLOT(emitSettingChanged()));
    */

    connect(m_options->antialiasCheckBox, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));
    connect(m_options->opaqueBackgroundCheckBox, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));
    connect(m_options->subpixelPrecisionCheckBox, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));

    setConfigurationPage(m_options);
}

コード例 #23

KisSprayShapeOption::KisSprayShapeOption()
    : KisPaintOpOption(i18n("Spray shape"), KisPaintOpOption::generalCategory(), true)
{
    m_checkable = true;
    // save this to be able to restore it back
    m_maxSize = 1000;

    m_options = new KisShapeOptionsWidget();
    m_useAspect = m_options->aspectButton->keepAspectRatio();
    computeAspect();

    // UI signals
    connect(m_options->proportionalBox, SIGNAL(clicked(bool)), SLOT(changeSizeUI(bool)));
    connect(m_options->aspectButton, SIGNAL(keepAspectRatioChanged(bool)), this, SLOT(aspectToggled(bool)));
    connect(m_options->imageUrl, SIGNAL(textChanged(QString)), this, SLOT(prepareImage()));

    connect(m_options->widthSpin, SIGNAL(valueChanged(int)), SLOT(updateHeight(int)));
    connect(m_options->heightSpin, SIGNAL(valueChanged(int)), SLOT(updateWidth(int)));

    setupBrushPreviewSignals();
    setConfigurationPage(m_options);
}

コード例 #24

ファイル: kis_hatching_options.cpp プロジェクト: KDE/calligra-history

KisHatchingOptions::KisHatchingOptions()
        : KisPaintOpOption(i18n("Hatching options"), KisPaintOpOption::brushCategory(), false)
{
    m_checkable = false;
    m_options = new KisHatchingOptionsWidget();
    
    connect(m_options->angleKisDoubleSliderSpinBox, SIGNAL(valueChanged(qreal)), SIGNAL(sigSettingChanged()));
    connect(m_options->separationKisDoubleSliderSpinBox, SIGNAL(valueChanged(qreal)), SIGNAL(sigSettingChanged()));
    connect(m_options->thicknessKisDoubleSliderSpinBox, SIGNAL(valueChanged(qreal)), SIGNAL(sigSettingChanged()));
    connect(m_options->originXKisDoubleSliderSpinBox, SIGNAL(valueChanged(qreal)), SIGNAL(sigSettingChanged()));
    connect(m_options->originYKisDoubleSliderSpinBox, SIGNAL(valueChanged(qreal)), SIGNAL(sigSettingChanged()));
   
    connect(m_options->noCrosshatchingRadioButton, SIGNAL(clicked(bool)),SIGNAL(sigSettingChanged()));
    connect(m_options->perpendicularRadioButton, SIGNAL(clicked(bool)),SIGNAL(sigSettingChanged()));
    connect(m_options->minusThenPlusRadioButton, SIGNAL(clicked(bool)),SIGNAL(sigSettingChanged()));
    connect(m_options->plusThenMinusRadioButton, SIGNAL(clicked(bool)),SIGNAL(sigSettingChanged()));
    connect(m_options->moirePatternRadioButton, SIGNAL(clicked(bool)),SIGNAL(sigSettingChanged()));
    
    connect(m_options->separationIntervalSpinBox, SIGNAL(valueChanged(int)),SIGNAL(sigSettingChanged()));
    
    setConfigurationPage(m_options);
}

コード例 #25

KisPressureRateOption::KisPressureRateOption()
    : KisCurveOption(i18n("Rate"), "Rate")
{
    QWidget* w = new QWidget;
    QLabel* rateLabel = new QLabel(i18n("Rate: "));
    m_rateSlider = new QSlider();
    m_rateSlider->setMinimum(0);
    m_rateSlider->setMaximum(100);
    m_rateSlider->setPageStep(1);
    m_rateSlider->setValue(50);
    m_rateSlider->setOrientation(Qt::Horizontal);
    QHBoxLayout* hl = new QHBoxLayout;
    hl->addWidget( rateLabel );
    hl->addWidget( m_rateSlider );

    QVBoxLayout* vl = new QVBoxLayout;
    vl->addLayout( hl );
    vl->addWidget( m_curveWidget );

    w->setLayout( vl );
    setConfigurationPage( w );
}

コード例 #26

ファイル: kis_deform_option.cpp プロジェクト: TheTypoMaster/calligra

KisDeformOption::KisDeformOption()
    : KisPaintOpOption(KisPaintOpOption::COLOR, false)
{
    setObjectName("KisDeformOption");

    m_checkable = false;
    m_options = new KisDeformOptionsWidget();

    connect(m_options->deformAmount, SIGNAL(valueChanged(qreal)), SLOT(emitSettingChanged()));
    connect(m_options->interpolationChBox, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
    connect(m_options->useCounter, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));
    connect(m_options->useOldData, SIGNAL(toggled(bool)), SLOT(emitSettingChanged()));

    connect(m_options->growBtn, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));
    connect(m_options->shrinkBtn, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));
    connect(m_options->swirlCWBtn, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));
    connect(m_options->swirlCCWBtn, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));
    connect(m_options->moveBtn, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));
    connect(m_options->lensBtn, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));
    connect(m_options->lensOutBtn, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));
    connect(m_options->colorBtn, SIGNAL(clicked(bool)), SLOT(emitSettingChanged()));

    setConfigurationPage(m_options);
}

コード例 #27

KisSprayOpOption::KisSprayOpOption()
    : KisPaintOpOption(i18n("Spray area"), KisPaintOpOption::generalCategory(), false)
{
    m_checkable = false;
    m_options = new KisSprayOpOptionsWidget();
    connect(m_options->diameterSpinBox, SIGNAL(valueChanged(double)), SIGNAL(sigSettingChanged()));
    connect(m_options->coverageSpin, SIGNAL(valueChanged(double)), SIGNAL(sigSettingChanged()));
    connect(m_options->jitterMovementSpin, SIGNAL(valueChanged(double)), SIGNAL(sigSettingChanged()));
    connect(m_options->spacingSpin, SIGNAL(valueChanged(double)), SIGNAL(sigSettingChanged()));
    connect(m_options->scaleSpin, SIGNAL(valueChanged(double)), SIGNAL(sigSettingChanged()));
    connect(m_options->particlesSpinBox, SIGNAL(valueChanged(double)), SIGNAL(sigSettingChanged()));
    connect(m_options->countRadioButton, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->densityRadioButton, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->gaussianBox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));
    connect(m_options->aspectSPBox, SIGNAL(valueChanged(double)), SIGNAL(sigSettingChanged()));
    connect(m_options->rotationSPBox, SIGNAL(valueChanged(double)), SIGNAL(sigSettingChanged()));
    connect(m_options->jitterMoveBox, SIGNAL(toggled(bool)), SIGNAL(sigSettingChanged()));

    connect(m_options->countRadioButton, SIGNAL(toggled(bool)), m_options->particlesSpinBox, SLOT(setEnabled(bool)));
    connect(m_options->densityRadioButton, SIGNAL(toggled(bool)), m_options->coverageSpin, SLOT(setEnabled(bool)));
    connect(m_options->jitterMoveBox, SIGNAL(toggled(bool)), m_options->jitterMovementSpin, SLOT(setEnabled(bool)));

    setConfigurationPage(m_options);
}