bool
GuiAppInstance::findAndTryLoadUntitledAutoSave()
{
if ( !appPTR->getCurrentSettings()->isAutoSaveEnabledForUnsavedProjects() ) {
return false;
}
QDir savesDir( Project::autoSavesDir() );
QStringList entries = savesDir.entryList(QDir::Files | QDir::NoDotAndDotDot);
QStringList foundAutosaves;
for (int i = 0; i < entries.size(); ++i) {
const QString & entry = entries.at(i);
QString searchStr( QLatin1Char('.') );
searchStr.append( QString::fromUtf8(NATRON_PROJECT_FILE_EXT) );
searchStr.append( QString::fromUtf8(".autosave") );
int suffixPos = entry.indexOf(searchStr);
if ( (suffixPos == -1) || entry.contains( QString::fromUtf8("RENDER_SAVE") ) ) {
continue;
}
foundAutosaves << entry;
}
if ( foundAutosaves.empty() ) {
return false;
}
QString text = tr("An auto-saved project was found with no associated project file.\n"
"Would you like to restore it?\n"
"Clicking No will remove this auto-save.");
appPTR->hideSplashScreen();
StandardButtonEnum ret = Dialogs::questionDialog(tr("Auto-save").toStdString(),
text.toStdString(), false, StandardButtons(eStandardButtonYes | eStandardButtonNo),
eStandardButtonYes);
if ( (ret == eStandardButtonNo) || (ret == eStandardButtonEscape) ) {
Project::clearAutoSavesDir();
return false;
}
for (int i = 0; i < foundAutosaves.size(); ++i) {
const QString& autoSaveFileName = foundAutosaves[i];
if (i == 0) {
//Load the first one into the current instance of Natron, then open-up new instances
if ( !getProject()->loadProject(savesDir.path() + QLatin1Char('/'), autoSaveFileName, true) ) {
return false;
}
} else {
CLArgs cl;
AppInstancePtr newApp = appPTR->newAppInstance(cl, false);
if ( !newApp->getProject()->loadProject(savesDir.path() + QLatin1Char('/'), autoSaveFileName, true) ) {
return false;
}
}
}
return true;
} // findAndTryLoadAutoSave
AppInstancePtr
Gui::openProjectInternal(const std::string & absoluteFileName,
bool attemptToLoadAutosave)
{
QFileInfo file( QString::fromUtf8( absoluteFileName.c_str() ) );
if ( !file.exists() ) {
return AppInstancePtr();
}
QString fileUnPathed = file.fileName();
QString path = file.path() + QLatin1Char('/');
int openedProject = appPTR->isProjectAlreadyOpened(absoluteFileName);
if (openedProject != -1) {
AppInstancePtr instance = appPTR->getAppInstance(openedProject);
if (instance) {
GuiAppInstancePtr guiApp = toGuiAppInstance(instance);
if (guiApp) {
guiApp->getGui()->activateWindow();
return instance;
}
}
}
AppInstancePtr ret;
ProjectPtr project = getApp()->getProject();
///if the current graph has no value, just load the project in the same window
if ( project->isGraphWorthLess() ) {
bool ok = project->loadProject( path, fileUnPathed, false, attemptToLoadAutosave);
if (ok) {
ret = _imp->_appInstance.lock();
}
} else {
CLArgs cl;
AppInstancePtr newApp = appPTR->newAppInstance(cl, false);
bool ok = newApp->getProject()->loadProject( path, fileUnPathed, false, attemptToLoadAutosave);
if (ok) {
ret = newApp;
}
}
QSettings settings;
QStringList recentFiles = settings.value( QString::fromUtf8("recentFileList") ).toStringList();
recentFiles.removeAll( QString::fromUtf8( absoluteFileName.c_str() ) );
recentFiles.prepend( QString::fromUtf8( absoluteFileName.c_str() ) );
while (recentFiles.size() > NATRON_MAX_RECENT_FILES) {
recentFiles.removeLast();
}
settings.setValue(QString::fromUtf8("recentFileList"), recentFiles);
appPTR->updateAllRecentFileMenus();
return ret;
} // Gui::openProjectInternal
void
RestoreDefaultsCommand::redo()
{
KnobIPtr first = _knobs.front().lock();
AppInstancePtr app;
KnobHolderPtr holder = first->getHolder();
EffectInstancePtr isEffect = toEffectInstance(holder);
if (holder) {
app = holder->getApp();
holder->beginChanges();
}
// First reset all knobs values, this will not call instanceChanged action
for (std::list<KnobIWPtr >::iterator it = _knobs.begin(); it != _knobs.end(); ++it) {
KnobIPtr itKnob = it->lock();
if (!itKnob) {
continue;
}
if ( itKnob->getHolder() ) {
itKnob->getHolder()->beginChanges();
}
itKnob->resetToDefaultValue(_targetDim, _targetView);
if ( itKnob->getHolder() ) {
itKnob->getHolder()->endChanges(true);
}
}
// Call instanceChange on all knobs afterwards to put back the plug-in
// in a correct state
double time = 0;
if (app) {
time = app->getTimeLine()->currentFrame();
}
for (std::list<KnobIWPtr >::iterator it = _knobs.begin(); it != _knobs.end(); ++it) {
KnobIPtr itKnob = it->lock();
if (!itKnob) {
continue;
}
if ( itKnob->getHolder() ) {
itKnob->getHolder()->onKnobValueChanged_public(itKnob, eValueChangedReasonRestoreDefault, time, ViewIdx(0), true);
}
}
if ( holder && holder->getApp() ) {
holder->endChanges();
}
if ( first->getHolder() ) {
if ( first->getHolder()->getApp() ) {
first->getHolder()->getApp()->redrawAllViewers();
}
}
} // RestoreDefaultsCommand::redo
AppInstancePtr
Gui::createNewProject()
{
CLArgs cl;
AppInstancePtr app = appPTR->newAppInstance(cl, false);
app->execOnProjectCreatedCallback();
return app;
}
GuiApp*
PyGuiApplication::getGuiInstance(int idx) const
{
AppInstancePtr app = appPTR->getAppInstance(idx);
if (!app) {
return 0;
}
GuiAppInstancePtr guiApp = toGuiAppInstance(app);
if (!guiApp) {
return 0;
}
// First, try to re-use an existing Effect object that was created for this node.
// If not found, create one.
std::stringstream ss;
ss << kPythonTmpCheckerVariable << " = " << app->getAppIDString() ;
std::string script = ss.str();
bool ok = NATRON_PYTHON_NAMESPACE::interpretPythonScript(script, 0, 0);
// Clear errors if our call to interpretPythonScript failed, we don't want the
// calling function to fail aswell.
PyErr_Clear();
if (ok) {
PyObject* pyApp = 0;
PyObject* mainModule = NATRON_PYTHON_NAMESPACE::getMainModule();
if ( PyObject_HasAttrString(mainModule, kPythonTmpCheckerVariable) ) {
pyApp = PyObject_GetAttrString(mainModule, kPythonTmpCheckerVariable);
if (pyApp == Py_None) {
pyApp = 0;
}
}
GuiApp* cppApp = 0;
if (pyApp && Shiboken::Object::isValid(pyApp)) {
cppApp = (GuiApp*)Shiboken::Conversions::cppPointer(SbkNatronGuiTypes[SBK_GUIAPP_IDX], (SbkObject*)pyApp);
}
NATRON_PYTHON_NAMESPACE::interpretPythonScript("del " kPythonTmpCheckerVariable, 0, 0);
if (cppApp) {
return cppApp;
}
}
return new GuiApp(guiApp);
}
void
TrackerNodePrivate::exportTrackDataFromExportOptions()
{
//bool transformLink = _imp->exportLink.lock()->getValue();
KnobChoicePtr transformTypeKnob = transformType.lock();
assert(transformTypeKnob);
int transformType_i = transformTypeKnob->getValue();
TrackerTransformNodeEnum transformType = (TrackerTransformNodeEnum)transformType_i;
KnobChoicePtr motionTypeKnob = motionType.lock();
if (!motionTypeKnob) {
return;
}
int motionType_i = motionTypeKnob->getValue();
TrackerMotionTypeEnum mt = (TrackerMotionTypeEnum)motionType_i;
if (mt == eTrackerMotionTypeNone) {
Dialogs::errorDialog( tr("Tracker Export").toStdString(), tr("Please select the export mode with the Motion Type parameter").toStdString() );
return;
}
bool linked = exportLink.lock()->getValue();
QString pluginID;
switch (transformType) {
case eTrackerTransformNodeCornerPin:
pluginID = QString::fromUtf8(PLUGINID_OFX_CORNERPIN);
break;
case eTrackerTransformNodeTransform:
pluginID = QString::fromUtf8(PLUGINID_OFX_TRANSFORM);
break;
}
NodePtr thisNode = publicInterface->getNode();
AppInstancePtr app = thisNode->getApp();
CreateNodeArgsPtr args(CreateNodeArgs::create( pluginID.toStdString(), thisNode->getGroup() ));
args->setProperty<bool>(kCreateNodeArgsPropAutoConnect, false);
args->setProperty<bool>(kCreateNodeArgsPropSettingsOpened, false);
NodePtr createdNode = app->createNode(args);
if (!createdNode) {
return;
}
// Move the new node
double thisNodePos[2];
double thisNodeSize[2];
thisNode->getPosition(&thisNodePos[0], &thisNodePos[1]);
thisNode->getSize(&thisNodeSize[0], &thisNodeSize[1]);
createdNode->setPosition(thisNodePos[0] + thisNodeSize[0] * 2., thisNodePos[1]);
TimeValue timeForFromPoints(referenceFrame.lock()->getValue());
switch (transformType) {
case eTrackerTransformNodeCornerPin: {
KnobDoublePtr cornerPinToPoints[4];
KnobDoublePtr cornerPinFromPoints[4];
for (unsigned int i = 0; i < 4; ++i) {
cornerPinFromPoints[i] = getCornerPinPoint(createdNode, true, i);
assert(cornerPinFromPoints[i]);
for (int j = 0; j < cornerPinFromPoints[i]->getNDimensions(); ++j) {
cornerPinFromPoints[i]->setValue(fromPoints[i].lock()->getValueAtTime(timeForFromPoints, DimIdx(j)), ViewSetSpec::all(), DimIdx(j));
}
cornerPinToPoints[i] = getCornerPinPoint(createdNode, false, i);
assert(cornerPinToPoints[i]);
if (!linked) {
cornerPinToPoints[i]->copyKnob( toPoints[i].lock() );
} else {
bool ok = cornerPinToPoints[i]->linkTo(toPoints[i].lock());
(void)ok;
assert(ok);
}
}
{
KnobIPtr knob = createdNode->getKnobByName(kCornerPinParamMatrix);
if (knob) {
KnobDoublePtr isType = toKnobDouble(knob);
if (isType) {
isType->copyKnob(cornerPinMatrix.lock() );
}
}
}
break;
}
case eTrackerTransformNodeTransform: {
KnobIPtr translateKnob = createdNode->getKnobByName(kTransformParamTranslate);
if (translateKnob) {
KnobDoublePtr isDbl = toKnobDouble(translateKnob);
if (isDbl) {
if (!linked) {
isDbl->copyKnob(translate.lock() );
} else {
ignore_result(isDbl->linkTo(translate.lock()));
}
}
}
KnobIPtr scaleKnob = createdNode->getKnobByName(kTransformParamScale);
if (scaleKnob) {
KnobDoublePtr isDbl = toKnobDouble(scaleKnob);
if (isDbl) {
if (!linked) {
isDbl->copyKnob(scale.lock() );
} else {
ignore_result(isDbl->linkTo(scale.lock()));
}
}
}
KnobIPtr rotateKnob = createdNode->getKnobByName(kTransformParamRotate);
if (rotateKnob) {
KnobDoublePtr isDbl = toKnobDouble(rotateKnob);
if (isDbl) {
if (!linked) {
isDbl->copyKnob(rotate.lock());
} else {
ignore_result(isDbl->linkTo(rotate.lock()));
}
}
}
KnobIPtr centerKnob = createdNode->getKnobByName(kTransformParamCenter);
if (centerKnob) {
KnobDoublePtr isDbl = toKnobDouble(centerKnob);
if (isDbl) {
isDbl->copyKnob( center.lock() );
}
}
break;
}
} // switch
KnobIPtr cpInvertKnob = createdNode->getKnobByName(kTransformParamInvert);
if (cpInvertKnob) {
KnobBoolPtr isBool = toKnobBool(cpInvertKnob);
if (isBool) {
if (!linked) {
isBool->copyKnob(invertTransform.lock());
} else {
ignore_result(isBool->linkTo(invertTransform.lock()));
}
}
}
{
KnobIPtr knob = createdNode->getKnobByName(kTransformParamMotionBlur);
if (knob) {
KnobDoublePtr isType = toKnobDouble(knob);
if (isType) {
isType->copyKnob(motionBlur.lock());
}
}
}
{
KnobIPtr knob = createdNode->getKnobByName(kTransformParamShutter);
if (knob) {
KnobDoublePtr isType = toKnobDouble(knob);
if (isType) {
isType->copyKnob(shutter.lock());
}
}
}
{
KnobIPtr knob = createdNode->getKnobByName(kTransformParamShutterOffset);
if (knob) {
KnobChoicePtr isType = toKnobChoice(knob);
if (isType) {
isType->copyKnob(shutterOffset.lock());
}
}
}
{
KnobIPtr knob = createdNode->getKnobByName(kTransformParamCustomShutterOffset);
if (knob) {
KnobDoublePtr isType = toKnobDouble(knob);
if (isType) {
isType->copyKnob(customShutterOffset.lock());
}
}
}
} // exportTrackDataFromExportOptions