public void RemovePropertyStringTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
Property prop1 = new StringProperty("test", "orange");
Property prop2 = new StringProperty("two", "number");
collection.Add(prop1);
collection.Add(prop2);
collection.PropertyRemoved += (s, e) =>
{
Assert.AreSame(prop1, e.Property);
Assert.AreEqual(1, collection.Count);
Assert.IsFalse(collection.Contains("test"));
Assert.IsTrue(collection.Contains("two"));
Assert.IsFalse(collection.Contains(prop1));
Assert.IsTrue(collection.Contains(prop2));
};
_eventsFired = EventFlags.None;
collection.Remove("test");
Assert.AreEqual(EventFlags.PropertyRemoved | EventFlags.Modified, _eventsFired);
}
public void RemoveProperty()
{
Assert.AreEqual(0, _pool.CustomProperties.Count());
Property prop1 = new StringProperty("author", "Justin");
Property prop2 = new StringProperty("date", "May");
_pool.CustomProperties.Add(prop1);
_pool.CustomProperties.Add(prop2);
Assert.AreEqual(2, _pool.CustomProperties.Count());
_eventsFired = EventFlags.None;
_pool.CustomProperties.PropertyRemoved += (s, e) =>
{
Assert.AreEqual(prop1, e.Property);
};
_pool.CustomProperties.Remove("author");
Assert.AreEqual(EventFlags.Modified | EventFlags.PropertyRemoved, _eventsFired);
Assert.AreEqual(1, _pool.CustomProperties.Count());
Assert.Null(_pool.LookupProperty("author"));
Assert.AreEqual(PropertyCategory.Custom, _pool.LookupPropertyCategory("date"));
Assert.AreEqual(prop2, _pool.LookupProperty("date"));
}
///////////////////////////////////////////////////////////////////////
//
// NOTE: For use by InteractiveOps.Commands._break() and
// Engine.CheckBreakpoints() only.
//
internal InteractiveLoopData(
ReturnCode code,
BreakpointType breakpointType,
string breakpointName,
IToken token,
ITraceInfo traceInfo,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags,
HeaderFlags headerFlags,
IClientData clientData,
ArgumentList arguments
)
: this()
{
this.code = code;
this.breakpointType = breakpointType;
this.breakpointName = breakpointName;
this.token = token;
this.traceInfo = traceInfo;
this.engineFlags = engineFlags;
this.substitutionFlags = substitutionFlags;
this.eventFlags = eventFlags;
this.expressionFlags = expressionFlags;
this.headerFlags = headerFlags;
this.clientData = clientData;
this.arguments = arguments;
}
///////////////////////////////////////////////////////////////////////
private static ReturnCode ProcessEvents(
Interpreter interpreter,
EventFlags eventFlags,
EventPriority priority,
int limit,
bool stopOnError,
bool errorOnEmpty,
ref int eventCount,
ref Result result
)
{
if (interpreter != null)
{
IEventManager eventManager = interpreter.EventManager;
if (ManagerIsOk(eventManager))
{
return(eventManager.ProcessEvents(
eventFlags, priority, limit, stopOnError, errorOnEmpty,
ref eventCount, ref result));
}
else
{
result = "event manager not available";
}
}
else
{
result = "invalid interpreter";
}
return(ReturnCode.Error);
}
public void RenamePropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
StringProperty prop = new StringProperty("test", "orange");
collection.PropertyRenamed += (s, e) =>
{
Assert.AreEqual("test", e.OldName);
Assert.AreEqual("two", e.NewName);
Assert.AreEqual(1, collection.Count);
Assert.IsFalse(collection.Contains("test"));
Assert.IsTrue(collection.Contains("two"));
Assert.IsTrue(collection.Contains(prop));
};
collection.Add(prop);
_eventsFired = EventFlags.None;
prop.Name = "two";
Assert.AreEqual(EventFlags.PropertyRenamed | EventFlags.Modified, _eventsFired);
}
public void ModifyTileTextureDirect()
{
Texture2D tex1 = RandomTexture(16, 16);
Texture2D tex2 = RandomTexture(16, 16);
Assert.IsFalse(TexturesEqual(tex1, tex2));
int id = _pool.AddTile(tex1);
_eventsFired = EventFlags.None;
_pool.TileModified += (s, e) =>
{
Assert.AreEqual(_pool, e.Tile.Pool);
Assert.AreEqual(id, e.Tile.Uid);
Assert.IsTrue(TexturesEqual(tex2, e.Tile.Pool.GetTileTexture(id)));
};
byte[] data = new byte[16 * 16 * 4];
tex2.GetData(data);
Tile tile = _pool.GetTile(id);
tile.Update(data);
Assert.AreEqual(EventFlags.Modified | EventFlags.TileModified, _eventsFired);
Assert.AreEqual(1, _registry.TileCount);
Assert.AreEqual(1, _pool.Count);
}
public void ClearPropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
Property prop1 = new StringProperty("test", "orange");
Property prop2 = new StringProperty("two", "number");
collection.Add(prop1);
collection.Add(prop2);
int rmCount = 0;
collection.PropertyRemoved += (s, e) =>
{
rmCount++;
};
_eventsFired = EventFlags.None;
collection.Clear();
Assert.AreEqual(EventFlags.PropertyRemoved | EventFlags.Modified, _eventsFired);
Assert.AreEqual(2, rmCount);
Assert.AreEqual(0, collection.Count);
}
internal AsynchronousContext(
int threadId,
EngineMode engineMode,
Interpreter interpreter,
string text,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags,
AsynchronousCallback callback,
IClientData clientData
)
{
this.threadId = threadId;
this.engineMode = engineMode;
this.interpreter = interpreter;
this.text = text;
this.engineFlags = engineFlags;
this.substitutionFlags = substitutionFlags;
this.eventFlags = eventFlags;
this.expressionFlags = expressionFlags;
this.callback = callback;
this.clientData = clientData;
}
public void ModifyPropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
StringProperty prop = new StringProperty("test", "orange");
collection.PropertyModified += (s, e) =>
{
Assert.AreSame(prop, e.Property);
Assert.AreEqual(1, collection.Count);
Assert.IsTrue(collection.Contains("test"));
Assert.IsTrue(collection.Contains(prop));
Assert.AreEqual("blue", e.Property.ToString());
};
collection.Add(prop);
_eventsFired = EventFlags.None;
prop.Value = "blue";
Assert.AreEqual(EventFlags.PropertyModified | EventFlags.Modified, _eventsFired);
}
/// <summary>
/// Dispatch the event as described in the specification.
/// http://www.w3.org/TR/DOM-Level-3-Events/
/// </summary>
/// <param name="target">The target of the event.</param>
/// <returns>A boolean if the event has been cancelled.</returns>
internal Boolean Dispatch(IEventTarget target)
{
_flags |= EventFlags.Dispatch;
_target = target;
var eventPath = new List <IEventTarget>();
if (target is Node parent)
{
while ((parent = parent.Parent !) != null)
{
eventPath.Add(parent);
}
}
_phase = EventPhase.Capturing;
DispatchAt(eventPath.Reverse <IEventTarget>());
_phase = EventPhase.AtTarget;
if ((_flags & EventFlags.StopPropagation) != EventFlags.StopPropagation)
{
CallListeners(target);
}
if (_bubbles)
{
_phase = EventPhase.Bubbling;
DispatchAt(eventPath);
}
_flags &= ~EventFlags.Dispatch;
_phase = EventPhase.None;
_current = null !;
return((_flags & EventFlags.Canceled) == EventFlags.Canceled);
}
public void Cancel()
{
if (_cancelable)
{
_flags |= EventFlags.Canceled;
}
}
public void OnMouseMove(Vec mousePos, Vec mouseMove, EventFlags flags)
{
var absPos = _mapView.PxToTile(mousePos);
if (!_level.InBoundary(absPos) || _controller.FoV.Visibility[absPos] == 0 || _controller.GameOver)
{
OnSelected?.Invoke(null);
_path = null;
_mapView.RenderMap(_controller);
return;
}
var list = _level.GetEntities(absPos);
foreach (var e in list)
{
if (_controller.FoV.ShowLocation(e) != null)
{
OnSelected?.Invoke(e);
}
}
_path = _aStar.Run(_controller.Player.Pos, absPos);
_mapView.RenderMap(_controller);
}
/*
* private void RenderPath()
* {
* if (_path == null)
* return;
*
* foreach (var absPos in _path)
* {
* var relPos = absPos - _relToAbs;
* if (!Rect.Size.Contains(relPos))
* continue;
*
* var s = Data[relPos];
* s.TextColor.Add(_pathColor);
* s.BackgroundColor.Add(_pathColor);
* Data[relPos] = s;
* }
* }
*/
public void OnMouseEvent(Vec mousePos, EventFlags flags)
{
if (flags.HasFlag(EventFlags.RightButton) && flags.HasFlag(EventFlags.MouseEventPress) && _path != null)
{
_controller.Path = _path.ToList();
}
}
private void AttachEvents(Layer layer)
{
layer.Modified += (s, e) => { _eventsFired |= EventFlags.Modified; };
layer.NameChanged += (s, e) => { _eventsFired |= EventFlags.NameChanged; };
layer.OpacityChanged += (s, e) => { _eventsFired |= EventFlags.OpacityChanged; };
layer.VisibilityChanged += (s, e) => { _eventsFired |= EventFlags.VisibilityChanged; };
}
///////////////////////////////////////////////////////////////////////
public static IScript Create(
string name,
string group,
string description,
string type,
string text,
string fileName,
int startLine,
int endLine,
bool viaSource,
DateTime timeStamp,
EngineMode engineMode,
ScriptFlags scriptFlags,
EngineFlags engineFlags,
SubstitutionFlags substitutionFlags,
EventFlags eventFlags,
ExpressionFlags expressionFlags,
IClientData clientData
)
{
return(PrivateCreate(
Guid.Empty, name, group, description, type, text, fileName,
startLine, endLine, viaSource,
#if XML
XmlBlockType.None, timeStamp, null, null,
#endif
engineMode, scriptFlags, engineFlags, substitutionFlags,
eventFlags, expressionFlags, clientData));
}
public void OnMouseEvent(Vec mousePos, EventFlags flags)
{
if (flags.HasFlag(EventFlags.LeftButton) && flags.HasFlag(EventFlags.MouseEventRelease))
{
ShowEquipMenu();
}
}
private void AttachEvents(TileGridLayer layer)
{
layer.Modified += (s, e) => { _eventsFired |= EventFlags.Modified; };
layer.LayerSizeChanged += (s, e) => { _eventsFired |= EventFlags.LayerSizeChanged; };
layer.TileAdded += (s, e) => { _eventsFired |= EventFlags.TileAdded; };
layer.TileRemoved += (s, e) => { _eventsFired |= EventFlags.TileRemoved; };
layer.TileCleared += (s, e) => { _eventsFired |= EventFlags.TileCleared; };
}
private void AttachEvents(PropertyCollection collection)
{
collection.PropertyAdded += (s, e) => { _eventsFired |= EventFlags.PropertyAdded; };
collection.PropertyRemoved += (s, e) => { _eventsFired |= EventFlags.PropertyRemoved; };
collection.PropertyModified += (s, e) => { _eventsFired |= EventFlags.PropertyModified; };
collection.PropertyRenamed += (s, e) => { _eventsFired |= EventFlags.PropertyRenamed; };
collection.Modified += (s, e) => { _eventsFired |= EventFlags.Modified; };
}
public void SubscribeUserPresence(string sessionId, string userId, EventFlags evtFlags)
{
this.Invoke("SubscribeUserPresence", new object[] {
sessionId,
userId,
evtFlags
});
}
internal EventRow(
EventFlags flags,
uint name,
uint eventType)
{
this.Flags = flags;
this.Name = name;
this.EventType = eventType;
}
/// <summary>
/// イベントフラグを検証する
/// </summary>
/// <param name="flag">フラグ</param>
/// <returns></returns>
public bool CheckRaizeEventFlag(
EventFlags flag
)
{
EventFlags flags = (EventFlags)
this._EventInfos[(int)EventInfoNo.RaiseEventFlags];
return(flags.CheckManagementFlags(flag));
}
internal EventRow(
EventFlags flags,
uint name,
uint eventType)
{
this.Flags = flags;
this.Name = name;
this.EventType = eventType;
}
/// <summary>
/// イベントフラグをリセットする
/// </summary>
/// <param name="flag">フラグ</param>
/// <returns></returns>
public EventFlags ResetRaizeEventFlag(
EventFlags flag
)
{
EventFlags flags = (EventFlags)
this._EventInfos[(int)EventInfoNo.RaiseEventFlags];
return((EventFlags)flags.ResetManagementFlags(flag));
}
public static EventRec Create(string name, EventFlags flags, int priority)
{
EventRec result = new EventRec();
result.Name = name;
result.Flags = flags;
result.Priority = priority;
return(result);
}
public Event(Event data)
{
type = data.type;
time = data.time;
param1 = data.param1;
param2 = data.param2;
x = data.x;
y = data.y;
}
public void OnMouseMove(Vec mousePos, Vec mouseMove, EventFlags flags)
{
var index = (mousePos.Y - HEADER_HEIGHT) / LINE_HEIGHT;
if (index >= 0 && index < Set.Count && _selectedIndex != index)
{
_selectedIndex = index;
Dirty = true;
}
}
public void OnMouseEvent(Vec mousePos, EventFlags flags)
{
if (flags.HasFlag(EventFlags.LeftButton) && flags.HasFlag(EventFlags.MouseEventRelease))
{
if (Use())
{
OnClose?.Invoke();
}
}
}
public void TestSetup()
{
_eventsFired = EventFlags.None;
_registry = new TileRegistry(_service.GraphicsDevice);
_pool = new TilePool("pool", _registry, 16, 16);
Texture2D tex1 = new Texture2D(_service.GraphicsDevice, 16, 16);
Texture2D tex2 = new Texture2D(_service.GraphicsDevice, 16, 16);
_tile1 = _pool.GetTile(_pool.AddTile(tex1));
_tile2 = _pool.GetTile(_pool.AddTile(tex2));
}
/// <remarks/>
public void SubscribeUserPresenceAsync(string sessionId, string userId, EventFlags evtFlags, object userState)
{
if ((this.SubscribeUserPresenceOperationCompleted == null))
{
this.SubscribeUserPresenceOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSubscribeUserPresenceOperationCompleted);
}
this.InvokeAsync("SubscribeUserPresence", new object[] {
sessionId,
userId,
evtFlags
}, this.SubscribeUserPresenceOperationCompleted, userState);
}
public void OnKeyPress(char keyCode, EventFlags flags)
{
if (keyCode == (char)13) // Enter
{
Use();
OnClose?.Invoke();
}
else if (keyCode == (char)27) // Escape
{
OnClose?.Invoke();
}
}
public void OnArrowPress(Vec move, EventFlags flags)
{
_selectedRow += move.Y;
if (_selectedRow < 0)
{
_selectedRow = Math.Max(Inventory.SlotNames.Length - 1, 0);
}
if (_selectedRow >= Inventory.SlotNames.Length)
{
_selectedRow = 0;
}
Dirty = true;
}
public Event(TypeNode declaringType, AttributeList attributes, EventFlags flags, Identifier name,
Method handlerAdder, Method handlerCaller, Method handlerRemover, TypeNode handlerType)
: base(declaringType, attributes, name, NodeType.Event)
{
this.Flags = flags;
this.HandlerAdder = handlerAdder;
this.HandlerCaller = handlerCaller;
this.HandlerRemover = handlerRemover;
this.HandlerType = handlerType;
}
public void ModifyPropertyValue()
{
Assert.AreEqual(0, _pool.CustomProperties.Count());
StringProperty prop = new StringProperty("author", "Justin");
_pool.CustomProperties.Add(prop);
_eventsFired = EventFlags.None;
_pool.CustomProperties.PropertyModified += (s, e) =>
{
Assert.AreEqual(prop, e.Property);
Assert.AreEqual("Andy", e.Property.ToString());
};
prop.Value = "Andy";
Assert.AreEqual(EventFlags.Modified | EventFlags.PropertyModified, _eventsFired);
Assert.AreEqual(1, _pool.CustomProperties.Count());
Assert.AreEqual(PropertyCategory.Custom, _pool.LookupPropertyCategory("author"));
Assert.AreEqual(prop, _pool.LookupProperty("author"));
}
public void ModifyTileTextureDirect()
{
Texture2D tex1 = RandomTexture(16, 16);
Texture2D tex2 = RandomTexture(16, 16);
Assert.IsFalse(TexturesEqual(tex1, tex2));
int id = _pool.AddTile(tex1);
_eventsFired = EventFlags.None;
_pool.TileModified += (s, e) =>
{
Assert.AreEqual(_pool, e.Tile.Pool);
Assert.AreEqual(id, e.Tile.Uid);
Assert.IsTrue(TexturesEqual(tex2, e.Tile.Pool.GetTileTexture(id)));
};
byte[] data = new byte[16 * 16 * 4];
tex2.GetData(data);
Tile tile = _pool.GetTile(id);
tile.Update(data);
Assert.AreEqual(EventFlags.Modified | EventFlags.TileModified, _eventsFired);
Assert.AreEqual(1, _registry.TileCount);
Assert.AreEqual(1, _pool.Count);
}
public void RemoveTile()
{
Texture2D tex = new Texture2D(_service.GraphicsDevice, 16, 16);
int id = _pool.AddTile(tex);
_eventsFired = EventFlags.None;
_pool.TileRemoved += (s, e) =>
{
Assert.AreEqual(_pool, e.Tile.Pool);
Assert.AreEqual(id, e.Tile.Uid);
Assert.AreEqual(tex.Width, e.Tile.Width);
Assert.AreEqual(tex.Height, e.Tile.Height);
};
_pool.RemoveTile(id);
Assert.AreEqual(EventFlags.Modified | EventFlags.TileRemoved, _eventsFired);
Assert.AreEqual(0, _registry.TileCount);
Assert.AreEqual(0, _pool.Count);
}
public void Send(EventFlags eventFlags)
{
AddRequiredProperties();
int gdEventFlags = EventFlagIndexable;
if (eventFlags == EventFlags.Historical)
gdEventFlags |= EventFlagHistorical;
try
{
_gdsEvent.Send(gdEventFlags);
}
catch (COMException e)
{
throw new GoogleDesktopException(e);
}
}
/// <summary>
/// Sets the current set of events sunk by a given element. These events will
/// be fired to the nearest {@link EventListener} specified on any of the
/// element's parents.
/// </summary>
/// <param name="elem">the element whose events are to be retrieved</param>
/// <param name="eventBits">
/// a bitfield describing the events sunk on this element (its possible values
/// are described in {@link Event})
/// </param>
public static void SinkEvents(Element elem, EventFlags eventBits)
{
// impl.sinkEvents(elem, eventBits);
}
/// <summary>
/// Dispatch the event as described in the specification.
/// http://www.w3.org/TR/DOM-Level-3-Events/
/// </summary>
/// <param name="target">The target of the event.</param>
/// <returns>A boolean if the event has been cancelled.</returns>
internal Boolean Dispatch(IEventTarget target)
{
_flags |= EventFlags.Dispatch;
_target = target;
var eventPath = new List<IEventTarget>();
var parent = target as Node;
if (parent != null)
{
while ((parent = parent.Parent) != null)
{
eventPath.Add(parent);
}
}
_phase = EventPhase.Capturing;
DispatchAt(eventPath.Reverse<IEventTarget>());
_phase = EventPhase.AtTarget;
if ((_flags & EventFlags.StopPropagation) != EventFlags.StopPropagation)
{
CallListeners(target);
}
if (_bubbles)
{
_phase = EventPhase.Bubbling;
DispatchAt(eventPath);
}
_flags &= ~EventFlags.Dispatch;
_phase = EventPhase.None;
_current = null;
return (_flags & EventFlags.Canceled) == EventFlags.Canceled;
}
public void TestSetup()
{
_eventsFired = EventFlags.None;
_registry = new TileRegistry(_service.GraphicsDevice);
_pool = new TilePool("pool", _registry, 16, 16);
Texture2D tex1 = new Texture2D(_service.GraphicsDevice, 16, 16);
Texture2D tex2 = new Texture2D(_service.GraphicsDevice, 16, 16);
_tile1 = _pool.GetTile(_pool.AddTile(tex1));
_tile2 = _pool.GetTile(_pool.AddTile(tex2));
}
private void AttachEvents(TileGridLayer layer)
{
layer.Modified += (s, e) => { _eventsFired |= EventFlags.Modified; };
layer.LayerSizeChanged += (s, e) => { _eventsFired |= EventFlags.LayerSizeChanged; };
layer.TileAdded += (s, e) => { _eventsFired |= EventFlags.TileAdded; };
layer.TileRemoved += (s, e) => { _eventsFired |= EventFlags.TileRemoved; };
layer.TileCleared += (s, e) => { _eventsFired |= EventFlags.TileCleared; };
}
public void ClearPropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
Property prop1 = new StringProperty("test", "orange");
Property prop2 = new StringProperty("two", "number");
collection.Add(prop1);
collection.Add(prop2);
int rmCount = 0;
collection.PropertyRemoved += (s, e) =>
{
rmCount++;
};
_eventsFired = EventFlags.None;
collection.Clear();
Assert.AreEqual(EventFlags.PropertyRemoved | EventFlags.Modified, _eventsFired);
Assert.AreEqual(2, rmCount);
Assert.AreEqual(0, collection.Count);
}
private void AttachEvents(PropertyCollection collection)
{
collection.PropertyAdded += (s, e) => { _eventsFired |= EventFlags.PropertyAdded; };
collection.PropertyRemoved += (s, e) => { _eventsFired |= EventFlags.PropertyRemoved; };
collection.PropertyModified += (s, e) => { _eventsFired |= EventFlags.PropertyModified; };
collection.PropertyRenamed += (s, e) => { _eventsFired |= EventFlags.PropertyRenamed; };
collection.Modified += (s, e) => { _eventsFired |= EventFlags.Modified; };
}
public void TestSetup()
{
_eventsFired = EventFlags.None;
}
public void RenamePropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
StringProperty prop = new StringProperty("test", "orange");
collection.PropertyRenamed += (s, e) =>
{
Assert.AreEqual("test", e.OldName);
Assert.AreEqual("two", e.NewName);
Assert.AreEqual(1, collection.Count);
Assert.IsFalse(collection.Contains("test"));
Assert.IsTrue(collection.Contains("two"));
Assert.IsTrue(collection.Contains(prop));
};
collection.Add(prop);
_eventsFired = EventFlags.None;
prop.Name = "two";
Assert.AreEqual(EventFlags.PropertyRenamed | EventFlags.Modified, _eventsFired);
}
public void Init(String type, Boolean bubbles, Boolean cancelable)
{
_flags |= EventFlags.Initialized;
if ((_flags & EventFlags.Dispatch) != EventFlags.Dispatch)
{
_flags &= ~(EventFlags.StopPropagation | EventFlags.StopImmediatePropagation | EventFlags.Canceled);
IsTrusted = false;
_target = null;
_type = type;
_bubbles = bubbles;
_cancelable = cancelable;
}
}
private void AttachEvents(TileStack stack)
{
stack.Modified += (s, e) => { _eventsFired |= EventFlags.Modified; };
}
/// <summary>
/// Creates a new event.
/// </summary>
public Event()
{
_flags = EventFlags.None;
_phase = EventPhase.None;
_time = DateTime.Now;
}
public void TestSetup()
{
_eventsFired = EventFlags.None;
_registry = new TileRegistry(_service.GraphicsDevice);
_pool = new TilePool("pool", _registry, 16, 16);
}
private static extern UInt32 timeSetEvent(UInt32 uDelay, UInt32 uResolution, TimerCallback lpTimeProc,
UIntPtr dwUser, EventFlags Flags);
private void AttachEvents(Tile tile)
{
tile.Modified += (s, e) => { _eventsFired |= EventFlags.Modified; };
tile.TextureModified += (s, e) => { _eventsFired |= EventFlags.TextureModified; };
}
public void RenameProperty()
{
Assert.AreEqual(0, _pool.CustomProperties.Count());
StringProperty prop = new StringProperty("author", "Justin");
_pool.CustomProperties.Add(prop);
_eventsFired = EventFlags.None;
_pool.CustomProperties.PropertyRenamed += (s, e) =>
{
Assert.AreEqual("author", e.OldName);
Assert.AreEqual("developer", e.NewName);
};
prop.Name = "developer";
Assert.AreEqual(EventFlags.Modified | EventFlags.PropertyRenamed, _eventsFired);
Assert.AreEqual(1, _pool.CustomProperties.Count());
Assert.Null(_pool.LookupProperty("author"));
Assert.AreEqual(PropertyCategory.Custom, _pool.LookupPropertyCategory("developer"));
Assert.AreEqual(prop, _pool.LookupProperty("developer"));
}
public void TestSetup()
{
_eventsFired = EventFlags.None;
_registry = new TileRegistry(_service.GraphicsDevice);
_pool = new TilePool("pool", _registry, 16, 16);
_pool.Modified += (s, e) => { _eventsFired |= EventFlags.Modified; };
_pool.NameChanged += (s, e) => { _eventsFired |= EventFlags.NameChanged; };
_pool.TileAdded += (s, e) => { _eventsFired |= EventFlags.TileAdded; };
_pool.TileRemoved += (s, e) => { _eventsFired |= EventFlags.TileRemoved; };
_pool.TileModified += (s, e) => { _eventsFired |= EventFlags.TileModified; };
_pool.CustomProperties.PropertyAdded += (s, e) => { _eventsFired |= EventFlags.PropertyAdded; };
_pool.CustomProperties.PropertyRemoved += (s, e) => { _eventsFired |= EventFlags.PropertyRemoved; };
_pool.CustomProperties.PropertyModified += (s, e) => { _eventsFired |= EventFlags.PropertyModified; };
_pool.CustomProperties.PropertyRenamed += (s, e) => { _eventsFired |= EventFlags.PropertyRenamed; };
}
public void RemoveProperty()
{
Assert.AreEqual(0, _pool.CustomProperties.Count());
Property prop1 = new StringProperty("author", "Justin");
Property prop2 = new StringProperty("date", "May");
_pool.CustomProperties.Add(prop1);
_pool.CustomProperties.Add(prop2);
Assert.AreEqual(2, _pool.CustomProperties.Count());
_eventsFired = EventFlags.None;
_pool.CustomProperties.PropertyRemoved += (s, e) =>
{
Assert.AreEqual(prop1, e.Property);
};
_pool.CustomProperties.Remove("author");
Assert.AreEqual(EventFlags.Modified | EventFlags.PropertyRemoved, _eventsFired);
Assert.AreEqual(1, _pool.CustomProperties.Count());
Assert.Null(_pool.LookupProperty("author"));
Assert.AreEqual(PropertyCategory.Custom, _pool.LookupPropertyCategory("date"));
Assert.AreEqual(prop2, _pool.LookupProperty("date"));
}
public void Stop()
{
_flags |= EventFlags.StopPropagation;
}
public void ModifyTileTexture()
{
Texture2D tex1 = RandomTexture(16, 16);
Texture2D tex2 = RandomTexture(16, 16);
Assert.IsFalse(TexturesEqual(tex1, tex2));
int id = _pool.AddTile(tex1);
_eventsFired = EventFlags.None;
_pool.TileModified += (s, e) =>
{
Assert.AreEqual(_pool, e.Tile.Pool);
Assert.AreEqual(id, e.Tile.Uid);
Assert.IsTrue(TexturesEqual(tex2, e.Tile.Pool.GetTileTexture(id)));
};
_pool.SetTileTexture(id, tex2);
Assert.AreEqual(EventFlags.Modified | EventFlags.TileModified, _eventsFired);
Assert.AreEqual(1, _registry.TileCount);
Assert.AreEqual(1, _pool.Count);
}
public void StopImmediately()
{
_flags |= EventFlags.StopImmediatePropagation;
}
public virtual System.Reflection.EventInfo GetEventInfo()
{
if(this.eventInfo == null)
{
TypeNode tn = this.DeclaringType;
if(tn == null)
return null;
Type t = tn.GetRuntimeType();
if(t == null)
return null;
System.Reflection.BindingFlags flags = System.Reflection.BindingFlags.DeclaredOnly;
if(this.IsPublic)
flags |= System.Reflection.BindingFlags.Public;
else
flags |= System.Reflection.BindingFlags.NonPublic;
if(this.IsStatic)
flags |= System.Reflection.BindingFlags.Static;
else
flags |= System.Reflection.BindingFlags.Instance;
this.eventInfo = t.GetEvent(this.Name.ToString(), flags);
}
return this.eventInfo;
}
public void Cancel()
{
if (_cancelable)
{
_flags |= EventFlags.Canceled;
}
}
public void RemovePropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
Property prop1 = new StringProperty("test", "orange");
Property prop2 = new StringProperty("two", "number");
collection.Add(prop1);
collection.Add(prop2);
collection.PropertyRemoved += (s, e) =>
{
Assert.AreSame(prop1, e.Property);
Assert.AreEqual(1, collection.Count);
Assert.IsFalse(collection.Contains("test"));
Assert.IsTrue(collection.Contains("two"));
Assert.IsFalse(collection.Contains(prop1));
Assert.IsTrue(collection.Contains(prop2));
};
_eventsFired = EventFlags.None;
collection.Remove(prop1);
Assert.AreEqual(EventFlags.PropertyRemoved | EventFlags.Modified, _eventsFired);
}
public void ModifyPropertyTest()
{
PropertyCollection collection = new PropertyCollection(new string[0]);
AttachEvents(collection);
StringProperty prop = new StringProperty("test", "orange");
collection.PropertyModified += (s, e) =>
{
Assert.AreSame(prop, e.Property);
Assert.AreEqual(1, collection.Count);
Assert.IsTrue(collection.Contains("test"));
Assert.IsTrue(collection.Contains(prop));
Assert.AreEqual("blue", e.Property.ToString());
};
collection.Add(prop);
_eventsFired = EventFlags.None;
prop.Value = "blue";
Assert.AreEqual(EventFlags.PropertyModified | EventFlags.Modified, _eventsFired);
}
