File indexing completed on 2025-03-09 04:10:27

 /*
  *  SPDX-FileCopyrightText: 2017 Eugene Ingerman
  *  SPDX-FileCopyrightText: 2022 L. E. Segovia <amy@amyspark.me>
  *
  *  SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "ToolReferenceImagesWidget.h"
 
 #include "ui_WdgToolOptions.h"
 
 #include <KoSelection.h>
 #include <KoShapeTransparencyCommand.h>
 #include <KoShapeKeepAspectRatioCommand.h>
 #include <kis_config.h>
 #include <kis_signals_blocker.h>
 #include <kis_signal_compressor.h>
 #include <KisReferenceImage.h>
 #include <KisSpinBoxI18nHelper.h>
 #include <kis_clipboard.h>
 
 #include <QApplication>
 #include <QStandardItemModel>
 
 #include "ToolReferenceImages.h"
 
 struct ToolReferenceImagesWidget::Private {
     Private(ToolReferenceImages *tool)
     : tool(tool)
     {
     }
 
     Ui_WdgToolOptions *ui {nullptr};
     ToolReferenceImages *tool {nullptr};
 };
 
 ToolReferenceImagesWidget::ToolReferenceImagesWidget(ToolReferenceImages *tool, KisCanvasResourceProvider */*provider*/, QWidget *parent)
     : QWidget(parent),
       d(new Private(tool))
 {
     d->ui = new Ui_WdgToolOptions();
     d->ui->setupUi(this);
 
     d->ui->opacitySlider->setRange(0, 100);
     d->ui->opacitySlider->setTextTemplates(
         i18nc("{n} is the number value, % is the percent sign", "Opacity: {n}%"),
         i18nc("{n} is the number value, % is the percent sign", "Opacity [*varies*]: {n}%"));
     d->ui->opacitySlider->setValueGetter(
         [](KoShape *s){ return 100.0 * (1.0 - s->transparency()); }
     );
 
     d->ui->saturationSlider->setRange(0, 100);
     d->ui->saturationSlider->setTextTemplates(
         i18nc("{n} is the number value, % is the percent sign", "Saturation: {n}%"),
         i18nc("{n} is the number value, % is the percent sign", "Saturation [*varies*]: {n}%"));
     d->ui->saturationSlider->setValueGetter(
         [](KoShape *s){
             auto *r = dynamic_cast<KisReferenceImage*>(s);
             KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(r, 0.0);
             return 100.0 * r->saturation();
         }
     );
 
     d->ui->bnAddReferenceImage->setToolTip(i18n("Add Reference Image"));
     d->ui->bnAddReferenceImage->setIcon(KisIconUtils::loadIcon("list-add"));
     d->ui->bnAddReferenceImage->setIconSize(QSize(16, 16));
 
 
     d->ui->bnDelete->setToolTip(i18n("Delete all Reference Images"));
     d->ui->bnDelete->setIcon(KisIconUtils::loadIcon("edit-delete"));
     d->ui->bnDelete->setIconSize(QSize(16, 16));
 
     d->ui->bnLoad->setToolTip(i18n("Load Reference Images Set"));
     d->ui->bnLoad->setIcon(KisIconUtils::loadIcon("folder"));
     d->ui->bnLoad->setIconSize(QSize(16, 16));
 
     d->ui->bnSave->setToolTip(i18n("Export Reference Images Set"));
     d->ui->bnSave->setIcon(KisIconUtils::loadIcon("document-save-16"));
     d->ui->bnSave->setIconSize(QSize(16, 16));
 
     d->ui->bnPasteReferenceImage->setToolTip(i18n("Paste Reference Image From System Clipboard"));
     d->ui->bnPasteReferenceImage->setIcon(KisIconUtils::loadIcon("edit-paste-16"));
     d->ui->bnPasteReferenceImage->setIconSize(QSize(16, 16));
     d->ui->bnPasteReferenceImage->setEnabled(KisClipboard::instance()->hasClip() || KisClipboard::instance()->hasUrls());
 
     connect(d->ui->bnAddReferenceImage, SIGNAL(clicked()), tool, SLOT(addReferenceImage()));
     connect(d->ui->bnPasteReferenceImage, SIGNAL(clicked()), tool, SLOT(pasteReferenceImage()));
 
     connect(KisClipboard::instance(), &KisClipboard::clipChanged, this, [&]() {
         d->ui->bnPasteReferenceImage->setEnabled(KisClipboard::instance()->hasClip() || KisClipboard::instance()->hasUrls());
     });
 
     connect(d->ui->bnDelete, SIGNAL(clicked()), tool, SLOT(removeAllReferenceImages()));
     connect(d->ui->bnSave, SIGNAL(clicked()), tool, SLOT(saveReferenceImages()));
     connect(d->ui->bnLoad, SIGNAL(clicked()), tool, SLOT(loadReferenceImages()));
 
     connect(d->ui->chkKeepAspectRatio, SIGNAL(stateChanged(int)), this, SLOT(slotKeepAspectChanged()));
 
     KisSignalCompressor *compressor = new KisSignalCompressor(100 /* ms */, KisSignalCompressor::POSTPONE, this);
     connect(compressor, SIGNAL(timeout()), this, SLOT(slotImageValuesChanged()));
 
     connect(d->ui->saturationSlider, SIGNAL(valueChanged(qreal)), compressor, SLOT(start()));
     connect(d->ui->opacitySlider, SIGNAL(valueChanged(qreal)), compressor, SLOT(start()));
 
     d->ui->referenceImageLocationCombobox->addItem(i18n("Embed to .KRA"));
     d->ui->referenceImageLocationCombobox->addItem(i18n("Link to Image"));
     connect(d->ui->referenceImageLocationCombobox, SIGNAL(currentIndexChanged(int)), this, SLOT(slotSaveLocationChanged(int)));
 
     updateVisibility(false); // no selection when we start
 }
 
 ToolReferenceImagesWidget::~ToolReferenceImagesWidget()
 {
     delete d->ui;
     d->ui = nullptr;
 }
 
 void ToolReferenceImagesWidget::selectionChanged(KoSelection *selection)
 {
     QList<KoShape*> shapes = selection->selectedEditableShapes();
 
     d->ui->opacitySlider->setSelection(shapes);
     d->ui->saturationSlider->setSelection(shapes);
 
     bool anyKeepingAspectRatio = false;
     bool anyNotKeepingAspectRatio = false;
     bool anyEmbedded = false;
     bool anyLinked = false;
     // bool anyNonLinkable = false;
     bool anySelected = selection->count() > 0;
 
     Q_FOREACH(KoShape *shape, shapes) {
         KisReferenceImage *reference = dynamic_cast<KisReferenceImage*>(shape);
 
         anyKeepingAspectRatio |= shape->keepAspectRatio();
         anyNotKeepingAspectRatio |= !shape->keepAspectRatio();
 
         if (reference) {
             anyEmbedded |= reference->embed();
             anyLinked |= !reference->embed();
             // anyNonLinkable |= !reference->hasLocalFile();
         }
     }
 
     KisSignalsBlocker blocker(
         d->ui->chkKeepAspectRatio,
         d->ui->referenceImageLocationCombobox
     );
 
     d->ui->chkKeepAspectRatio->setCheckState(
         (anyKeepingAspectRatio && anyNotKeepingAspectRatio) ? Qt::PartiallyChecked :
          anyKeepingAspectRatio ? Qt::Checked : Qt::Unchecked);
 
 
     // set save location combobox
     bool imagesEmbedded = anyEmbedded && !anyLinked;
     int comboBoxIndex = imagesEmbedded ? 0 : 1; // maps state to combobox index
     d->ui->referenceImageLocationCombobox->setCurrentIndex(comboBoxIndex);
 
 
     updateVisibility(anySelected);
 }
 
 void ToolReferenceImagesWidget::slotKeepAspectChanged()
 {
     KoSelection *selection = d->tool->koSelection();
     QList<KoShape*> shapes = selection->selectedEditableShapes();
 
     KUndo2Command *cmd =
             new KoShapeKeepAspectRatioCommand(shapes, d->ui->chkKeepAspectRatio->isChecked());
 
     d->tool->canvas()->addCommand(cmd);
 }
 
 void ToolReferenceImagesWidget::slotOpacitySliderChanged(qreal newOpacity)
 {
     QList<KoShape*> shapes = d->ui->opacitySlider->selection();
     if (shapes.isEmpty()) return;
 
     KUndo2Command *cmd =
         new KoShapeTransparencyCommand(shapes, 1.0 - newOpacity / 100.0);
 
     d->tool->canvas()->addCommand(cmd);
 }
 
 void ToolReferenceImagesWidget::slotSaturationSliderChanged(qreal newSaturation)
 {
     QList<KoShape*> shapes = d->ui->saturationSlider->selection();
     if (shapes.isEmpty()) return;
 
     KUndo2Command *cmd =
             new KisReferenceImage::SetSaturationCommand(shapes, newSaturation / 100.0);
 
     d->tool->canvas()->addCommand(cmd);
 }
 
 void ToolReferenceImagesWidget::slotSaveLocationChanged(int index)
 {
     KoSelection *selection = d->tool->koSelection();
     QList<KoShape*> shapes = selection->selectedEditableShapes();
 
 
     Q_FOREACH(KoShape *shape, shapes) {
         KisReferenceImage *reference = dynamic_cast<KisReferenceImage*>(shape);
         KIS_SAFE_ASSERT_RECOVER_RETURN(reference);
 
         if (index == 0) { // embed to KRA
             reference->setEmbed(true);
         } else { // link to file
             if (reference->hasLocalFile()) {
                 reference->setEmbed(false);
             } else {
                 //In the case no local file is found, switch back to embed file data.
                 d->ui->referenceImageLocationCombobox->setCurrentIndex(0);
             }
         }
     }
 }
 
 void ToolReferenceImagesWidget::slotImageValuesChanged()
 {
     slotSaturationSliderChanged(d->ui->saturationSlider->value());
     slotOpacitySliderChanged(d->ui->opacitySlider->value());
 }
 
 void ToolReferenceImagesWidget::updateVisibility(bool hasSelection)
 {
     // hide UI elements if nothing is selected.
     d->ui->referenceImageLocationCombobox->setVisible(hasSelection);
     d->ui->chkKeepAspectRatio->setVisible(hasSelection);
     d->ui->saveLocationLabel->setVisible(hasSelection);
     d->ui->opacitySlider->setVisible(hasSelection);
     d->ui->saturationSlider->setVisible(hasSelection);
 
     // show a label indicating that a selection is required to show options
     d->ui->referenceImageOptionsLabel->setVisible(!hasSelection);
 
     if (hasSelection) {
         KoSelection* selection = d->tool->koSelection();
         QList<KoShape*> shapes = selection->selectedEditableShapes();
         bool usesLocalFile = true;
 
         Q_FOREACH(KoShape *shape, shapes) {
             KisReferenceImage *reference = dynamic_cast<KisReferenceImage*>(shape);
 
             if (reference) {
                 usesLocalFile &= reference->hasLocalFile();
             }
         }
 
         QStandardItemModel* model = dynamic_cast<QStandardItemModel*>(d->ui->referenceImageLocationCombobox->model());
 
         if (model) {
             QStandardItem* item = model->item(1);
             item->setFlags(usesLocalFile ? item->flags() | Qt::ItemIsEnabled :
                                            item->flags() & ~Qt::ItemIsEnabled);
         }
     }
 }