KisCustomBrushWidget Class Reference

#include <kis_custom_brush_widget.h>

Inheritance diagram for KisCustomBrushWidget:

Signals
void	sigNewPredefinedBrush (KoResourceSP)

Public Member Functions
	KisCustomBrushWidget (QWidget *parent, const QString &caption)
virtual	~KisCustomBrushWidget ()

Private Slots
void	slotAddPredefined ()
void	slotReload ()
void	slotSourceChanged (int source)
void	slotUpdateBrush ()
void	slotUpdateSaveButton ()

Private Member Functions
int	currentBrushStyle ()
KisConfigWidget *	currentBrushWidget ()
KisImageWSP	currentImage ()
QString	fileName ()
void	loadImage ()
KisConfigWidget *	otherBrushWidget ()
void	swapBrushWidget ()
void	updatePreviewImage (bool updateDev)

Private Attributes
KisConfigWidget *	m_animBrushWidget {nullptr}
KisConfigWidget *	m_brushWidget {nullptr}
QDialogButtonBox *	m_buttonBox {nullptr}
KisPaintDeviceSP	m_dev {nullptr}
QVector< QVector< KisPaintDevice * > >	m_devices
QRect	m_devRect
const KoColorSpace *	m_imageColorSpace
QSize	m_imageSize
KisPropertiesConfigurationSP	m_oldConfig {nullptr}
QLabel *	m_preview {nullptr}
KoResourceServer< KisBrush > *	m_rServer {0}
bool	m_useClipboard {false}

Detailed Description

Definition at line 22 of file kis_custom_brush_widget.h.

Constructor & Destructor Documentation

KisCustomBrushWidget()

KisCustomBrushWidget::KisCustomBrushWidget	(	QWidget *	parent,
		const QString &	caption )

Definition at line 63 of file kis_custom_brush_widget.cpp.

    : QDialog(parent)
{
    setWindowTitle(caption);
 
    QVBoxLayout* layout = new QVBoxLayout();
    QHBoxLayout* hLayout = new QHBoxLayout();
 
    m_preview = new QLabel();
    m_preview->setFixedSize(110, 110);
    m_preview->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    m_preview->setScaledContents(false);
    m_preview->setFrameStyle(QFrame::StyledPanel | QFrame::Plain);
    m_preview->setAlignment(Qt::AlignCenter);
    m_preview->setWordWrap(true);
    hLayout->addWidget(m_preview);
 
    QLabel* sourceLabel = new QLabel(i18nc("@label:listbox image source", "Source:"));
    hLayout->addWidget(sourceLabel);
 
    QComboBox* sourceBox = new QComboBox();
    sourceBox->addItem(i18nc("@item:inlistbox", "Image"), Source::Image);
    sourceBox->addItem(i18nc("@item:inlistbox", "Clipboard"), Source::Clipboard);
    hLayout->addWidget(sourceBox);
 
    QPushButton* reloadButton = new QPushButton(i18nc("@action:button reload image", "Reload"));
    hLayout->addWidget(reloadButton);
 
    layout->addLayout(hLayout);
 
    const QString mimetype = "image/x-gimp-brush";
    QSharedPointer<KisImportExportFilter> filter(KisImportExportManager::filterForMimeType(mimetype, KisImportExportManager::Export));
    KIS_SAFE_ASSERT_RECOVER_RETURN(filter);
    m_brushWidget = filter->createConfigurationWidget(0, 0, mimetype.toLatin1());
    connect(m_brushWidget, SIGNAL(sigConfigurationUpdated()), this, SLOT(slotUpdateBrush()));
 
    const QString animMimetype = "image/x-gimp-brush-animated";
    QSharedPointer<KisImportExportFilter> animFilter(KisImportExportManager::filterForMimeType(animMimetype, KisImportExportManager::Export));
    KIS_SAFE_ASSERT_RECOVER_RETURN(animFilter);
    m_animBrushWidget = animFilter->createConfigurationWidget(0, 0, animMimetype.toLatin1());
    connect(m_animBrushWidget, SIGNAL(sigConfigurationUpdated()), this, SLOT(slotUpdateBrush()));
    layout->addWidget(m_animBrushWidget);
 
    m_oldConfig = currentBrushWidget()->configuration();
 
    m_rServer = KisBrushServerProvider::instance()->brushServer();
 
    m_buttonBox = new QDialogButtonBox(QDialogButtonBox::Cancel|QDialogButtonBox::Save);
    KGuiItem::assign(m_buttonBox->button(QDialogButtonBox::Save), KStandardGuiItem::save());
    KGuiItem::assign(m_buttonBox->button(QDialogButtonBox::Cancel), KStandardGuiItem::cancel());
    layout->addWidget(m_buttonBox);
    connect(m_buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
    connect(m_buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
 
    setLayout(layout);
 
    connect(this, SIGNAL(accepted()), SLOT(slotAddPredefined()));
    connect(reloadButton, SIGNAL(clicked()), this, SLOT(slotReload()));
    connect(sourceBox, SIGNAL(activated(int)), this, SLOT(slotSourceChanged(int)));
 
    loadImage();
}

References KisBrushServerProvider::brushServer(), Clipboard, KisConfigWidget::configuration(), currentBrushWidget(), KisImportExportManager::Export, KisImportExportManager::filterForMimeType(), Image, KisBrushServerProvider::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN, loadImage(), m_animBrushWidget, m_brushWidget, m_buttonBox, m_oldConfig, m_preview, m_rServer, slotAddPredefined(), slotReload(), slotSourceChanged(), and slotUpdateBrush().

~KisCustomBrushWidget()

KisCustomBrushWidget::~KisCustomBrushWidget ( )

virtual

Definition at line 126 of file kis_custom_brush_widget.cpp.

{
}

Member Function Documentation

currentBrushStyle()

int KisCustomBrushWidget::currentBrushStyle ( )

private

Definition at line 156 of file kis_custom_brush_widget.cpp.

{
    return (BrushStyle)currentBrushWidget()->configuration()->getInt(KEY_BRUSH_STYLE);
}

References KisConfigWidget::configuration(), currentBrushWidget(), and KEY_BRUSH_STYLE.

currentBrushWidget()

KisConfigWidget * KisCustomBrushWidget::currentBrushWidget ( )

private

Definition at line 130 of file kis_custom_brush_widget.cpp.

{
    if (m_useClipboard) { // Can't be animated
        return m_brushWidget;
    } else {
        return m_animBrushWidget;
    }
}

References m_animBrushWidget, m_brushWidget, and m_useClipboard.

currentImage()

KisImageWSP KisCustomBrushWidget::currentImage ( )

private

Definition at line 169 of file kis_custom_brush_widget.cpp.

{
    KisMainWindow *mainWin = KisPart::instance()->currentMainwindow();
    if (!mainWin) { return nullptr; }
    KisViewManager *viewManager = mainWin->viewManager();
    if (!viewManager) { return nullptr; }
 
    // Animated uses the view for the layer (frames) count.
    m_animBrushWidget->setView(viewManager);
    return viewManager->image();
}

References KisPart::currentMainwindow(), KisViewManager::image(), KisPart::instance(), m_animBrushWidget, KisConfigWidget::setView(), and KisMainWindow::viewManager.

fileName()

QString KisCustomBrushWidget::fileName ( )

private

Definition at line 161 of file kis_custom_brush_widget.cpp.

{
    const QString name = currentBrushWidget()->configuration()->getString(KEY_NAME);
    const QString suffix = currentBrushStyle() == BrushStyle::Regular ? ".gbr" : ".gih";
    // Export to a temp location, the resource system doesn't like importing from the resource folder
    return QStandardPaths::writableLocation(QStandardPaths::TempLocation) + "/" + name.split(" ").join("_") + suffix;
}

References KisConfigWidget::configuration(), currentBrushStyle(), currentBrushWidget(), KEY_NAME, and Regular.

loadImage()

void KisCustomBrushWidget::loadImage ( )

private

Definition at line 327 of file kis_custom_brush_widget.cpp.

{
    if (currentBrushStyle() == BrushStyle::Regular) {
        KisImageWSP image;
        if (!m_dev) {
            if (m_useClipboard) {
                KisImageSP clipImage = KisClipboard::instance()->clipImage(false);
                if (clipImage) {
                    m_dev = new KisPaintDevice(*clipImage->projection());
                    m_devRect = clipImage->projection()->exactBounds();
 
                    // if the device has non-transparent default pixel, we
                    // should bake that, otherwise calls to exactBounds() will
                    // have negative effects
                    KisToolUtils::bakeDefaultPixel(m_dev, m_devRect);
                }
            } else if ((image = currentImage())) {
                // create copy of the data
                image->barrierLock();
                m_dev = new KisPaintDevice(*image->projection());
                m_devRect = QRect(QPoint(0,0), image->size());
                image->unlock();
 
                KisSelectionSP selection = image->globalSelection();
                if (selection) {
                    // apply selection mask
                    QRect r = selection->selectedExactRect();
 
                    KisHLineIteratorSP pixelIt = m_dev->createHLineIteratorNG(r.x(), r.top(), r.width());
                    KisHLineConstIteratorSP maskIt = selection->projection()->createHLineIteratorNG(r.x(), r.top(), r.width());
 
                    for (qint32 y = r.top(); y <= r.bottom(); ++y) {
                        do {
                            m_dev->colorSpace()->applyAlphaU8Mask(pixelIt->rawData(), maskIt->oldRawData(), 1);
                        } while (pixelIt->nextPixel() && maskIt->nextPixel());
 
                        pixelIt->nextRow();
                        maskIt->nextRow();
                    }
 
                    m_dev->crop(r);
                    m_devRect = r;
                }
            }
            updatePreviewImage(true);
        }
    } else /*if (currentBrushStyle() == BrushStyle::Animated)*/ {
        KisImageWSP image;
        if (m_devices.isEmpty() && (image = currentImage())) {
            // For each layer in the current image, create a new image, and add it to the list
            m_devices.clear();
            m_devices.append(QVector<KisPaintDevice*>());
 
            KisImageReadOnlyBarrierLock lock(image);
 
            m_imageSize = image->size();
            m_imageColorSpace = image->colorSpace();
 
            // We only loop over the rootLayer. Since we actually should have a layer selection
            // list, no need to elaborate on that here and now
            KoProperties properties;
            properties.setProperty("visible", true);
            QList<KisNodeSP> layers = image->root()->childNodes(QStringList("KisLayer"), properties);
            Q_FOREACH (KisNodeSP node, layers) {
                m_devices[0].append(node->projection().data());
            }
        }
        updatePreviewImage(true);
    }
 
    m_buttonBox->button(QDialogButtonBox::Save)->setEnabled(m_dev || !m_devices.isEmpty());
}

References KoColorSpace::applyAlphaU8Mask(), KisToolUtils::bakeDefaultPixel(), KisImage::barrierLock(), KisNode::childNodes(), KisClipboard::clipImage(), KisImage::colorSpace(), KisPaintDevice::colorSpace(), KisPaintDevice::createHLineIteratorNG(), KisPaintDevice::crop(), currentBrushStyle(), currentImage(), KisSharedPtr< T >::data(), KisPaintDevice::exactBounds(), KisImage::globalSelection(), KisClipboard::instance(), m_buttonBox, m_dev, m_devices, m_devRect, m_imageColorSpace, m_imageSize, m_useClipboard, KisBaseConstIteratorNG::nextPixel(), KisHLineConstIteratorNG::nextRow(), KisBaseConstAccessor::oldRawData(), KisImage::projection(), KisSelection::projection(), KisBaseNode::projection(), Regular, KisNodeFacade::root, KisSelection::selectedExactRect(), KoProperties::setProperty(), KisImage::size(), KisImage::unlock(), and updatePreviewImage().

otherBrushWidget()

KisConfigWidget * KisCustomBrushWidget::otherBrushWidget ( )

private

Definition at line 139 of file kis_custom_brush_widget.cpp.

{
    if (m_useClipboard) { // Can't be animated
        return m_animBrushWidget;
    } else {
        return m_brushWidget;
    }
}

References m_animBrushWidget, m_brushWidget, and m_useClipboard.

sigNewPredefinedBrush

void KisCustomBrushWidget::sigNewPredefinedBrush ( KoResourceSP )

signal

slotAddPredefined

void KisCustomBrushWidget::slotAddPredefined ( )

privateslot

Definition at line 284 of file kis_custom_brush_widget.cpp.

{
    if (!m_rServer || !(m_dev || !m_devices.isEmpty())) {
        close();
        return;
    }
 
    KisDocument* doc = KisPart::instance()->createTemporaryDocument();
    // Don't show a second export dialog when calling export later.
    doc->setFileBatchMode(true);
    KisImageSP image;
 
    if (currentBrushStyle() == BrushStyle::Regular) {
        image = new KisImage(0, m_devRect.width(), m_devRect.height(), m_dev->colorSpace(), TEMPORARY_BRUSH_NAME);
        KisNodeSP node = new KisPaintLayer(image, TEMPORARY_BRUSH_NAME, OPACITY_OPAQUE_U8, m_dev);
        image->addNode(node);
    } else /*if (currentBrushStyle() == BrushStyle::Animated)*/ {
        image = new KisImage(0, m_imageSize.width(), m_imageSize.height(), m_imageColorSpace, TEMPORARY_BRUSH_NAME);
        Q_FOREACH(KisPaintDeviceSP dev, m_devices[0]) {
            KisNodeSP node = new KisPaintLayer(image, TEMPORARY_BRUSH_NAME, OPACITY_OPAQUE_U8, dev);
            image->addNode(node);
        }
    }
 
    doc->setCurrentImage(image);
 
    const QByteArray mimetype = currentBrushStyle() == BrushStyle::Regular ? "image/x-gimp-brush" : "image/x-gimp-brush-animated";
    QString path = fileName();
    bool success = doc->exportDocumentSync(path, mimetype, currentBrushWidget()->configuration());
    doc->deleteLater();
 
    // Add it to the brush server, so that it automatically gets to the mediators, and
    // so to the other brush choosers can pick it up, if they want to
    if (success) {
        KoResourceSP resource = KisResourceUserOperations::importResourceFileWithUserInput(this, QString(), ResourceType::Brushes, path);
        if (resource) {
            Q_EMIT sigNewPredefinedBrush(resource);
        }
    }
 
    close();
}

References KisNodeFacade::addNode(), ResourceType::Brushes, KisPaintDevice::colorSpace(), KisPart::createTemporaryDocument(), currentBrushStyle(), currentBrushWidget(), KisDocument::exportDocumentSync(), fileName(), KisResourceUserOperations::importResourceFileWithUserInput(), KisPart::instance(), m_dev, m_devices, m_devRect, m_imageColorSpace, m_imageSize, m_rServer, OPACITY_OPAQUE_U8, Regular, KisDocument::setCurrentImage(), KisDocument::setFileBatchMode(), sigNewPredefinedBrush(), and TEMPORARY_BRUSH_NAME.

slotReload

void KisCustomBrushWidget::slotReload ( )

privateslot

Definition at line 259 of file kis_custom_brush_widget.cpp.

{
    m_dev = nullptr;
    m_devices.clear();
    loadImage();
}

References KisSharedPtr< T >::clear(), loadImage(), m_dev, and m_devices.

slotSourceChanged

void KisCustomBrushWidget::slotSourceChanged ( int source )

privateslot

Definition at line 181 of file kis_custom_brush_widget.cpp.

{
    bool useClipboard = source == Source::Clipboard;
    if (m_useClipboard == useClipboard) { return; }
 
    m_useClipboard = useClipboard;
 
    swapBrushWidget();
 
    if (m_useClipboard) {
        // Clipboard doesn't support animated.
        KisPropertiesConfigurationSP cfg = currentBrushWidget()->configuration();
        cfg->setProperty(KEY_BRUSH_STYLE, BrushStyle::Regular);
        currentBrushWidget()->setConfiguration(cfg);
    }
 
    slotReload();
}

References Clipboard, KisConfigWidget::configuration(), currentBrushWidget(), KEY_BRUSH_STYLE, m_useClipboard, Regular, KisConfigWidget::setConfiguration(), slotReload(), source(), and swapBrushWidget().

slotUpdateBrush

void KisCustomBrushWidget::slotUpdateBrush ( )

privateslot

Definition at line 200 of file kis_custom_brush_widget.cpp.

{
    int brushStyle = currentBrushStyle();
    if (brushStyle != m_oldConfig->getInt(KEY_BRUSH_STYLE)) {
        loadImage();
    }
    updatePreviewImage(false);
 
    slotUpdateSaveButton();
 
    m_oldConfig = currentBrushWidget()->configuration();
}

References KisConfigWidget::configuration(), currentBrushStyle(), currentBrushWidget(), KEY_BRUSH_STYLE, loadImage(), m_oldConfig, slotUpdateSaveButton(), and updatePreviewImage().

slotUpdateSaveButton

void KisCustomBrushWidget::slotUpdateSaveButton ( )

privateslot

Definition at line 266 of file kis_custom_brush_widget.cpp.

{
    if (!m_rServer) { return; }
 
    const QString name = currentBrushWidget()->configuration()->getString(KEY_NAME);
    int brushStyle = currentBrushStyle();
    bool needsUpdate = (name != m_oldConfig->getString(KEY_NAME) || brushStyle != m_oldConfig->getInt(KEY_BRUSH_STYLE));
    if (!needsUpdate) { return; }
 
    const QString suffix = brushStyle == BrushStyle::Regular ? ".gbr" : ".gih";
    QString exportFilename = m_rServer->saveLocation() + "/" + name.split(" ").join("_") + suffix;
    if (QFileInfo(exportFilename).exists()) {
        m_buttonBox->button(QDialogButtonBox::Save)->setText(i18nc("@action:button", "Overwrite"));
    } else {
        m_buttonBox->button(QDialogButtonBox::Save)->setText(i18nc("@action:button", "Save"));
    }
}

References KisConfigWidget::configuration(), currentBrushStyle(), currentBrushWidget(), KEY_BRUSH_STYLE, KEY_NAME, m_buttonBox, m_oldConfig, m_rServer, Regular, and KoResourceServer< T >::saveLocation().

swapBrushWidget()

void KisCustomBrushWidget::swapBrushWidget ( )

private

Definition at line 148 of file kis_custom_brush_widget.cpp.

{
    currentBrushWidget()->setConfiguration(otherBrushWidget()->configuration());
    layout()->replaceWidget(otherBrushWidget(), currentBrushWidget());
    otherBrushWidget()->hide();
    currentBrushWidget()->show();
}

References currentBrushWidget(), otherBrushWidget(), and KisConfigWidget::setConfiguration().

updatePreviewImage()

void KisCustomBrushWidget::updatePreviewImage ( bool updateDev )

private

Definition at line 213 of file kis_custom_brush_widget.cpp.

{
    int brushStyle = currentBrushStyle();
    bool useColorMask = currentBrushWidget()->configuration()->getBool(KEY_MASK);
    bool preserveAlpha = currentBrushWidget()->configuration()->getBool(KEY_PRESERVE_ALPHA);
    bool needsUpdate = updateDev || (brushStyle != m_oldConfig->getInt(KEY_BRUSH_STYLE)) ||
        (useColorMask != m_oldConfig->getInt(KEY_MASK)) || (preserveAlpha != m_oldConfig->getInt(KEY_PRESERVE_ALPHA));
    if (!needsUpdate) {
        return;
    }
 
    // Create a temporary brush to generate a preview image
    KisPaintDeviceSP dev;
    QRect rc;
    if (currentBrushStyle() == BrushStyle::Regular) {
        dev = m_dev;
        rc = m_devRect;
    } else {
        if (!m_devices.isEmpty() && !m_devices[0].isEmpty()) {
            dev = m_devices[0][0];
            rc = QRect(QPoint(0,0), m_imageSize);
        }
    }
 
    QImage brushImage;
    if (dev) {
        KisBrushSP brush = KisBrushSP(new KisGbrBrush(dev, rc.x(), rc.y(), rc.width(), rc.height()));
 
        if (useColorMask) {
            static_cast<KisGbrBrush*>(brush.data())->makeMaskImage(preserveAlpha);
            static_cast<KisGbrBrush*>(brush.data())->setBrushApplication(preserveAlpha ? LIGHTNESSMAP : ALPHAMASK);
        } else {
            static_cast<KisGbrBrush*>(brush.data())->setBrushApplication(IMAGESTAMP);
        }
        brushImage = brush->brushTipImage();
    }
 
    if (brushImage.isNull()) {
        m_preview->setText(i18nc("@info empty image", "Empty"));
    } else {
        int w = m_preview->size().width() - m_preview->frameWidth() * 2;
        brushImage = brushImage.scaled(w, w, Qt::KeepAspectRatio);
        m_preview->setPixmap(QPixmap::fromImage(brushImage));
    }
}

References ALPHAMASK, KisConfigWidget::configuration(), currentBrushStyle(), currentBrushWidget(), IMAGESTAMP, KEY_BRUSH_STYLE, KEY_MASK, KEY_PRESERVE_ALPHA, LIGHTNESSMAP, m_dev, m_devices, m_devRect, m_imageSize, m_oldConfig, m_preview, and Regular.

Member Data Documentation

m_animBrushWidget

KisConfigWidget* KisCustomBrushWidget::m_animBrushWidget {nullptr}

private

Definition at line 77 of file kis_custom_brush_widget.h.

{nullptr};

m_brushWidget

KisConfigWidget* KisCustomBrushWidget::m_brushWidget {nullptr}

private

Definition at line 76 of file kis_custom_brush_widget.h.

{nullptr};

m_buttonBox

QDialogButtonBox* KisCustomBrushWidget::m_buttonBox {nullptr}

private

Definition at line 78 of file kis_custom_brush_widget.h.

{nullptr};

m_dev

KisPaintDeviceSP KisCustomBrushWidget::m_dev {nullptr}

private

Definition at line 80 of file kis_custom_brush_widget.h.

{nullptr};

m_devices

QVector<QVector<KisPaintDevice*> > KisCustomBrushWidget::m_devices

private

Definition at line 82 of file kis_custom_brush_widget.h.

m_devRect

QRect KisCustomBrushWidget::m_devRect

private

Definition at line 81 of file kis_custom_brush_widget.h.

m_imageColorSpace

const KoColorSpace* KisCustomBrushWidget::m_imageColorSpace

private

Definition at line 84 of file kis_custom_brush_widget.h.

m_imageSize

QSize KisCustomBrushWidget::m_imageSize

private

Definition at line 83 of file kis_custom_brush_widget.h.

m_oldConfig

KisPropertiesConfigurationSP KisCustomBrushWidget::m_oldConfig {nullptr}

private

Definition at line 89 of file kis_custom_brush_widget.h.

{nullptr};

m_preview

QLabel* KisCustomBrushWidget::m_preview {nullptr}

private

Definition at line 75 of file kis_custom_brush_widget.h.

{nullptr};

m_rServer

KoResourceServer<KisBrush>* KisCustomBrushWidget::m_rServer {0}

private

Definition at line 86 of file kis_custom_brush_widget.h.

{0};

m_useClipboard

bool KisCustomBrushWidget::m_useClipboard {false}

private

Definition at line 88 of file kis_custom_brush_widget.h.

{false};

---

The documentation for this class was generated from the following files:

• plugins/paintops/libpaintop/kis_custom_brush_widget.h
• plugins/paintops/libpaintop/kis_custom_brush_widget.cpp