void
KnobGuiColor::onDialogCurrentColorChanged(const QColor & color)
{
KnobColorPtr knob = _knob.lock();
if (!knob) {
return;
}
int nDims = knob->getNDimensions();
std::vector<double> values(nDims);
values[0] = color.redF();
convertFromUIToInternalColorspace(&values[0]);
if (nDims > 1) {
values[1] = color.greenF();
convertFromUIToInternalColorspace(&values[1]);
}
if (nDims > 2) {
values[2] = color.blueF();
convertFromUIToInternalColorspace(&values[2]);
}
if (nDims > 3) {
values[3] = color.alphaF();
}
KnobGuiPtr knobUI = getKnobGui();
knob->setValueAcrossDimensions(values, DimIdx(0), getView(), eValueChangedReasonUserEdited);
if ( knobUI->getGui() ) {
knobUI->getGui()->setDraftRenderEnabled(true);
}
}
void
KnobGuiGroup::setEnabled(const std::vector<bool>& perDimEnabled)
{
KnobGroupPtr knob = _knob.lock();
if (_button) {
_button->setEnabled(perDimEnabled[0]);
}
if (perDimEnabled[0]) {
for (std::list<KnobGuiWPtr>::iterator it = _children.begin(); it != _children.end(); ++it) {
KnobGuiPtr k = it->lock();
if (!k) {
continue;
}
k->setEnabledSlot();
}
} else {
for (std::list<KnobGuiWPtr>::iterator it = _children.begin(); it != _children.end(); ++it) {
KnobGuiPtr k = it->lock();
if (!k) {
continue;
}
k->onFrozenChanged(true);
}
}
}
void
KnobGuiGroup::setCheckedInternal(bool checked,
bool userRequested)
{
if (checked == _checked) {
return;
}
_checked = checked;
if (userRequested) {
KnobGroupPtr knob = _knob.lock();
if (knob) {
knob->setValue(checked);
}
}
//getGui()->getPropertiesBin()->setUpdatesEnabled(false);
for (std::list<KnobGuiWPtr>::iterator it = _children.begin(); it != _children.end(); ++it) {
KnobGuiPtr knob = it->lock();
if (!knob) {
continue;
}
if (!checked) {
knob->hide();
} else if ( !knob->getKnob()->getIsSecret() ) {
knob->show();
}
}
//getGui()->getPropertiesBin()->setUpdatesEnabled(true);
}
void
KnobGuiFile::createWidget(QHBoxLayout* layout)
{
KnobGuiPtr knobUI = getKnobGui();
if (!knobUI) {
return;
}
Gui* gui = knobUI->getGui();
if (!gui) {
return;
}
GuiAppInstancePtr app = gui->getApp();
if (!app) {
return;
}
KnobFilePtr knob = _knob.lock();
if (!knob) {
return;
}
EffectInstancePtr holderIsEffect = toEffectInstance( knob->getHolder() );
if ( holderIsEffect && holderIsEffect->isReader() && (knob->getName() == kOfxImageEffectFileParamName) ) {
TimeLinePtr timeline = app->getTimeLine();
QObject::connect( timeline.get(), SIGNAL(frameChanged(SequenceTime,int)), this, SLOT(onTimelineFrameChanged(SequenceTime,int)) );
}
KnobGuiColor::KnobGuiColor(const KnobGuiPtr& knobUI, ViewIdx view)
: KnobGuiValue(knobUI, view)
, _knob( toKnobColor(knobUI->getKnob()) )
, _colorLabel(0)
, _colorDialogButton(0)
, _useSimplifiedUI(false)
, _uiColorspaceLut(0)
, _internalColorspaceLut(0)
{
KnobColorPtr knob = _knob.lock();
if (!knob) {
return;
}
_useSimplifiedUI = knob && knob->isSimplified();
if (!_useSimplifiedUI) {
DimIdx singleDim;
bool singleDimEnabled = knobUI->isSingleDimensionalEnabled(&singleDim);
if (knobUI->getLayoutType() == KnobGui::eKnobLayoutTypeViewerUI && !singleDimEnabled) {
_useSimplifiedUI = true;
}
}
const std::string& uiName = knob->getUIColorspaceName();
const std::string& internalName = knob->getInternalColorspaceName();
_uiColorspaceLut = Color::LutManager::findLut(uiName);
_internalColorspaceLut = Color::LutManager::findLut(internalName);
}
void
KnobGuiColor::onDialogCurrentColorChanged(const QColor & color)
{
KnobColorPtr knob = _knob.lock();
bool isSimple = _useSimplifiedUI;
int nDims = knob->getNDimensions();
std::vector<double> values(nDims);
values[0] = isSimple ? color.redF() : Color::from_func_srgb( color.redF() );
if (nDims >= 3) {
values[1] = isSimple ? color.greenF() : Color::from_func_srgb( color.greenF() );
values[2] = isSimple ? color.blueF() : Color::from_func_srgb( color.blueF() );
if (nDims == 4) {
values[3] = color.alphaF();
}
}
KnobGuiPtr knobUI = getKnobGui();
knob->setValueAcrossDimensions(values, DimIdx(0), getView(), eValueChangedReasonUserEdited);
if ( knobUI->getGui() ) {
knobUI->getGui()->setDraftRenderEnabled(true);
}
}
void
DSRemoveKeysCommand::addOrRemoveKeyframe(bool add)
{
std::set<KnobGuiPtr> knobsSet;
for (std::vector<DopeSheetKey>::iterator it = _keys.begin(); it != _keys.end(); ++it) {
DopeSheetKey selected = (*it);
DSKnobPtr knobContext = selected.context.lock();
if (!knobContext) {
continue;
}
KnobGuiPtr knobGui = knobContext->getKnobGui();
assert(knobGui);
std::pair<std::set<KnobGuiPtr>::iterator,bool> ok = knobsSet.insert(knobGui);
if (ok.second) {
knobGui->getKnob()->beginChanges();
}
if (add) {
knobGui->setKeyframe( selected.key.getTime(), selected.key, knobContext->getDimension(), ViewIdx(0) );
} else {
knobGui->removeKeyFrame( selected.key.getTime(), knobContext->getDimension(), ViewIdx(0) );
knobContext->getTreeItem()->setSelected(false);
}
}
for (std::set<KnobGuiPtr>::iterator it = knobsSet.begin(); it != knobsSet.end(); ++it) {
(*it)->getKnob()->endChanges();
}
_model->refreshSelectionBboxAndRedrawView();
}
void
KnobGuiButton::createWidget(QHBoxLayout* layout)
{
KnobGuiPtr knobUI = getKnobGui();
KnobButtonPtr knob = _knob.lock();
_button = new Button( layout->parentWidget() );
if (knobUI->getLayoutType() == KnobGui::eKnobLayoutTypeTableItemWidget) {
_button->setIconSize( QSize(TO_DPIX(NATRON_SMALL_BUTTON_ICON_SIZE), TO_DPIY(NATRON_SMALL_BUTTON_ICON_SIZE)) );
} else {
_button->setIconSize( QSize(TO_DPIX(NATRON_MEDIUM_BUTTON_ICON_SIZE), TO_DPIY(NATRON_MEDIUM_BUTTON_ICON_SIZE)) );
}
loadPixmaps(false, QColor());
if (!_button->icon().isNull()) {
_button->setFixedSize(TO_DPIX(NATRON_MEDIUM_BUTTON_SIZE), TO_DPIY(NATRON_MEDIUM_BUTTON_SIZE));
}
bool checkable = knob->getIsCheckable();
if (checkable) {
_button->setCheckable(true);
bool checked = knob->getValue();
_button->setChecked(checked);
_button->setDown(checked);
}
QObject::connect( _button, SIGNAL(clicked(bool)), this, SLOT(emitValueChanged(bool)) );
if ( knobUI->hasToolTip() ) {
knobUI->toolTip(_button, getView());
}
layout->addWidget(_button);
} // KnobGuiButton::createWidget
PasteUndoCommand::PasteUndoCommand(const KnobGuiPtr& knob,
KnobClipBoardType type,
int fromDimension,
int targetDimension,
const KnobPtr& fromKnob)
: QUndoCommand(0)
, _imp( new PasteUndoCommandPrivate() )
{
_imp->knob = knob;
_imp->type = type;
_imp->fromDimension = fromDimension;
_imp->targetDimension = targetDimension;
_imp->fromKnob = fromKnob;
{
std::ostringstream ss;
{
try {
boost::archive::xml_oarchive oArchive(ss);
_imp->originalSerialization->initialize( knob->getKnob() );
oArchive << boost::serialization::make_nvp("KnobClipboard", *_imp->originalSerialization);
} catch (...) {
assert(false);
}
}
_imp->originalSerialization.reset(new KnobSerialization);
std::string str = ss.str();
{
try {
std::stringstream ss(str);
boost::archive::xml_iarchive iArchive(ss);
iArchive >> boost::serialization::make_nvp("KnobClipboard", *_imp->originalSerialization);
} catch (...) {
assert(false);
}
}
}
assert( _imp->originalSerialization->getKnob() );
assert(knob);
assert( _imp->targetDimension >= -1 && _imp->targetDimension < _imp->knob.lock()->getKnob()->getDimension() );
assert( _imp->fromDimension >= -1 && _imp->fromDimension < _imp->fromKnob->getDimension() );
QString text;
switch (type) {
case eKnobClipBoardTypeCopyAnim:
text = tr("Paste Animation to %1");
break;
case eKnobClipBoardTypeCopyValue:
text = tr("Paste Value to %1");
break;
case eKnobClipBoardTypeCopyLink:
text = tr("Paste Link to %1");
break;
}
setText( text.arg( QString::fromUtf8( knob->getKnob()->getLabel().c_str() ) ) );
}
void
KnobGuiBool::updateToolTip()
{
KnobGuiPtr knob = getKnobGui();
if ( knob->hasToolTip() ) {
for (int i = 0; i < _knob.lock()->getNDimensions(); ++i) {
knob->toolTip(_checkBox, getView());
}
}
}
void
KnobGuiChoice::onCurrentIndexChanged(int i)
{
KnobGuiPtr knobUI = getKnobGui();
knobUI->setWarningValue( KnobGui::eKnobWarningChoiceMenuOutOfDate, QString() );
KnobChoicePtr knob = _knob.lock();
if (!knob) {
return;
}
knobUI->pushUndoCommand( new KnobUndoCommand<int>(knob, knob->getValue(DimIdx(0), getView()), i, DimIdx(0), getView()));
}
void
KnobGui::hide()
{
if (!_imp->customInteract) {
_hide();
} else {
_imp->customInteract->hide();
}
//also hide the curve from the curve editor if there's any and the knob is not inside a group
KnobPtr knob = getKnob();
if ( knob && knob->getHolder() && knob->getHolder()->getApp() ) {
KnobPtr parent = getKnob()->getParentKnob();
bool isSecret = true;
while (parent) {
if ( !parent->getIsSecret() ) {
isSecret = false;
break;
}
parent = parent->getParentKnob();
}
if (isSecret) {
getGui()->getCurveEditor()->hideCurves( shared_from_this() );
}
}
////In order to remove the row of the layout we have to make sure ALL the knobs on the row
////are hidden.
bool shouldRemoveWidget = true;
for (U32 i = 0; i < _imp->knobsOnSameLine.size(); ++i) {
KnobGuiPtr sibling = _imp->container->getKnobGui( _imp->knobsOnSameLine[i].lock() );
if ( sibling && !sibling->isSecretRecursive() ) {
shouldRemoveWidget = false;
}
}
if (shouldRemoveWidget) {
if (_imp->field) {
_imp->field->hide();
}
if (_imp->container) {
_imp->container->refreshTabWidgetMaxHeight();
}
} else {
if ( _imp->field && !_imp->field->isVisible() ) {
_imp->field->show();
}
}
if (_imp->labelContainer) {
_imp->labelContainer->hide();
} else if (_imp->descriptionLabel) {
_imp->descriptionLabel->hide();
}
} // KnobGui::hide
void
KnobGuiBool::updateToolTip()
{
KnobGuiPtr knobgui = getKnobGui();
if ( knobgui->hasToolTip() ) {
KnobBoolPtr knob = _knob.lock();
if (!knob) {
return;
}
knobgui->toolTip(_checkBox, getView());
}
}
void
KnobGuiColor::onColorLabelPickingEnabled(bool enabled)
{
KnobColorPtr knob = _knob.lock();
KnobGuiPtr knobUI = getKnobGui();
if ( knob->getHolder()->getApp() ) {
if (enabled) {
knobUI->getGui()->registerNewColorPicker( _knob.lock(), getView() );
} else {
knobUI->getGui()->removeColorPicker( _knob.lock(), getView());
}
}
}
void
KnobGuiGroup::_hide()
{
if (_button) {
_button->hide();
}
for (std::list<KnobGuiWPtr>::iterator it = _children.begin(); it != _children.end(); ++it) {
KnobGuiPtr k = it->lock();
if (!k) {
continue;
}
k->hide();
}
}
void
ColorPickerLabel::setEnabledMode(bool enabled)
{
setEnabled(enabled);
if (!enabled && _pickingEnabled) {
_pickingEnabled = false;
setColor(_currentColor);
if (_knob) {
ViewIdx view = _knob->getView();
KnobGuiPtr knobUI = _knob->getKnobGui();
knobUI->getGui()->removeColorPicker( toKnobColor( knobUI->getKnob() ), view );
}
}
}
void
KnobGuiGroup::createWidget(QHBoxLayout* layout)
{
_button = new GroupBoxLabel( layout->parentWidget() );
KnobGuiPtr knobUI = getKnobGui();
if ( knobUI->hasToolTip() ) {
knobUI->toolTip(_button, getView());
}
_checked = _knob.lock()->getValue(DimIdx(0), getView());
_button->setFixedSize(NATRON_MEDIUM_BUTTON_SIZE, NATRON_MEDIUM_BUTTON_SIZE);
_button->setChecked(_checked);
QObject::connect( _button, SIGNAL(checked(bool)), this, SLOT(onCheckboxChecked(bool)) );
layout->addWidget(_button);
}
void
KnobGuiColor::addExtraWidgets(QHBoxLayout* containerLayout)
{
containerLayout->addSpacing( TO_DPIX(10) );
KnobColorPtr knob = _knob.lock();
if (!knob) {
return;
}
KnobGuiPtr knobUI = getKnobGui();
if (!knobUI) {
return;
}
_colorLabel = new ColorPickerLabel( _useSimplifiedUI, knobUI->getLayoutType(), this, containerLayout->widget() );
if (!_useSimplifiedUI && knobUI->getLayoutType() != KnobGui::eKnobLayoutTypeTableItemWidget) {
_colorLabel->setToolTip( NATRON_NAMESPACE::convertFromPlainText(tr("To pick a color on a viewer, click this and then press control + left click on any viewer.\n"
"You can also pick the average color of a given rectangle by holding control + shift + left click\n. "
"To deselect the picker left click anywhere."
"Note that by default %1 converts to linear the color picked\n"
"because all the processing pipeline is linear, but you can turn this off in the\n"
"preferences panel.").arg( QString::fromUtf8(NATRON_APPLICATION_NAME) ), NATRON_NAMESPACE::WhiteSpaceNormal) );
}
QSize medSize( TO_DPIX(NATRON_MEDIUM_BUTTON_SIZE), TO_DPIY(NATRON_MEDIUM_BUTTON_SIZE) );
QSize medIconSize( TO_DPIX(NATRON_MEDIUM_BUTTON_ICON_SIZE), TO_DPIY(NATRON_MEDIUM_BUTTON_ICON_SIZE) );
_colorLabel->setFixedSize(medSize);
QObject::connect( _colorLabel, SIGNAL(pickingEnabled(bool)), this, SLOT(onColorLabelPickingEnabled(bool)) );
containerLayout->addWidget(_colorLabel);
if (_useSimplifiedUI) {
containerLayout->addSpacing( TO_DPIX(5) );
}
if (knobUI->getLayoutType() != KnobGui::eKnobLayoutTypeTableItemWidget) {
QPixmap buttonPix;
appPTR->getIcon(NATRON_PIXMAP_COLORWHEEL, NATRON_MEDIUM_BUTTON_ICON_SIZE, &buttonPix);
_colorDialogButton = new Button( QIcon(buttonPix), QString(), containerLayout->widget() );
_colorDialogButton->setFixedSize(medSize);
_colorDialogButton->setIconSize(medIconSize);
_colorDialogButton->setToolTip( NATRON_NAMESPACE::convertFromPlainText(tr("Open the color dialog."), NATRON_NAMESPACE::WhiteSpaceNormal) );
_colorDialogButton->setFocusPolicy(Qt::NoFocus);
QObject::connect( _colorDialogButton, SIGNAL(clicked()), this, SLOT(showColorDialog()) );
containerLayout->addWidget(_colorDialogButton);
}
if (_useSimplifiedUI) {
setWidgetsVisibleInternal(false);
KnobGuiWidgets::enableRightClickMenu(getKnobGui(), _colorLabel, DimSpec::all(), getView());
}
}
void
KnobGuiBool::createWidget(QHBoxLayout* layout)
{
KnobGuiPtr knobUI = getKnobGui();
_checkBox = new Bool_CheckBox( knobUI, DimIdx(0), getView(), layout->parentWidget() );
onLabelChanged();
//_checkBox->setFixedSize(NATRON_MEDIUM_BUTTON_SIZE, NATRON_MEDIUM_BUTTON_SIZE);
QObject::connect( _checkBox, SIGNAL(clicked(bool)), this, SLOT(onCheckBoxStateChanged(bool)) );
QObject::connect( knobUI.get(), SIGNAL(labelClicked(bool)), this, SLOT(onLabelClicked(bool)) );
///set the copy/link actions in the right click menu
KnobGuiWidgets::enableRightClickMenu(knobUI, _checkBox, DimIdx(0), getView());
layout->addWidget(_checkBox);
}
KnobGuiColor::KnobGuiColor(const KnobGuiPtr& knobUI, ViewIdx view)
: KnobGuiValue(knobUI, view)
, _knob( toKnobColor(knobUI->getKnob()) )
, _colorLabel(0)
, _colorDialogButton(0)
, _useSimplifiedUI( _knob.lock()->isSimplified() )
{
if (!_useSimplifiedUI) {
DimIdx singleDim;
bool singleDimEnabled = knobUI->isSingleDimensionalEnabled(&singleDim);
if (knobUI->getLayoutType() == KnobGui::eKnobLayoutTypeViewerUI && !singleDimEnabled) {
_useSimplifiedUI = true;
}
}
}
std::string
KnobGuiWidgets::getDescriptionLabel() const
{
std::string ret;
KnobGuiPtr knob = getKnobGui();
if (!knob) {
return ret;
}
KnobIPtr internalKnob = knob->getKnob();
if (!internalKnob) {
return ret;
}
ret = internalKnob->getLabel();
return ret;
}
MultipleKnobEditsUndoCommand::MultipleKnobEditsUndoCommand(const KnobGuiPtr& knob,
ValueChangedReasonEnum reason,
bool createNew,
bool setKeyFrame,
const Variant & value,
int dimension,
double time)
: QUndoCommand()
, knobs()
, createNew(createNew)
, firstRedoCalled(false)
, _reason(reason)
{
assert(knob);
std::list<ValueToSet>& vlist = knobs[knob];
ValueToSet v;
v.newValue = value;
v.dimension = dimension;
assert(dimension != -1);
v.time = time;
v.setKeyFrame = setKeyFrame;
v.setValueRetCode = -1;
vlist.push_back(v);
KnobHolder* holder = knob->getKnob()->getHolder();
EffectInstance* effect = dynamic_cast<EffectInstance*>(holder);
QString holderName;
if (effect) {
holderName = QString::fromUtf8( effect->getNode()->getLabel().c_str() );
}
setText( tr("Multiple edits for %1").arg(holderName) );
}
KnobGuiGroup::KnobGuiGroup(const KnobGuiPtr& knob, ViewIdx view)
: KnobGuiWidgets(knob, view)
, _checked(false)
, _button(0)
, _children()
, _knob( toKnobGroup(knob->getKnob()) )
{
}
KnobComboBox::KnobComboBox(const KnobGuiPtr& knob,
DimSpec dimension,
ViewIdx view,
QWidget* parent)
: ComboBox(parent)
, _knob(toKnobChoice(knob->getKnob()))
, _dnd( KnobWidgetDnD::create(knob, dimension, view, this) )
, _drawLinkedFrame(false)
{
}
void
KnobGuiGroup::setWidgetsVisible(bool visible)
{
if (_button) {
_button->setVisible(visible);
}
for (std::list<KnobGuiWPtr>::iterator it = _children.begin(); it != _children.end(); ++it) {
KnobGuiPtr k = it->lock();
if (!k) {
continue;
}
if (visible) {
k->show();
} else {
k->hide();
}
}
}
LinkToKnobDialog::LinkToKnobDialog(const KnobGuiPtr& from,
QWidget* parent)
: QDialog(parent)
, _imp( new LinkToKnobDialogPrivate(from) )
{
_imp->mainLayout = new QVBoxLayout(this);
_imp->firstLine = new QWidget(this);
_imp->firstLineLayout = new QHBoxLayout(_imp->firstLine);
_imp->mainLayout->addWidget(_imp->firstLine);
_imp->buttons = new QDialogButtonBox(QDialogButtonBox::StandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel),
Qt::Horizontal, this);
QObject::connect( _imp->buttons, SIGNAL(accepted()), this, SLOT(accept()) );
QObject::connect( _imp->buttons, SIGNAL(rejected()), this, SLOT(reject()) );
_imp->mainLayout->addWidget(_imp->buttons);
_imp->selectNodeLabel = new Label(tr("Parent:"), _imp->firstLine);
_imp->firstLineLayout->addWidget(_imp->selectNodeLabel);
EffectInstance* isEffect = dynamic_cast<EffectInstance*>( from->getKnob()->getHolder() );
assert(isEffect);
if (!isEffect) {
throw std::logic_error("");
}
boost::shared_ptr<NodeCollection> group = isEffect->getNode()->getGroup();
group->getActiveNodes(&_imp->allNodes);
NodeGroup* isGroup = dynamic_cast<NodeGroup*>( group.get() );
if (isGroup) {
_imp->allNodes.push_back( isGroup->getNode() );
}
QStringList nodeNames;
for (NodesList::iterator it = _imp->allNodes.begin(); it != _imp->allNodes.end(); ++it) {
QString name = QString::fromUtf8( (*it)->getLabel().c_str() );
nodeNames.push_back(name);
//_imp->nodeSelectionCombo->addItem(name);
}
nodeNames.sort();
_imp->nodeSelectionCombo = new CompleterLineEdit(nodeNames, nodeNames, false, this);
_imp->nodeSelectionCombo->setToolTip( GuiUtils::convertFromPlainText(tr("Input the name of a node in the current project."), Qt::WhiteSpaceNormal) );
_imp->firstLineLayout->addWidget(_imp->nodeSelectionCombo);
_imp->nodeSelectionCombo->setFocus(Qt::PopupFocusReason);
QTimer::singleShot( 25, _imp->nodeSelectionCombo, SLOT(showCompleter()) );
_imp->knobSelectionCombo = new ComboBox(_imp->firstLine);
_imp->firstLineLayout->addWidget(_imp->knobSelectionCombo);
QObject::connect( _imp->nodeSelectionCombo, SIGNAL(itemCompletionChosen()), this, SLOT(onNodeComboEditingFinished()) );
_imp->firstLineLayout->addStretch();
}
KnobGuiChoice::KnobGuiChoice(const KnobGuiPtr& knob, ViewIdx view)
: KnobGuiWidgets(knob, view)
, _comboBox(0)
{
KnobChoicePtr k = toKnobChoice(knob->getKnob());
QObject::connect( k.get(), SIGNAL(populated()), this, SLOT(onEntriesPopulated()) );
QObject::connect( k.get(), SIGNAL(entryAppended()), this, SLOT(onEntryAppended()) );
QObject::connect( k.get(), SIGNAL(entriesReset()), this, SLOT(onEntriesReset()) );
_knob = k;
}
void
KnobGuiGroup::_show()
{
// if ( _knob->getIsSecret() ) {
// return;
// }
if (_button) {
_button->show();
}
if (_checked) {
for (std::list<KnobGuiWPtr>::iterator it = _children.begin(); it != _children.end(); ++it) {
KnobGuiPtr k = it->lock();
if (!k) {
continue;
}
k->show();
}
}
}
void
KnobSpinBox::focusInEvent(QFocusEvent* e)
{
_dnd->focusIn();
SpinBox::focusInEvent(e);
//Set the expression so the user can edit it easily
KnobGuiPtr k = knob.lock();
if (!k) {
return;
}
std::string expr = k->getKnob()->getExpression(dimension);
if ( expr.empty() ) {
return;
} else {
QLineEdit::setText( QString::fromUtf8( expr.c_str() ) );
setCursorPosition(expr.size() - 1);
}
}
void onSelectedKnobChanged()
{
if (!selectedKnob) {
return;
}
KnobParametricPtr isParametric = toKnobParametric( selectedKnob->getKnob() );
if (isParametric) {
useAliasCheckBox->setChecked(true);
}
useAliasLabel->setEnabled(!isParametric);
useAliasCheckBox->setEnabled(!isParametric);
}
