public void CreateNewEventTrigger()
{
if (this.CurrentContainer == null)
{
return;
}
SceneViewModel activeSceneViewModel = this.ActiveSceneViewModel;
SceneDocument document = activeSceneViewModel.Document;
ITriggerContainer currentContainer = this.CurrentContainer;
using (SceneEditTransaction editTransaction = document.CreateEditTransaction(StringTable.TriggerChangeUndoUnit))
{
IProjectContext projectContext = document.ProjectContext;
IType type = projectContext.GetType(currentContainer.TargetElementType);
if (type != null)
{
TriggerSourceInformation triggerSource = (TriggerSourceInformation)TriggersHelper.GetDefaultEvent((ITypeResolver)projectContext, type);
if (triggerSource != (TriggerSourceInformation)null)
{
TriggerBaseNode trigger = TriggersHelper.CreateTrigger(triggerSource, activeSceneViewModel);
if (trigger != null)
{
int index = currentContainer.VisualTriggers.Count;
if (this.selectedItem != null)
{
index = this.selectedItem != this.noneTrigger ? currentContainer.VisualTriggers.IndexOf(this.selectedItem.SceneNode) + 1 : 0;
}
currentContainer.VisualTriggers.Insert(index, trigger);
this.TriggerToBeSelected = trigger;
}
}
}
editTransaction.Commit();
}
}
public void Remove(SceneDocument document)
{
RelatedDocumentInfo relatedDocumentInfo = this[document];
this.documents.Remove(document);
relatedDocumentInfo.Unregister();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="document">Scene document.</param>
public SceneDocumentProxy(SceneDocument document)
: base(document, null)
{
base.name = defaultName;
this.document = document;
this.environment = document.EditorScene.Environment;
}
/// <summary>
/// Adds a new scene document.
/// </summary>
private void NewSceneDocument()
{
// Create document
sceneDocument = new SceneDocument(worldControl.Core);
// Create standard proxies
documentProxy = new SceneDocumentProxy(sceneDocument);
// Add new document to tree view
SceneTreeView.Nodes.Clear();
TreeNode sceneNode = AddTreeNode(null, documentProxy);
sceneNode.Expand();
// Assign nodes to proxies
documentProxy.TreeNode = sceneNode;
// Subscribe events
sceneDocument.OnPushUndo += new EventHandler(Document_OnPushUndo);
// Update toolbars
UpdateUndoRedoToolbarItems();
// Create default document
CreateDefaultDocument();
}
public Model(DesignerContext designerContext, SceneDocument document, DocumentCompositeNode node)
{
this.designerContext = designerContext;
this.document = document;
this.node = node;
this.state = EventsModel.State.Unknown;
}
private void RemoveHandlers(SceneDocument document)
{
if (!this.watchedDocuments.Contains(document))
{
return;
}
document.PostEditTransactionCompleted -= new EventHandler(this.OnEditTransactionCompleted);
document.PostEditTransactionUpdated -= new EventHandler(this.OnEditTransactionUpdated);
document.PostEditTransactionUndoRedo -= new EventHandler(this.OnEditTransactionCompleted);
document.TypesChanged -= new EventHandler(this.OnDocumentModelChanged);
document.RootNodeChanged -= new EventHandler(this.OnDocumentModelChanged);
IProjectContext projectContext = document.ProjectContext;
List <SceneDocument> list = (List <SceneDocument>)null;
if (this.watchedDocumentsForProjectContext.TryGetValue(projectContext, out list))
{
if (list.Contains(document))
{
list.Remove(document);
}
if (list.Count == 0)
{
this.watchedDocumentsForProjectContext.Remove(projectContext);
}
}
this.watchedDocuments.Remove(document);
}
public override void ResetToDefault()
{
if (!this.IsLocal)
{
return;
}
using (TemporaryCursor.SetWaitCursor())
{
SceneDocument sceneDocument = this.ProjectItem.Document as SceneDocument;
if (sceneDocument != null && this.ProjectItem.FileExists)
{
using (SceneEditTransaction editTransaction = sceneDocument.CreateEditTransaction(StringTable.UndoUnitResetDocumentToDefault))
{
((XamlDocument)sceneDocument.DocumentRoot).Text = this.originalDocumentProvider.Document.Text;
editTransaction.Commit();
}
}
else
{
if (this.ProjectItem.IsOpen)
{
this.ProjectItem.CloseDocument();
}
this.ProjectItem.CreateDocument(this.originalDocumentProvider.Document.Text);
}
}
}
private bool IsApplicationResourceContributor(SceneDocument sceneDocument, HashSet <SceneDocument> visitedDocuments, List <SceneDocument> designTimeResourceDocuments)
{
if (sceneDocument.ProjectDocumentType != ProjectDocumentType.Application && sceneDocument.ProjectDocumentType != ProjectDocumentType.ResourceDictionary)
{
return(false);
}
if (designTimeResourceDocuments.Contains(sceneDocument))
{
return(true);
}
if (visitedDocuments.Contains(sceneDocument))
{
return(false);
}
visitedDocuments.Add(sceneDocument);
List <SceneView> list = (List <SceneView>)null;
if (this.relatedViewsForDocument.TryGetValue(sceneDocument, out list))
{
foreach (SceneView sceneView in list)
{
if (!sceneView.IsClosing && !sceneView.IsEditingOutOfPlace && this.IsApplicationResourceContributor(sceneView.Document, visitedDocuments, designTimeResourceDocuments))
{
return(true);
}
}
}
return(false);
}
private void AddHandlers(SceneDocument document)
{
if (this.watchedDocuments.Contains(document))
{
return;
}
document.PostEditTransactionCompleted += new EventHandler(this.OnEditTransactionCompleted);
document.PostEditTransactionUpdated += new EventHandler(this.OnEditTransactionUpdated);
document.PostEditTransactionUndoRedo += new EventHandler(this.OnEditTransactionCompleted);
document.TypesChanged += new EventHandler(this.OnDocumentModelChanged);
document.RootNodeChanged += new EventHandler(this.OnDocumentModelChanged);
IProjectContext projectContext = document.ProjectContext;
List <SceneDocument> list = (List <SceneDocument>)null;
if (!this.watchedDocumentsForProjectContext.TryGetValue(projectContext, out list))
{
list = new List <SceneDocument>();
this.watchedDocumentsForProjectContext[projectContext] = list;
}
if (!list.Contains(document))
{
list.Add(document);
}
this.watchedDocuments.Add(document);
}
internal SceneEditTransaction(IExternalChanges externalChanges, SceneDocument document, IUndoTransaction undo)
{
this.document = document;
this.delayExternalChanges = externalChanges != null?externalChanges.DelayNotification() : (IDisposable)null;
this.undo = undo;
}
public RelatedDocumentInfo(SceneDocument document)
{
this.document = document;
this.damage = new DocumentNodeChangeList();
document.XamlDocument.RegisterChangeList(this.damage);
this.UpdateChangeStamp();
}
private void ApplyChangesInternal(SceneDocument sceneDocument, List <PathChange> documentChanges)
{
bool flag = true;
foreach (PathChange pathChange in documentChanges)
{
if (!pathChange.Change.BreakingChange)
{
flag = false;
break;
}
}
if (flag)
{
return;
}
SceneView sceneView = this.GetSceneView(sceneDocument);
string description = string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.SampleDataUpdateBindingsTransaction, new object[1]
{
(object)this.SampleData.Name
});
using (SceneEditTransaction editTransaction = sceneDocument.CreateEditTransaction(description))
{
using (sceneView.ViewModel.AnimationEditor.DeferKeyFraming())
{
foreach (PathChange pathChange in documentChanges)
{
pathChange.ApplyChange(sceneView.ViewModel);
}
}
editTransaction.Commit();
}
}
public RelatedDocumentInfo this[SceneDocument index]
{
get
{
return(this.documents[index]);
}
}
/// <summary>
/// Initiate document loading
/// </summary>
private void OpenDocument()
{
OpenFileDialog openDialog = new OpenFileDialog
{
Title = @"Open a " + defaultMapLoader.FileDescription,
Filter = $@"{defaultMapLoader.FileTypeName}|*{defaultMapLoader.FileExtensionName}"
};
openDialog.FileOk += (sender, e) =>
{
using (FileStream fileStream = (FileStream)openDialog.OpenFile())
{
try
{
SceneDocument newDocument = new SceneDocument();
defaultMapLoader.Import(fileStream, newDocument);
SceneDocument = newDocument;
SceneDocument.AbsoluteFileName = openDialog.FileName;
SceneDocument.OnDirty += (s, args) => toolbarSave.Enabled = args.IsDirty;
SetupEditorCaption();
ResetEditorState();
LoadUsedTexturesToGpu();
RenderViewports();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
};
openDialog.ShowDialog();
}
private IInstanceBuilderContext GetUnopenedDocumentContext(IDocumentRoot documentRoot)
{
SceneView sceneView;
if (!this.hiddenDocumentsViews.TryGetValue(documentRoot, out sceneView))
{
++this.isInitializingUnopenedView;
try
{
SceneDocument sceneDocument = ViewRootResolver.GetSceneDocument(this.designerContext, documentRoot);
if (sceneDocument != null)
{
sceneView = (SceneView)sceneDocument.CreateDefaultView();
this.hiddenDocumentsViews[documentRoot] = sceneView;
sceneView.Initialize();
}
}
finally
{
--this.isInitializingUnopenedView;
}
UIThreadDispatcher.Instance.BeginInvoke(DispatcherPriority.Send, (Action)(() => this.NotifyViewCreated(sceneView)));
}
if (sceneView == null)
{
return((IInstanceBuilderContext)null);
}
return(sceneView.InstanceBuilderContext);
}
protected override void Work()
{
if (this.IsKilled || !this.ShouldProcessCurrentDocument)
{
return;
}
SceneDocument sceneDocument = this.GetSceneDocument(this.CurrentDocument, true);
if (sceneDocument == null)
{
return;
}
if (this.IsCollectingChanges)
{
if (this.pass == 0)
{
this.documentProcessor.ProcessDocument(sceneDocument, DataBindingProcessingOptions.FirstPass);
}
else
{
this.documentProcessor.ProcessDocument(sceneDocument, DataBindingProcessingOptions.SecondPass);
}
}
if (!this.IsApplyingChanges || !this.allChangesCollected && this.IsCollectingChanges)
{
return;
}
this.documentProcessor.ApplyChanges(sceneDocument);
this.documentProcessor.InvalidateNodes(sceneDocument);
}
public void ProcessDocument(SceneDocument sceneDocument, DataBindingProcessingOptions options)
{
if (sceneDocument.DocumentRoot == null || sceneDocument.DocumentRoot.RootNode == null)
{
return;
}
this.EnsureInitialized(sceneDocument.ProjectContext);
this.DocumentRoot = sceneDocument.DocumentRoot;
if (!this.documenNamedElementDataContexts.TryGetValue(this.DocumentRoot, out this.namedElementDataContexts))
{
this.namedElementDataContexts = new Dictionary <DocumentCompositeNode, DataBindingProcessingContext>();
this.documenNamedElementDataContexts[this.DocumentRoot] = this.namedElementDataContexts;
}
if ((options & DataBindingProcessingOptions.FirstPass) == DataBindingProcessingOptions.FirstPass)
{
DataBindingProcessingContext context = new DataBindingProcessingContext(sceneDocument.DocumentRoot.RootNode, (DataBindingProcessingContext)null);
context.DataContext = this.InitDataContext(context);
this.ProcessDocumentNode(context);
this.ProcessPendingBindings();
}
if ((options & DataBindingProcessingOptions.SecondPass) != DataBindingProcessingOptions.SecondPass)
{
return;
}
this.ProcessPendingBindings();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="document">Scene document.</param>
/// <param name="entity">Entity to proxy.</param>
public EntityProxy(SceneDocument document, DynamicEntity entity)
: base(document, null)
{
base.name = defaultName;
this.entity = entity;
this.entityProxy = this;
}
public void Export(FileStream stream, SceneDocument document)
{
StreamWriter streamWriter = new StreamWriter(stream);
JsonWriter writer = new JsonTextWriter(streamWriter);
writer.Formatting = Formatting.Indented;
CustomOperation mapObjectJsonWriter = GetJsonOperation(writer);
// Write map to Json file
writer.WriteStartObject();
// write map header
writer.WritePropertyName("name");
writer.WriteValue(document.MapName);
writer.WritePropertyName("mapversion");
writer.WriteValue(1);
// write map objects
writer.WritePropertyName("mapobjects");
writer.WriteStartArray();
foreach (MapObject mapObject in document)
{
mapObject.PerformOperation(mapObjectJsonWriter);
}
writer.WriteEndArray();
writer.WriteEndObject();
writer.Close();
}
protected override void ProcessDocument(SceneDocument document)
{
if (document.ProjectContext != this.fontFamilyChangeModel.ProjectContext)
{
return;
}
base.ProcessDocument(document);
}
public void AddReferencesFile(SceneDocument document)
{
if (this.scenesWithReferences.Contains(document.DocumentReference.Path))
{
return;
}
this.scenesWithReferences.Add(document.DocumentReference.Path);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="document">Scene document.</param>
/// <param name="entity">Entity owning this proxy.</param>
/// <param name="model">Model to proxy.</param>
public DaggerfallModelProxy(SceneDocument document, EntityProxy entity, DaggerfallModelComponent model)
: base(document, entity)
{
base.name = defaultName;
this.model = model;
// Add to parent entity
base.Entity.Components.Add(model);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="document">Scene document.</param>
/// <param name="entity">Entity owning this proxy.</param>
/// <param name="block">Block to proxy.</param>
public DaggerfallBlockProxy(SceneDocument document, EntityProxy entity, DaggerfallBlockComponent block)
: base(document, entity)
{
base.name = defaultName;
this.block = block;
// Add to parent entity
base.Entity.Components.Add(block);
}
public void UpdateInvalidRelatedDocuments(SceneView view)
{
if (view.IsClosing)
{
return;
}
SceneDocument applicationSceneDocument = view.Document.ApplicationSceneDocument;
if (applicationSceneDocument == view.Document && !view.IsEditingOutOfPlace)
{
return;
}
List <SceneView> orderedRelatedViews = this.GetOrderedRelatedViews(view);
orderedRelatedViews.RemoveAll((Predicate <SceneView>)(v =>
{
if (v != view && !v.IsEditingOutOfPlace && !v.IsClosing)
{
return(!v.ViewNodeManager.IsRootInvalid);
}
return(true);
}));
if (applicationSceneDocument != null)
{
if (!this.primaryViewsForDocument.ContainsKey(applicationSceneDocument))
{
this.designerContext.ViewRootResolver.GetViewContext((IDocumentRoot)applicationSceneDocument.XamlDocument);
}
List <SceneView> list;
if (this.primaryViewsForDocument.TryGetValue(applicationSceneDocument, out list))
{
foreach (SceneView sceneView in list)
{
if (!sceneView.IsClosing && !sceneView.IsEditingOutOfPlace && sceneView.ViewNodeManager.IsRootInvalid)
{
sceneView.Update(true);
}
}
}
}
for (int index = 0; index < orderedRelatedViews.Count; ++index)
{
SceneView sceneView = orderedRelatedViews[index];
if (!sceneView.IsClosing && sceneView.ViewNodeManager.IsRootInvalid)
{
sceneView.Update(false);
}
}
for (int index = 0; index < orderedRelatedViews.Count; ++index)
{
SceneView sceneView = orderedRelatedViews[index];
if (!sceneView.IsClosing)
{
sceneView.Update(true);
}
}
}
private void AddDocumentConverters(SceneDocument document, List <ValueConverterModel> converters, List <SceneDocument> visitedDocuments)
{
if (document == null || document.DocumentRoot == null || (document.DocumentRoot.RootNode == null || visitedDocuments.Contains(document)))
{
return;
}
visitedDocuments.Add(document);
this.AddSceneNodeValueConverters(this.ViewModel.GetViewModel(document.DocumentRoot, false).GetSceneNode(document.DocumentRoot.RootNode), converters, visitedDocuments);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="document">Scene document.</param>
/// <param name="entity">Entity owning this proxy.</param>
/// <param name="quadTerrain">Quad terrain to proxy.</param>
public QuadTerrainProxy(SceneDocument document, EntityProxy entity, QuadTerrainComponent quadTerrain)
: base(document, entity)
{
base.name = defaultName;
this.quadTerrain = quadTerrain;
// Add to entity
base.Entity.Components.Add(quadTerrain);
}
protected virtual void CloseDocument(SceneDocument document)
{
try
{
this.DesignerContext.DocumentService.CloseDocument((IDocument)document);
}
catch (NotSupportedException ex)
{
}
}
public PropertyEditingHelper(SceneDocument activeDocument, UIElement host)
{
this.activeDocument = activeDocument;
this.host = host;
if (this.host == null)
{
return;
}
this.AddCommandBindings(host, SupportedPropertyCommands.All);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="document">Scene document.</param>
/// <param name="entity">Entity owning this proxy.</param>
public BaseEditorProxy(SceneDocument document, EntityProxy entity)
{
// Save references
this.document = document;
this.entityProxy = entity;
if (entity != null)
{
this.entity = entity.Entity;
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="document">Scene document.</param>
/// <param name="entity">Parent entity</param>
public BasePrimitiveProxy(SceneDocument document, EntityProxy entity)
: base(document, entity)
{
primitive = new GeometricPrimitiveComponent(document.EditorScene.Core);
this.ColorRGB = System.Drawing.Color.White;
this.ColorW = 0.0f;
UpdatePrimitive();
base.Entity.Components.Add(primitive);
}
