public void CollectionManager_Changed_ChangeUntypedObject()
{
var remoteMethodCall = new Mock<IDdpRemoteMethodCall>();
var collectionManager = new CollectionManager(remoteMethodCall.Object);
var objectToAdd = new TestDdpObject { integerField = 101, StringProperty = "addedTest"};
collectionManager.Added(new Added { Collection = "Test", Fields = JObject.FromObject(objectToAdd), Id = "1" });
var changed = new Changed
{
Cleared = null,
Collection = "Test",
Fields = new Dictionary<string, JToken>() {{"StringProperty", JToken.FromObject("changed!")}},
ID = "1"
};
collectionManager.Changed(changed);
var collection = collectionManager.GetCollection<TestDdpObject>("Test");
Assert.AreEqual(1, collection.Count);
objectToAdd.StringProperty = "changed!";
objectToAdd.Id = "1";
AssertDdpObjectsEqual(objectToAdd, collection.First());
}
public void ChangedHandler_HandleMessage_DeserializsAndCallsCollectionManager()
{
var connectionMock = new Mock<IDdpConnectionSender>();
var collectionMock = new Mock<ICollectionManager>();
var resultHandlerMock = new Mock<IResultHandler>();
var testObject = new SimpleDdpObject { IsTrue = false };
var added = new Changed { Collection = "Tests", Fields = null, ID = "1" };
var handler = new ChangedHandler();
handler.HandleMessage(connectionMock.Object, collectionMock.Object, resultHandlerMock.Object,
JsonConvert.SerializeObject(added));
collectionMock.Verify(collection => collection.Changed(It.IsAny<Changed>()), Times.Once());
}
public bool AddChangedToGoods(Goods g, Changed c)
{
try
{
using (TransactionScope scope = new TransactionScope())
{
g.ChangedSet.Add(c);
g.Quantity = g.Quantity + c.Value;
this.ObjectContext.SaveChanges(SaveOptions.None);
scope.Complete();
this.ObjectContext.AcceptAllChanges();
return true;
}
}
catch
{
}
return false;
}
protected void OnChanged() => Changed?.Invoke(this, EventArgs.Empty);
//Methods that checks if there are subscribers to an event, if there is, the event is raised
protected virtual void OnChanged(object sender, ListChangedEventArgs <T> args)
{
Changed?.Invoke(this, args);
}
public void NotifySinceSubobjectChanged() => Changed?.Invoke();
private void OnChildChanged(object sender, EventArgs e)
{
Changed.Raise(this);
}
public void TriggerScriptChangedEvent(Changed val)
{
if (ParentGroup != null && ParentGroup.Scene != null)
ParentGroup.Scene.EventManager.TriggerOnScriptChangedEvent(LocalId, (uint)val);
}
public void TriggerScriptChangedEvent(Changed val)
{
SceneObjectPart[] parts = m_parts.GetArray();
for (int i = 0; i < parts.Length; i++)
parts[i].TriggerScriptChangedEvent(val);
}
public void Reset()
{
SwitchEvaluator = null;
PublishToAzure30 = null;
Changed?.Invoke(this, EventArgs.Empty);
}
public void Save()
{
_service.SaveString(SuppressDialog.SwitchEvaluatorSetting, SuppressDialog.Category, SwitchEvaluator);
_service.SaveString(SuppressDialog.PublishToAzure30Setting, SuppressDialog.Category, PublishToAzure30);
Changed?.Invoke(this, EventArgs.Empty);
}
public void Load()
{
SwitchEvaluator = _service.LoadString(SuppressDialog.SwitchEvaluatorSetting, SuppressDialog.Category);
PublishToAzure30 = _service.LoadString(SuppressDialog.PublishToAzure30Setting, SuppressDialog.Category);
Changed?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Must be called to rebuild the theme.
/// </summary>
public void ThemeHasChanged()
{
Changed?.Invoke(this, EventArgs.Empty);
}
void OnDataSource_Changed(object sender, EventArgs e)
{
Update();
Changed.Raise(this);
}
private void nudHeight_ValueChanged(object sender, EventArgs e)
{
Changed?.Invoke();
}
// private helpers
private void invokeChanged()
{
Changed?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// MyGrid_Changed causes the grid to be redrawn by raising a changed event
/// </summary>
/// <param name="sender">the object that caused the change</param>
/// <param name="e">what needs to be redrawn</param>
private void MyGrid_Changed(object sender, EventArgs e)
{
Changed?.Invoke(this, e);
}
public PresentationDesignerForm(PresentationInfo aPresentationInfo)
{
m_PresentationInfo = aPresentationInfo;
m_Presentation = aPresentationInfo.CreatePresentationStub();
PresentationController.CreatePresentationController();
PresentationController.Instance.PresentationChanged = false;
PresentationChanged = new Changed(() =>
{
this.saveMenuButton.Enabled = PresentationController.Instance.PresentationChanged;
this.savePresentationToolButton.Enabled = PresentationController.Instance.PresentationChanged;
this.ChangedStatus.Visible = PresentationController.Instance.PresentationChanged;
this.ChangedStatus.Text = PresentationController.Instance.ChangedTextStatus;
});
PresentationController.Instance.OnChanged += PresentationChanged;
PresentationController.Instance.OnPresentationLockChanged += new PresentationLockChanged(Instance_OnPresentationLockChanged);
PresentationController.Instance.OnPresentationRemoved += new Changed(Instance_OnPresentationRemoved);
PresentationController.Instance.OnPresentationLockedExternally += new PresentationLockedExternally(Instance_OnPresentationLockedExternally);
PresentationController.Instance.OnPresentationUnlockedExternally += new PresentationUnlockedExternally(Instance_OnPresentationUnlockedExternally);
PresentationController.Instance.OnSlideSelectionChanged += new SlideSelectionChanged(Instance_OnSlideSelectionChanged);
PresentationController.Instance.OnOtherUserLockForShow += new SlideChanged(Instance_OnOtherUserLockForShow);
UndoService.CreateUndoService();
PresentationController.Instance.AssignPresentation(m_Presentation, m_PresentationInfo);
InitializeComponent();
RefreshTitle();
this.statusStrip.ContextMenuStrip = null;
this.ChangedStatus.Visible = false;
this.WindowState = FormWindowState.Maximized;
UndoService.Instance.OnHistoryChanged += new HistoryChanged(OnHistoryChanged);
identity = Thread.CurrentPrincipal as UserIdentity;
slideDiagram.SwitchPlayerMode(false);
toolStripEx2.Enabled = false;
PresentationController.Instance.RefreshLockingInfo();
LockingInfo li = ((PresentationInfoExt)m_PresentationInfo).LockingInfo;
if (li != null)
{
string info = String.Format(lockedByUser,
string.IsNullOrEmpty(li.UserIdentity.User.FullName) ? li.UserIdentity.User.Name : li.UserIdentity.User.FullName,
li.RequireLock == RequireLock.ForShow ? "для показа" : "для редактирования");
this.LockingStatus.Visible = true;
this.LockingStatus.Text = info;
if (li.RequireLock == RequireLock.ForShow)
{
layoutPreviewMenuButton.Enabled = false;
previewToolButton.Enabled = false;
}
}
if (layoutPreviewMenuButton.Enabled || previewToolButton.Enabled)
{
layoutPreviewMenuButton.Enabled = previewToolButton.Enabled = !LayoutController.Instance.IsShownByPlayer();
}
SlideGraphController.Instance.OnSlideHover += new EventHandler<SlideEventArgs>(Instance_OnSlideHover);
updateMenuButton.Enabled = !DesignerClient.Instance.IsStandAlone;
refreshDisplayMenuButton.Enabled = !DesignerClient.Instance.IsStandAlone;
refreshSlidesMenuButton.Enabled = !DesignerClient.Instance.IsStandAlone;
commonSourcesRefreshMenuButton.Enabled = !DesignerClient.Instance.IsStandAlone;
equipmentRefreshMenuButton.Enabled = !DesignerClient.Instance.IsStandAlone;
toXmlMenuButton.Enabled = !DesignerClient.Instance.IsStandAlone;
LayoutController.Instance.OnShownStatusChanged += new Action<bool>(Instance_OnShownStatusChanged);
layoutPreviewMenuButton.Visible = previewToolButton.Visible = !DesignerClient.Instance.IsStandAlone;
}
private void HandleUserCacheUpdatedEvent(CacheUpdateEvent cacheUpdateEvent)
{
Changed?.Invoke(cacheUpdateEvent);
}
public void TriggerScriptChangedEvent(Changed val)
{
if (m_parentGroup != null && m_parentGroup.Scene != null)
m_parentGroup.Scene.EventManager.TriggerOnScriptChangedEvent(this, (uint)val);
}
public void Clear()
{
s_undo.Clear();
s_redo.Clear();
Changed.Invoke(this, EventArgs.Empty);
}
private void OnChanged()
{
Changed?.Invoke();
}
/// <summary>
/// Handler for on changed events.
/// </summary>
/// <param name="resources">A collection of resources to pass to the event handler.</param>
protected virtual void OnChanged(Resource[] resources)
{
Changed?.Invoke(this, resources);
}
protected virtual void OnChanged(EventArgs e)
{
Changed?.Invoke(this, e);
}
private void ProjectSnapshotManager_Changed(object sender, ProjectChangeEventArgs args)
{
var convertedArgs = new OmniSharpProjectChangeEventArgs(args);
Changed?.Invoke(this, convertedArgs);
}
private void OnChanged()
{
var args = new EditorSettingsChangedEventArgs(Current);
Changed?.Invoke(this, args);
}
public void OnChanged(BindingChangedEventArgs e)
{
Changed?.Invoke(target, e);
}
/// <summary>
/// Inform the resource management, that this instance was modified
/// and trigger saving the current state to storage
/// </summary>
protected void RaiseResourceChanged()
{
// This is only null during boot, when the resource manager populates the object
Changed?.Invoke(this, EventArgs.Empty);
}
private static void OnStateChanged(Changed <RoomPlayer> changed)
{
PlayerChanged?.Invoke(changed.Behaviour);
}
public bool UpdateingGoodsWithChanged(Goods g, Changed c)
{
try
{
using (TransactionScope scope = new TransactionScope())
{
c.Value = c.GoodsItemSet.Sum(x => x.Quantity);
c.SumCost = c.GoodsItemSet.Sum(p => (decimal)p.Quantity * c.PieceCost);
this.ObjectContext.SaveChanges();
g.Quantity = g.Quantity + c.Value;
this.ObjectContext.SaveChanges();
scope.Complete();
this.ObjectContext.AcceptAllChanges();
return true;
}
}
catch
{
}
return false;
}
private void HandleUserCacheUpdatedEvent(CacheUpdateEvent cacheUpdateEvent)
{
//Logger.Trace("GitUserCache Updated {0}", cacheUpdateEvent.UpdatedTime);
Changed?.Invoke(cacheUpdateEvent);
}
public void CollectionManager_Changed_NotExist()
{
var collectionManager = new CollectionManager(null);
var changed = new Changed
{
Cleared = null,
Collection = "Test",
Fields = new Dictionary<string, JToken>() { { "StringProperty", JToken.FromObject("changed!") } },
ID = "1"
};
ExceptionAssert.Throws<InvalidOperationException>(() => collectionManager.Changed(changed));
}
protected void RaiseChanged()
{
Changed.Raise(this);
}
public void TriggerScriptChangedEvent(Changed val)
{
m_childParts.ForEachPart((SceneObjectPart part) => {
part.TriggerScriptChangedEvent(val);
});
}
internal void NotifyChanged()
{
Runtime.AssertMainThread();
Changed?.Invoke(this, EventArgs.Empty);
ParentCommandInfo?.NotifyChanged();
}
public void TriggerScriptChangedEvent(Changed val)
{
SceneObjectPart[] parts = this.GetParts();
foreach (SceneObjectPart part in parts)
part.TriggerScriptChangedEvent(val);
}
private void RaiseChanged()
{
Changed?.Invoke(this);
Workspace.RaiseChanged();
}
public void TriggerScriptChangedEvent(Changed val)
{
if (m_parentGroup != null && m_parentGroup.Scene != null)
{
m_parentGroup.Scene.EventManager.TriggerOnScriptChangedEvent(LocalId, (uint)val);
}
/*else
{
m_log.ErrorFormat("[SCENE]: Not triggering script changed event for '{0}' because {1}", this.Name, m_parentGroup == null ? "Group is null" : "Scene is null");
}
*/
}
internal void NotifyChanged()
{
Changed?.Invoke(this, EventArgs.Empty);
}
private void SendScriptEventToAllAttachments(Changed c)
{
IAttachmentsModule attMod = Scene.RequestModuleInterface<IAttachmentsModule>();
if (attMod != null)
attMod.SendScriptEventToAttachments(UUID, "changed", new Object[] {c});
}
/// <summary> /// Invoke the Changed event. /// </summary> public void InvokeChanged() => Changed?.Invoke(this, EventArgs.Empty);
public static void Show(MadAtlas atlas, string currentGUID, Changed changedCallback, ScriptableObject parent) {
//var window = ScriptableObject.CreateInstance<MadAtlasBrowser>();
var browser = EditorWindow.GetWindow<MadAtlasBrowser>(true, "Atlas Browser", true);
browser.atlas = atlas;
browser.changedCallback = changedCallback;
browser.selectedItemGUID = currentGUID;
browser.parent = parent;
}
protected virtual void OnChanged()
{
Changed?.Invoke(this, EventArgs.Empty);
}
public void TriggerScriptChangedEvent(Changed val)
{
foreach (SceneObjectPart part in ChildrenList)
{
part.TriggerScriptChangedEvent(val);
}
}
protected void OnChanged(SettingsChangedEventArgs args)
{
Changed?.Invoke(this, args);
}
