private void OnOpenedBlueprint(RdEditorModel unrealModel, BlueprintReference blueprintReference)
{
unrealModel.OpenBlueprint.Fire(blueprintReference);
}
private void ResetModel(Lifetime lf, IProtocol protocol)
{
myUnrealHost.PerformModelAction(riderModel =>
{
UE4Library.RegisterDeclaredTypesSerializers(riderModel.SerializationContext.Serializers);
riderModel.EditorId.SetValue(riderModel.EditorId.Value + 1);
});
var unrealModel = new RdEditorModel(lf, protocol);
UE4Library.RegisterDeclaredTypesSerializers(unrealModel.SerializationContext.Serializers);
unrealModel.AllowSetForegroundWindow.Set((lt, pid) =>
{
return(myUnrealHost.PerformModelAction(riderModel =>
riderModel.AllowSetForegroundWindow.Start(lt, pid)) as RdTask <bool>);
});
unrealModel.UnrealLog.Advise(lf,
logEvent =>
{
myUnrealHost.PerformModelAction(riderModel => { OnMessageReceived(riderModel, logEvent); });
});
unrealModel.OnBlueprintAdded.Advise(lf, blueprintClass =>
{
//todo
});
unrealModel.Play.Advise(lf, val =>
{
myUnrealHost.PerformModelAction(riderModel =>
{
if (PlayedFromRider)
{
return;
}
try
{
PlayedFromUnreal = true;
riderModel.Play.Set(val);
}
finally
{
PlayedFromUnreal = false;
}
});
});
unrealModel.PlayMode.Advise(lf, val =>
{
myUnrealHost.PerformModelAction(riderModel =>
{
if (PlayModeFromRider)
{
return;
}
try
{
PlayModeFromUnreal = true;
riderModel.PlayMode.Set(val);
}
finally
{
PlayModeFromUnreal = false;
}
});
});
myUnrealHost.PerformModelAction(riderModel =>
{
riderModel.FilterLinkCandidates.Set((lifetime, candidates) =>
RdTask <ILinkResponse[]> .Successful(candidates
.Select(request => myLinkResolver.ResolveLink(request, unrealModel.IsBlueprintPathName))
.AsArray()));
riderModel.IsMethodReference.Set((lifetime, methodReference) =>
{
var b = myEditorNavigator.IsMethodReference(methodReference);
return(RdTask <bool> .Successful(b));
});
riderModel.OpenBlueprint.Advise(lf, blueprintReference =>
OnOpenedBlueprint(unrealModel, blueprintReference));
riderModel.NavigateToClass.Advise(lf,
uClass => myEditorNavigator.NavigateToClass(uClass));
riderModel.NavigateToMethod.Advise(lf,
methodReference => myEditorNavigator.NavigateToMethod(methodReference));
riderModel.Play.Advise(lf, val =>
{
if (PlayedFromUnreal)
{
return;
}
try
{
PlayedFromRider = true;
unrealModel.Play.Set(val);
}
finally
{
PlayedFromRider = false;
}
});
riderModel.PlayMode.Advise(lf, val =>
{
if (PlayModeFromUnreal)
{
return;
}
try
{
PlayModeFromRider = true;
unrealModel.PlayMode.Set(val);
}
finally
{
PlayModeFromRider = false;
}
});
riderModel.FrameSkip.Advise(lf, skip =>
unrealModel.FrameSkip.Fire(skip));
});
if (myComponentLifetime.IsAlive)
{
myLocks.ExecuteOrQueueEx(myComponentLifetime, "setModel",
() => { myEditorModel.SetValue(unrealModel); });
}
}
