#include "cleanupsettingspopup.h"
// Tnz6 includes
#include "tapp.h"
#include "mainwindow.h"
#include "cleanupsettingsmodel.h"
#include "cleanuppaletteviewer.h"
#include "cleanupswatch.h"
#include "menubarcommandids.h"
#include "pane.h"
#include "floatingpanelcommand.h"
// TnzQt includes
#include "toonzqt/gutil.h"
#include "toonzqt/tabbar.h"
#include "toonzqt/checkbox.h"
#include "toonzqt/doublefield.h"
#include "toonzqt/filefield.h"
#include "toonzqt/cleanupcamerasettingswidget.h"
// TnzLib includes
#include "toonz/toonzfolders.h"
#include "toonz/palettecontroller.h"
#include "toonz/tpalettehandle.h"
#include "toonz/tscenehandle.h"
#include "toonz/txsheethandle.h"
#include "toonz/txshlevelhandle.h"
#include "toonz/tframehandle.h"
#include "toonz/tcolumnhandle.h"
#include "toonz/toonzscene.h"
#include "toonz/sceneproperties.h"
#include "toonz/txshsimplelevel.h"
// Qt includes
#include <QSplitter>
#include <QStackedWidget>
#include <QScrollArea>
#include <QComboBox>
#include <QAction>
#include <QLabel>
//**********************************************************************
// Cleanup Tab implementation
//**********************************************************************
CleanupTab::CleanupTab()
{
QVBoxLayout *mainLayout = new QVBoxLayout(this);
setLayout(mainLayout);
mainLayout->setSizeConstraint(QLayout::SetMinimumSize);
mainLayout->setSpacing(0);
mainLayout->setMargin(0);
QWidget *settingsBox = new QWidget(this);
mainLayout->addWidget(settingsBox);
mainLayout->addStretch(); //This is the reason we need mainLayout
QGridLayout *settingsLayout = new QGridLayout(settingsBox);
settingsBox->setLayout(settingsLayout);
settingsLayout->setSizeConstraint(QLayout::SetMaximumSize);
settingsLayout->setSpacing(9);
settingsLayout->setMargin(12);
int row = 0;
// AutoCenter
m_autoCenter = new CheckBox(tr("Autocenter"), this);
settingsLayout->addWidget(m_autoCenter, row++, 1, Qt::AlignLeft);
m_autoCenter->setFixedSize(150, WidgetHeight);
// Pegbar Holes
settingsLayout->addWidget(new QLabel(tr("Pegbar Holes:")), row, 0, Qt::AlignRight);
m_pegHolesOm = new QComboBox(this);
settingsLayout->addWidget(m_pegHolesOm, row++, 1, Qt::AlignLeft);
m_pegHolesOm->setFixedHeight(WidgetHeight);
m_pegHolesOm->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Maximum);
QStringList pegbarHoles;
pegbarHoles << "Bottom"
<< "Top"
<< "Left"
<< "Right";
m_pegHolesOm->addItems(pegbarHoles);
// Field Guide
settingsLayout->addWidget(new QLabel(tr("Field Guide:")), row, 0, Qt::AlignRight);
m_fieldGuideOm = new QComboBox(this);
settingsLayout->addWidget(m_fieldGuideOm, row++, 1, Qt::AlignLeft);
m_fieldGuideOm->setFixedHeight(WidgetHeight);
m_fieldGuideOm->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Maximum);
std::vector<string> fdgNames;
CleanupParameters::getFdgNames(fdgNames);
for (int i = 0; i < (int)fdgNames.size(); i++)
m_fieldGuideOm->addItem(QString(fdgNames[i].c_str()));
settingsLayout->addWidget(new Separator(), row++, 0, 1, 2);
// Rotate
settingsLayout->addWidget(new QLabel(tr("Rotate:")), row, 0, Qt::AlignRight);
m_rotateOm = new QComboBox(this);
settingsLayout->addWidget(m_rotateOm, row++, 1, Qt::AlignLeft);
m_rotateOm->setFixedHeight(WidgetHeight);
m_rotateOm->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Maximum);
QStringList rotate;
rotate << "0"
<< "90"
<< "180"
<< "270";
m_rotateOm->addItems(rotate);
// Flip
settingsLayout->addWidget(new QLabel(tr("Flip:")), row, 0, Qt::AlignRight);
QWidget *flipWidget = new QWidget();
settingsLayout->addWidget(flipWidget, row++, 1, Qt::AlignLeft);
QHBoxLayout *flipLayout = new QHBoxLayout();
flipWidget->setLayout(flipLayout);
flipLayout->setSizeConstraint(QLayout::SetFixedSize);
flipLayout->setMargin(0);
m_flipX = new CheckBox(tr("Horizontal"), flipWidget);
flipLayout->addWidget(m_flipX, 0, Qt::AlignLeft);
m_flipX->setFixedHeight(WidgetHeight);
m_flipY = new CheckBox(tr("Vertical"), flipWidget);
flipLayout->addWidget(m_flipY, 0, Qt::AlignLeft);
m_flipY->setFixedHeight(WidgetHeight);
flipLayout->addStretch(1);
// Save In
settingsLayout->addWidget(new QLabel(tr("Save in:")), row, 0, Qt::AlignRight);
m_pathField = new FileField(this, QString(""));
settingsLayout->addWidget(m_pathField, row++, 1);
m_pathField->setFixedHeight(WidgetHeight);
// Connections
bool ret = true;
ret = ret && connect(m_autoCenter, SIGNAL(stateChanged(int)), SLOT(onGenericSettingsChange()));
ret = ret && connect(m_pegHolesOm, SIGNAL(activated(int)), SLOT(onGenericSettingsChange()));
ret = ret && connect(m_fieldGuideOm, SIGNAL(activated(int)), SLOT(onGenericSettingsChange()));
ret = ret && connect(m_rotateOm, SIGNAL(activated(int)), SLOT(onGenericSettingsChange()));
ret = ret && connect(m_flipX, SIGNAL(stateChanged(int)), SLOT(onGenericSettingsChange()));
ret = ret && connect(m_flipY, SIGNAL(stateChanged(int)), SLOT(onGenericSettingsChange()));
ret = ret && connect(m_pathField, SIGNAL(pathChanged()), SLOT(onPathChange()));
assert(ret);
}
//-----------------------------------------------------------------------------
QString CleanupTab::pathString(const TFilePath &path, bool lpNone)
{
return path.isEmpty() ? lpNone ? QString("+extras") : QString("+drawings") : toQString(path);
}
//-----------------------------------------------------------------------------
void CleanupTab::updateGui(CleanupParameters *params, CleanupParameters *oldParams)
{
m_autoCenter->setChecked(params->m_autocenterType == CleanupTypes::AUTOCENTER_FDG);
m_pegHolesOm->setCurrentIndex(params->m_pegSide - 1);
QString fieldName = QString::fromStdString(params->getFdgName());
int index = (fieldName.isEmpty()) ? 0 : m_fieldGuideOm->findText(fieldName);
assert(index != -1);
m_fieldGuideOm->setCurrentIndex(index);
m_rotateOm->setCurrentIndex(params->m_rotate / 90);
m_flipX->setChecked(params->m_flipx);
m_flipY->setChecked(params->m_flipy);
m_path = params->m_path;
m_pathField->setPath(pathString(m_path, params->m_lineProcessingMode == lpNone));
}
//-----------------------------------------------------------------------------
void CleanupTab::onGenericSettingsChange()
{
CleanupSettingsModel *model = CleanupSettingsModel::instance();
CleanupParameters *params = model->getCurrentParameters();
params->m_autocenterType = m_autoCenter->isChecked() ? CleanupTypes::AUTOCENTER_FDG : CleanupTypes::AUTOCENTER_NONE;
params->m_pegSide = (CleanupTypes::PEGS_SIDE)(m_pegHolesOm->currentIndex() + 1);
params->setFdgByName(m_fieldGuideOm->currentText().toStdString());
params->m_rotate = m_rotateOm->currentIndex() * 90;
params->m_flipx = m_flipX->isChecked();
params->m_flipy = m_flipY->isChecked();
model->commitChanges();
}
//-----------------------------------------------------------------------------
void CleanupTab::onPathChange()
{
CleanupSettingsModel *model = CleanupSettingsModel::instance();
CleanupParameters *params = model->getCurrentParameters();
m_path = params->m_path = TFilePath(m_pathField->getPath().toStdWString());
model->commitChanges();
}
//**********************************************************************
// Processing Tab implementation
//**********************************************************************
ProcessingTab::ProcessingTab()
{
QVBoxLayout *mainLayout = new QVBoxLayout();
setLayout(mainLayout);
mainLayout->setSizeConstraint(QLayout::SetMinimumSize);
mainLayout->addSpacing(6);
m_settingsFrame = new QWidget(this);
mainLayout->addWidget(m_settingsFrame);
//----------------- Parameters Layout -----------------------
QGridLayout *settingsLayout = new QGridLayout(m_settingsFrame);
m_settingsFrame->setLayout(settingsLayout);
settingsLayout->setSpacing(9);
settingsLayout->setMargin(6);
settingsLayout->setSizeConstraint(QLayout::SetMinimumSize);
settingsLayout->setColumnStretch(1, 1); // needed when lpNone
//-------------------- Parameters ---------------------------
int row = 0;
// Line processing
settingsLayout->addWidget(new QLabel(tr("Line Processing:")), row, 0, Qt::AlignRight);
m_lineProcessing = new QComboBox(this);
m_lineProcessing->setFixedHeight(WidgetHeight);
m_lineProcessing->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Maximum);
QStringList items;
items << tr("None") << tr("Greyscale") << tr("Color");
m_lineProcessing->addItems(items);
settingsLayout->addWidget(m_lineProcessing, row++, 1, Qt::AlignLeft);
// Antialias
m_antialiasLabel = new QLabel(tr("Antialias:"));
settingsLayout->addWidget(m_antialiasLabel, row, 0, Qt::AlignRight);
m_antialias = new QComboBox(this);
m_antialias->setFixedHeight(WidgetHeight);
m_antialias->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Maximum);
items.clear();
items << tr("Standard") << tr("None") << tr("Morphological");
m_antialias->addItems(items);
settingsLayout->addWidget(m_antialias, row++, 1, Qt::AlignLeft);
// Autoadjust
m_autoadjustLabel = new QLabel(tr("Autoadjust:"));
settingsLayout->addWidget(m_autoadjustLabel, row, 0, Qt::AlignRight);
m_autoadjustOm = new QComboBox(this);
m_autoadjustOm->setFixedHeight(WidgetHeight);
m_autoadjustOm->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Maximum);
items.clear();
items << "None"
<< "Black-Eq"
<< "Histo"
<< "Histo-L";
m_autoadjustOm->addItems(items);
settingsLayout->addWidget(m_autoadjustOm, row++, 1, Qt::AlignLeft);
// Sharpness
m_sharpLabel = new QLabel(tr("Sharpness:"));
settingsLayout->addWidget(m_sharpLabel, row, 0, Qt::AlignRight);
m_sharpness = new DoubleField(this);
m_sharpness->setFixedHeight(WidgetHeight);
m_sharpness->setValues(90, 0, 100);
settingsLayout->addWidget(m_sharpness, row++, 1);
// Despeckling
m_despeckLabel = new QLabel(tr("Despeckling:"));
settingsLayout->addWidget(m_despeckLabel, row, 0, Qt::AlignRight);
m_despeckling = new IntField(this);
m_despeckling->setFixedHeight(WidgetHeight);
m_despeckling->setValues(2, 0, 20);
settingsLayout->addWidget(m_despeckling, row++, 1);
// MLAA Value
m_aaValueLabel = new QLabel(tr("MLAA Intensity:"));
settingsLayout->addWidget(m_aaValueLabel, row, 0, Qt::AlignRight);
m_aaValue = new IntField(this);
m_aaValue->setFixedHeight(WidgetHeight);
m_aaValue->setValues(70, 0, 100);
settingsLayout->addWidget(m_aaValue, row++, 1);
//---------------------- Palette ----------------------------
m_paletteSep = new Separator();
mainLayout->addWidget(m_paletteSep);
m_paletteViewer = new CleanupPaletteViewer(this);
mainLayout->addWidget(m_paletteViewer, 1); // The palette viewer dominates on the stretch below
mainLayout->addStretch(); // Lp: none sticks to the upper edge
//-------------------- Connections --------------------------
bool ret = true;
ret = ret && connect(m_sharpness, SIGNAL(valueChanged(bool)), SLOT(onSharpnessChange(bool)));
ret = ret && connect(m_lineProcessing, SIGNAL(activated(int)), SLOT(onGenericSettingsChange()));
ret = ret && connect(m_antialias, SIGNAL(activated(int)), SLOT(onGenericSettingsChange()));
ret = ret && connect(m_autoadjustOm, SIGNAL(activated(int)), SLOT(onGenericSettingsChange()));
ret = ret && connect(m_despeckling, SIGNAL(valueChanged(bool)), SLOT(onGenericSettingsChange()));
ret = ret && connect(m_aaValue, SIGNAL(valueChanged(bool)), SLOT(onGenericSettingsChange()));
assert(ret);
}
//-----------------------------------------------------------------------------
void ProcessingTab::updateGui(CleanupParameters *params, CleanupParameters *oldParams)
{
m_lineProcessing->setCurrentIndex(params->m_lineProcessingMode);
m_antialias->setCurrentIndex(params->m_postAntialias ? 2 : params->m_noAntialias ? 1 : 0);
m_autoadjustOm->setCurrentIndex((int)params->m_autoAdjustMode);
m_sharpness->setValue(params->m_sharpness);
m_despeckling->setValue(params->m_despeckling);
m_aaValue->setValue(params->m_aaValue);
updateVisibility();
}
//------------------------------------------------------------------------------
void ProcessingTab::updateVisibility()
{
bool lp = (m_lineProcessing->currentIndex() != 0);
bool lpGrey = (m_lineProcessing->currentIndex() == 1);
bool MLAA = lp && (m_antialias->currentIndex() == 2);
m_antialiasLabel->setVisible(lp);
m_antialias->setVisible(lp);
m_autoadjustLabel->setVisible(lpGrey);
m_autoadjustOm->setVisible(lpGrey);
m_sharpLabel->setVisible(lp);
m_sharpness->setVisible(lp);
m_despeckLabel->setVisible(lp);
m_despeckling->setVisible(lp);
m_aaValueLabel->setVisible(MLAA);
m_aaValue->setVisible(MLAA);
m_paletteViewer->setMode(lpGrey);
m_paletteViewer->setContrastEnabled(m_antialias->currentIndex() == 0);
if (!lp && !m_paletteViewer->isHidden()) {
m_paletteViewer->setVisible(false);
m_paletteSep->setVisible(false);
} else if (lp && m_paletteViewer->isHidden()) {
m_paletteViewer->setVisible(true);
m_paletteSep->setVisible(false);
}
}
//-----------------------------------------------------------------------------
void ProcessingTab::onGenericSettingsChange()
{
CleanupSettingsModel *model = CleanupSettingsModel::instance();
CleanupParameters *params = model->getCurrentParameters();
params->m_lineProcessingMode = m_lineProcessing->currentIndex();
params->m_noAntialias = (m_antialias->currentIndex() > 0);
params->m_postAntialias = (m_antialias->currentIndex() == 2);
params->m_despeckling = m_despeckling->getValue();
params->m_aaValue = m_aaValue->getValue();
params->m_autoAdjustMode = (CleanupTypes::AUTO_ADJ_MODE)m_autoadjustOm->currentIndex();
if (params->m_lineProcessingMode == lpNone)
params->m_transparencyCheckEnabled = false;
model->commitChanges();
}
//-----------------------------------------------------------------------------
void ProcessingTab::onSharpnessChange(bool dragging = false)
{
if (dragging)
return;
CleanupSettingsModel *model = CleanupSettingsModel::instance();
model->getCurrentParameters()->m_sharpness = m_sharpness->getValue();
model->commitChanges();
}
//**********************************************************************
// CameraTab implementation
//**********************************************************************
CameraTab::CameraTab()
{
bool ret = true;
ret = ret && connect(TApp::instance()->getCurrentLevel(),
SIGNAL(xshLevelSwitched(TXshLevel *)), SLOT(onLevelSwitched()));
ret = ret && connect(this, SIGNAL(cleanupSettingsChanged()), SLOT(onGenericSettingsChange()));
assert(ret);
}
//-----------------------------------------------------------------------------
void CameraTab::updateGui(CleanupParameters *params, CleanupParameters *oldParams)
{
blockSignals(true);
setFields(params);
blockSignals(false);
if (params->m_lineProcessingMode != oldParams->m_lineProcessingMode ||
params->m_camera.getRes() != oldParams->m_camera.getRes() ||
params->m_camera.getSize() != oldParams->m_camera.getSize() ||
params->m_closestField != oldParams->m_closestField) {
updateImageInfo();
}
}
//-------------------------------------------------------
void CameraTab::updateImageInfo()
{
CleanupSettingsModel *model = CleanupSettingsModel::instance();
CleanupParameters *params = model->getCurrentParameters();
TDimension outRes(0, 0);
TPointD outDpi;
params->getOutputImageInfo(outRes, outDpi.x, outDpi.y);
setImageInfo(outRes.lx, outRes.ly, outDpi.x, outDpi.y);
TXshSimpleLevel *sl;
TFrameId fid;
model->getCleanupFrame(sl, fid);
ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();
TFilePath outputPath(sl ? scene->decodeFilePath(model->getOutputPath(sl, params)) : TFilePath());
setImageInfo(outputPath);
}
//-----------------------------------------------------------------------------
void CameraTab::onLevelSwitched()
{
setCurrentLevel(TApp::instance()->getCurrentLevel()->getLevel());
}
//------------------------------------------------------------------------------
void CameraTab::onGenericSettingsChange()
{
CleanupSettingsModel *model = CleanupSettingsModel::instance();
getFields(model->getCurrentParameters());
model->commitChanges();
}
//**********************************************************************
// CleanupSettings implementation
//**********************************************************************
CleanupSettings::CleanupSettings(QWidget *parent)
: QWidget(parent), m_attached(false)
{
QVBoxLayout *vLayout = new QVBoxLayout(this);
vLayout->setMargin(1); // NOTE: This works to show the 1-pix black border,
// because this is a QWidget (not QFrame) heir...
setLayout(vLayout);
// Tabs Container
// Used to deal with styled background and other stuff
TabBarContainter *tabBarContainer = new TabBarContainter(this);
QHBoxLayout *hLayout = new QHBoxLayout(tabBarContainer);
hLayout->setMargin(0);
hLayout->setAlignment(Qt::AlignLeft);
hLayout->addSpacing(6);
vLayout->addWidget(tabBarContainer);
// Tabs Bar
DVGui::TabBar *tabBar = new DVGui::TabBar(this);
hLayout->addWidget(tabBar);
tabBar->addSimpleTab(tr("Cleanup"));
tabBar->addSimpleTab(tr("Processing"));
tabBar->addSimpleTab(tr("Camera"));
tabBar->setDrawBase(false);
// Splitter
QSplitter *split = new QSplitter(Qt::Vertical, this);
split->setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding));
vLayout->addWidget(split);
// Stacked Widget
QStackedWidget *stackedWidget = new QStackedWidget(split);
stackedWidget->setMinimumWidth(300);
//stackedWidget->setMinimumHeight(250);
split->addWidget(stackedWidget);
split->setStretchFactor(0, 1);
// Cleanup Tab
QScrollArea *scrollArea = new QScrollArea(stackedWidget);
stackedWidget->addWidget(scrollArea);
scrollArea->setWidgetResizable(true);
scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_cleanupTab = new CleanupTab;
scrollArea->setWidget(m_cleanupTab);
// Processing Tab
scrollArea = new QScrollArea(stackedWidget);
stackedWidget->addWidget(scrollArea);
scrollArea->setWidgetResizable(true);
scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_processingTab = new ProcessingTab;
scrollArea->setWidget(m_processingTab);
// Camera Tab
scrollArea = new QScrollArea(stackedWidget);
stackedWidget->addWidget(scrollArea);
scrollArea->setWidgetResizable(true);
scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_cameraTab = new CameraTab;
scrollArea->setWidget(m_cameraTab);
m_cameraTab->setCameraPresetListFile(ToonzFolder::getReslistPath(true));
// Swatch
m_swatch = new CleanupSwatch(split, 200, 150);
split->addWidget(m_swatch);
// ToolBar
QWidget *toolBarWidget = new QWidget(this);
vLayout->addWidget(toolBarWidget);
toolBarWidget->setFixedHeight(22);
QHBoxLayout *toolBarLayout = new QHBoxLayout(toolBarWidget);
toolBarWidget->setLayout(toolBarLayout);
toolBarLayout->setMargin(0);
toolBarLayout->setSpacing(0);
QToolBar *leftToolBar = new QToolBar(toolBarWidget);
toolBarLayout->addWidget(leftToolBar, 0, Qt::AlignLeft);
leftToolBar->setFixedWidth(110);
m_swatchAct = new QAction(createQIconOnOffPNG("preview", true), tr("Toggle Swatch Preview"), this);
m_swatchAct->setCheckable(true);
leftToolBar->addAction(m_swatchAct);
leftToolBar->addSeparator();
m_opacityAct = new QAction(createQIconOnOffPNG("opacitycheck", true), tr("Toggle Opacity Check"), this);
m_opacityAct->setCheckable(true);
leftToolBar->addAction(m_opacityAct);
QToolBar *spacingToolBar1 = new QToolBar(toolBarWidget);
toolBarLayout->addWidget(spacingToolBar1, 1);
spacingToolBar1->setMinimumHeight(22);
QToolBar *rightToolBar = new QToolBar(toolBarWidget);
toolBarLayout->addWidget(rightToolBar, 0, Qt::AlignRight);
rightToolBar->setFixedWidth(110);
QAction *saveAct = new QAction(createQIconOnOffPNG("save", false), tr("Save Settings"), this);
rightToolBar->addAction(saveAct);
QAction *loadAct = new QAction(createQIconOnOffPNG("load", false), tr("Load Settings"), this);
rightToolBar->addAction(loadAct);
rightToolBar->addSeparator();
QAction *resetAct = new QAction(createQIconOnOffPNG("resetsize", false), tr("Reset Settings"), this);
rightToolBar->addAction(resetAct);
// Model-related stuff
CleanupSettingsModel *model = CleanupSettingsModel::instance();
m_backupParams.assign(model->getCurrentParameters(), false);
// Connections
QAction *opacityCheckCmd = CommandManager::instance()->getAction(MI_OpacityCheck);
assert(opacityCheckCmd);
bool ret = true;
ret = ret && connect(tabBar, SIGNAL(currentChanged(int)), stackedWidget, SLOT(setCurrentIndex(int)));
ret = ret && connect(m_swatchAct, SIGNAL(toggled(bool)), SLOT(enableSwatch(bool)));
ret = ret && connect(m_opacityAct, SIGNAL(triggered(bool)), opacityCheckCmd, SLOT(trigger()));
ret = ret && connect(saveAct, SIGNAL(triggered()), model, SLOT(promptSave()));
ret = ret && connect(loadAct, SIGNAL(triggered()), model, SLOT(promptLoad()));
ret = ret && connect(resetAct, SIGNAL(triggered()), this, SLOT(onRestoreSceneSettings()));
assert(ret);
}
//-----------------------------------------------------------------------------
void CleanupSettings::showEvent(QShowEvent *se)
{
QWidget::showEvent(se);
if (!m_attached) {
m_attached = true;
//Should ensure that swatch is off...
CleanupSettingsModel *model = CleanupSettingsModel::instance();
model->attach(CleanupSettingsModel::LISTENER);
bool ret = true;
ret = ret && connect(model, SIGNAL(imageSwitched()), this, SLOT(onImageSwitched()));
ret = ret && connect(model, SIGNAL(modelChanged(bool)), this, SLOT(updateGui(bool)));
ret = ret && connect(model, SIGNAL(clnLoaded()), this, SLOT(onClnLoaded()));
assert(ret);
m_cameraTab->setCurrentLevel(TApp::instance()->getCurrentLevel()->getLevel());
updateGui(false);
onImageSwitched();
onClnLoaded();
if (m_swatchAct->isChecked())
enableSwatch(true); //attach swatch
}
}
//-----------------------------------------------------------------------------
void CleanupSettings::hideEvent(QHideEvent *he)
{
// Surprisingly enough, it seems that Qt may trigger hideEvents for widgets that
// have never been shown - this is why we need to check a user-made bool to know whether
// model attachment has happened... and no, detaching without attaching is *BAD*
if (m_attached) {
m_attached = false;
//Should put swatch to off...
CleanupSettingsModel *model = CleanupSettingsModel::instance();
model->detach(CleanupSettingsModel::LISTENER);
bool ret = true;
ret = ret && disconnect(model, SIGNAL(imageSwitched()), this, SLOT(onImageSwitched()));
ret = ret && disconnect(model, SIGNAL(modelChanged(bool)), this, SLOT(updateGui(bool)));
ret = ret && disconnect(model, SIGNAL(clnLoaded()), this, SLOT(onClnLoaded()));
assert(ret);
if (m_swatchAct->isChecked())
enableSwatch(false); //detach swatch
}
QWidget::hideEvent(he);
}
//-----------------------------------------------------------------------------
void CleanupSettings::updateGui(bool needsPostProcess)
{
CleanupParameters *params = CleanupSettingsModel::instance()->getCurrentParameters();
m_cleanupTab->updateGui(params, &m_backupParams);
m_processingTab->updateGui(params, &m_backupParams);
m_cameraTab->updateGui(params, &m_backupParams);
m_backupParams.assign(params, false);
m_opacityAct->setChecked(params->m_transparencyCheckEnabled);
if (params->m_lineProcessingMode == lpNone) {
m_swatch->setRaster(TRasterP(), TAffine(), TRasterP());
m_swatchAct->setChecked(false);
} else if (needsPostProcess)
postProcess();
}
//-----------------------------------------------------------------------------
void CleanupSettings::enableSwatch(bool enable)
{
CleanupSettingsModel *model = CleanupSettingsModel::instance();
if (enable) {
model->attach(CleanupSettingsModel::PREVIEWER);
connect(model, SIGNAL(previewDataChanged()), this, SLOT(onPreviewDataChanged()));
onPreviewDataChanged();
} else {
model->detach(CleanupSettingsModel::PREVIEWER);
disconnect(model, SIGNAL(previewDataChanged()), this, SLOT(onPreviewDataChanged()));
m_swatch->setRaster(TRasterP(), TAffine(), TRasterP());
}
}
//-----------------------------------------------------------------------------
void CleanupSettings::enableOpacityCheck(bool enable)
{
CleanupSettingsModel *model = CleanupSettingsModel::instance();
CleanupParameters *params = model->getCurrentParameters();
params->m_transparencyCheckEnabled = enable;
model->commitChanges();
}
//-----------------------------------------------------------------------------
void CleanupSettings::onImageSwitched()
{
m_cameraTab->updateImageInfo();
}
//-----------------------------------------------------------------------------
void CleanupSettings::onPreviewDataChanged()
{
TRasterImageP original, transformed;
TAffine transform;
CleanupSettingsModel::instance()->getPreviewData(original, transformed, transform);
m_swatch->setRaster(original ? original->getRaster() : TRasterP(),
transform,
transformed ? transformed->getRaster() : TRasterP());
}
//-----------------------------------------------------------------------------
void CleanupSettings::postProcess()
{
m_swatch->updateCleanupped();
}
//-----------------------------------------------------------------------------
void CleanupSettings::onClnLoaded()
{
const TFilePath &fp = CleanupSettingsModel::instance()->clnPath();
const QString &newWindowTitle = (fp.isEmpty()) ? tr("Cleanup Settings") : tr("Cleanup Settings: %1").arg(toQString(fp.withoutParentDir()));
if (windowTitle() != newWindowTitle) {
setWindowTitle(newWindowTitle);
emit windowTitleChanged(windowTitle());
}
}
//-----------------------------------------------------------------------------
void CleanupSettings::onRestoreSceneSettings()
{
CleanupSettingsModel *model = CleanupSettingsModel::instance();
model->saveSettingsIfNeeded();
model->restoreGlobalSettings();
}
//**********************************************************************
// Toggle Opacity Check Command
//**********************************************************************
class ToggleOpacityCheckCommand : public MenuItemHandler
{
public:
ToggleOpacityCheckCommand()
: MenuItemHandler(MI_OpacityCheck) {}
void execute()
{
CleanupSettingsModel *model = CleanupSettingsModel::instance();
CleanupParameters *params = model->getCurrentParameters();
params->m_transparencyCheckEnabled = !params->m_transparencyCheckEnabled;
model->commitChanges();
}
} toggleOpacityCheckCommand;
//**********************************************************************
// Open Popup Command
//**********************************************************************
/*
class CleanupSettingsFactory : public TPanelFactory
{
public:
CleanupSettingsFactory() : TPanelFactory("CleanupSettings") {}
void initialize(TPanel* panel)
{
CleanupSettings* cleanupSettings = new CleanupSettings(panel);
panel->setWidget(cleanupSettings);
bool ret = QObject::connect(
cleanupSettings, SIGNAL(windowTitleChanged(const QString&)),
panel, SLOT(setWindowTitle(const QString&)));
assert(ret);
panel->setMinimumSize(320, 150);
panel->resize(600, 500);
}
} cleanupSettingsFactory;
*/
OpenFloatingPanel cleanupSettingsCommand(MI_CleanupSettings, "CleanupSettings", QObject::tr("Cleanup Settings"));