kis_dlg_layer_style.h

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: 2014 Boudewijn Rempt <boud@valdyas.org>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 */
#ifndef KIS_DLG_LAYER_STYLE_H
#define KIS_DLG_LAYER_STYLE_H
 
#include <QUuid>
 
#include <KoDialog.h>
 
#include "kis_types.h"
 
#include "ui_wdglayerstyles.h"
#include "ui_wdgBevelAndEmboss.h"
#include "ui_wdgblendingoptions.h"
#include "ui_WdgColorOverlay.h"
#include "ui_wdgContour.h"
#include "ui_wdgdropshadow.h"
#include "ui_WdgGradientOverlay.h"
#include "ui_wdgInnerGlow.h"
#include "ui_WdgPatternOverlay.h"
#include "ui_WdgSatin.h"
#include "ui_WdgStroke.h"
#include "ui_wdgstylesselector.h"
#include "ui_wdgTexture.h"
 
 
#include <QSortFilterProxyModel>
 
#include <kis_psd_layer_style.h>
 
class QListWidgetItem;
class KisSignalCompressor;
class KisCanvasResourceProvider;
 
 
class Contour : public QWidget {
    Q_OBJECT
public:
    Contour(QWidget *parent);
    Ui::WdgContour ui;
};
 
 
class Texture : public QWidget {
    Q_OBJECT
public:
    Texture(QWidget *parent);
    Ui::WdgTexture ui;
};
 
 
class BevelAndEmboss : public QWidget {
    Q_OBJECT
public:
    BevelAndEmboss(Contour *contour, Texture *texture, QWidget *parent);
    void setBevelAndEmboss(const psd_layer_effects_bevel_emboss *bevelAndEmboss);
    void fetchBevelAndEmboss(psd_layer_effects_bevel_emboss *bevelAndEmboss) const;
 
Q_SIGNALS:
    void configChanged();
    void globalAngleChanged(int value);
 
private:
    Contour *m_contour;
    Texture *m_texture;
    Ui::WdgBevelAndEmboss ui;
};
 
class BlendingOptions : public QWidget {
    Q_OBJECT
public:
    BlendingOptions(QWidget *parent);
Q_SIGNALS:
    void configChanged();
 
private:
    Ui::WdgBlendingOptions ui;
};
 
 
class ColorOverlay : public QWidget {
    Q_OBJECT
public:
    ColorOverlay(QWidget *parent);
    void setColorOverlay(const psd_layer_effects_color_overlay *colorOverlay);
    void fetchColorOverlay(psd_layer_effects_color_overlay *colorOverlay) const;
 
Q_SIGNALS:
    void configChanged();
 
private:
    Ui::WdgColorOverlay ui;
};
 
 
class DropShadow : public QWidget {
    Q_OBJECT
 
public:
    enum Mode {
        DropShadowMode,
        InnerShadowMode
    };
 
public:
    DropShadow(Mode mode, QWidget *parent);
    void setShadow(const psd_layer_effects_shadow_common *shadow);
    void fetchShadow(psd_layer_effects_shadow_common *shadow) const;
 
Q_SIGNALS:
    void configChanged();
    void globalAngleChanged(int value);
 
private:
    Ui::WdgDropShadow ui;
    Mode m_mode;
};
 
class GradientOverlay : public QWidget {
    Q_OBJECT
public:
    GradientOverlay(KisCanvasResourceProvider *resourceProvider, QWidget *parent);
    void setGradientOverlay(const psd_layer_effects_gradient_overlay *gradient);
    void fetchGradientOverlay(psd_layer_effects_gradient_overlay *gradient) const;
 
Q_SIGNALS:
    void configChanged();
 
private:
    Ui::WdgGradientOverlay ui;
    KisCanvasResourceProvider *m_resourceProvider;
};
 
class InnerGlow : public QWidget {
    Q_OBJECT
public:
    enum Mode {
        InnerGlowMode = 0,
        OuterGlowMode
    };
 
public:
    InnerGlow(Mode mode, KisCanvasResourceProvider *resourceProvider, QWidget *parent);
    void setConfig(const psd_layer_effects_glow_common *innerGlow);
    void fetchConfig(psd_layer_effects_glow_common *innerGlow) const;
 
Q_SIGNALS:
    void configChanged();
 
private:
    Ui::WdgInnerGlow ui;
    Mode m_mode;
    KisCanvasResourceProvider *m_resourceProvider;
};
 
class PatternOverlay : public QWidget {
    Q_OBJECT
public:
    PatternOverlay(QWidget *parent);
    void setPatternOverlay(const psd_layer_effects_pattern_overlay *pattern);
    void fetchPatternOverlay(psd_layer_effects_pattern_overlay *pattern) const;
 
Q_SIGNALS:
    void configChanged();
 
private:
    Ui::WdgPatternOverlay ui;
};
 
class Satin : public QWidget {
    Q_OBJECT
public:
    Satin(QWidget *parent);
    void setSatin(const psd_layer_effects_satin *satin);
    void fetchSatin(psd_layer_effects_satin *satin) const;
 
Q_SIGNALS:
    void configChanged();
 
private:
    Ui::WdgSatin ui;
};
 
class Stroke : public QWidget {
    Q_OBJECT
public:
    Stroke(KisCanvasResourceProvider *resourceProvider, QWidget *parent);
    void setStroke(const psd_layer_effects_stroke *stroke);
    void fetchStroke(psd_layer_effects_stroke *stroke) const;
 
Q_SIGNALS:
    void configChanged();
 
private:
    Ui::WdgStroke ui;
    KisCanvasResourceProvider *m_resourceProvider;
};
 
 
class KisResourceModel;
class StylesSelector : public QWidget {
    Q_OBJECT
 
protected:
    class LocationProxyModel : public QSortFilterProxyModel
    {
    public:
        LocationProxyModel(QObject* parent);
 
        void setEnableFiltering(bool enableFiltering);
        void setLocationToFilterBy(QString location);
 
    private:
        QString m_locationToFilter;
        bool m_enableFiltering {false};
 
 
        // QSortFilterProxyModel interface
    protected:
        bool filterAcceptsRow(int source_row,
                              const QModelIndex &source_parent) const override;
    };
 
 
public:
    StylesSelector(QWidget *parent);
 
    void notifyExternalStyleChanged(const QString &name, const QUuid &uuid);
 
    void addNewStyle(const QString &location, const KisPSDLayerStyleSP style);
    void loadCollection(const QString &fileName);
 
    void refillCollections();
 
private Q_SLOTS:
 
    void slotResourceModelReset();
 
    void loadStyles(const QString &name);
    void selectStyle(QModelIndex current);
Q_SIGNALS:
    void styleSelected(KisPSDLayerStyleSP style);
 
 
 
 
private:
    Ui::WdgStylesSelector ui;
    LocationProxyModel* m_locationsProxyModel;
    KisResourceModel* m_resourceModel;
};
 
class KisDlgLayerStyle : public KoDialog
{
    Q_OBJECT
public:
    explicit KisDlgLayerStyle(KisPSDLayerStyleSP layerStyle, KisCanvasResourceProvider *resourceProvider, QWidget *parent = 0);
    ~KisDlgLayerStyle() override;
 
    KisPSDLayerStyleSP style() const;
 
Q_SIGNALS:
    void configChanged();
 
public Q_SLOTS:
    void slotMasterFxSwitchChanged(bool value);
    void syncGlobalAngle(int angle);
 
    void notifyGuiConfigChanged();
    void notifyPredefinedStyleSelected(KisPSDLayerStyleSP style);
 
    void slotBevelAndEmbossChanged(QListWidgetItem*);
 
    void changePage(QListWidgetItem *, QListWidgetItem*);
 
    void slotNotifyOnAccept();
    void slotNotifyOnReject();
 
    // Sets all the widgets to the contents of the given style
    void setStyle(KisPSDLayerStyleSP style);
 
    void slotLoadStyle();
    void slotSaveStyle();
    void slotNewStyle();
 
private:
 
    KisPSDLayerStyleSP m_layerStyle;
    KisPSDLayerStyleSP m_initialLayerStyle;
 
    Ui::WdgStylesDialog wdgLayerStyles;
 
    BevelAndEmboss *m_bevelAndEmboss;
    BlendingOptions *m_blendingOptions;
    ColorOverlay *m_colorOverlay;
    Contour *m_contour;
    DropShadow *m_dropShadow;
    GradientOverlay *m_gradientOverlay;
    InnerGlow *m_innerGlow;
    DropShadow *m_innerShadow;
    InnerGlow *m_outerGlow;
    PatternOverlay * m_patternOverlay;
    Satin *m_satin;
    Stroke *m_stroke;
    StylesSelector *m_stylesSelector;
    Texture *m_texture;
 
    KisSignalCompressor *m_configChangedCompressor;
    bool m_isSwitchingPredefinedStyle;
 
    mutable bool m_sanityLayerStyleDirty;
};
 
#endif // KIS_DLG_LAYER_STYLE_H