/// <summary>
/// Used to notify any UI controls that they must commit
/// because the VM needs to perform an action
/// </summary>
/// <returns>True if all commits were succesful</returns>
public bool CommitEdit()
{
if (OnCommitEdit != null)
{
CancelEventArgs args = new CancelEventArgs();
OnCommitEdit(this,args);
return !args.Cancel;
}
return true;
}
public void CancelEventArgs()
{
var args = new CancelEventArgs();
Assert.IsFalse(args.Cancel);
args.Cancel = true;
Assert.IsTrue(args.Cancel);
args = new CancelEventArgs(true);
Assert.IsTrue(args.Cancel);
}
public void CancelEventArgsWithValue()
{
var args = new CancelEventArgs<string>();
Assert.IsFalse(args.Cancel);
Assert.IsNull(args.Value);
args.Cancel = true;
args.Value = "test";
Assert.IsTrue(args.Cancel);
Assert.AreEqual("test", args.Value);
args = new CancelEventArgs<string>("test", true);
Assert.IsTrue(args.Cancel);
Assert.AreEqual("test", args.Value);
}
void tas_PreviewSaid(object sender, CancelEventArgs<TasSayEventArgs> e) {
if (e.Data.Channel == GlobalConst.NightwatchName || e.Data.UserName == GlobalConst.NightwatchName || tas.UserName == GlobalConst.NightwatchName) {
var parts = e.Data.Text.Split(new[] { ' ' }, 3);
if (parts.Length == 3 && parts[0] == "USER_EXT") {
e.Cancel = true;
var name = parts[1];
var data = Deserialize(parts[2]);
var dict = new Dictionary<string, string>();
//userAttributes.TryGetValue(name, out dict);
//dict = dict ?? new Dictionary<string, string>();
foreach (var kvp in data) dict[kvp.Key] = kvp.Value;
userAttributes[name] = dict;
notifyUserExtensionChange(name, dict);
}
else if (parts.Length >= 3 && parts[0] == "!JSON") {
e.Cancel = true;
DecodeJson(e.Data.Text, e.Data);
}
}
}
void PerformUnitSyncOperation(WorkItem workItem)
{
Trace.TraceInformation("PerformUnitSyncOperation");
VerifyUnitSync();
if (unitSync == null)
{
Trace.TraceError("Skipping file after unitsync loading errors: {0}", workItem.CacheItem.ShortPath);
CacheMarkFailedUnitSync(workItem.CacheItem.ShortPath);
return;
}
var info = GetUnitSyncData(workItem.CacheItem.FileName);
UnInitUnitsync();
if (info != null)
{
workItem.CacheItem.InternalName = info.Name;
workItem.CacheItem.ResourceType = info.ResourceType;
CacheItemAdd(workItem.CacheItem);
var args = new CancelEventArgs<ResourceInfo>(info);
UploadUnitsyncData.Invoke(this,args);
if (args.Cancel) return;
var serializedData = MetaDataCache.SerializeAndCompressMetaData(info);
var map = info as Map;
object userState = null;
try
{
var creator = new TorrentCreator();
creator.Path = GetFullPath(workItem);
var ms = new MemoryStream();
creator.Create(ms);
byte[] minimap = null;
byte[] metalMap = null;
byte[] heightMap = null;
if (map != null)
{
minimap = map.Minimap.ToBytes(ImageSize);
metalMap = map.Metalmap.ToBytes(ImageSize);
heightMap = map.Heightmap.ToBytes(ImageSize);
userState = new MapRegisteredEventArgs(info.Name, map, minimap, metalMap, heightMap, serializedData);
}
var mod = info as Mod;
if (mod != null) userState = new KeyValuePair<Mod, byte[]>(mod, serializedData);
Trace.TraceInformation("uploading {0} to server", info.Name);
Task.Factory.StartNew(() => {
ReturnValue e;
try {
e = service.RegisterResource(PlasmaServiceVersion, springPaths.SpringVersion, workItem.CacheItem.Md5.ToString(),
workItem.CacheItem.Length, info.ResourceType, workItem.CacheItem.FileName, info.Name,
serializedData, info.Dependencies, minimap, metalMap, heightMap,
ms.ToArray());
} catch (Exception ex) {
Trace.TraceError("Error uploading data to server: {0}", ex);
return;
} finally {
Interlocked.Decrement(ref itemsSending);
}
if (e != ReturnValue.Ok)
{
Trace.TraceWarning("Resource registering failed: {0}", e);
return;
}
var mapArgs = userState as MapRegisteredEventArgs;
if (mapArgs != null)
{
var mapName = mapArgs.MapName;
MetaData.SaveMinimap(mapName, mapArgs.Minimap);
MetaData.SaveMetalmap(mapName, mapArgs.MetalMap);
MetaData.SaveHeightmap(mapName, mapArgs.HeightMap);
MetaData.SaveMetadata(mapName, mapArgs.SerializedData);
MapRegistered(this, mapArgs);
}
else if (userState != null)
{
var kvp = (KeyValuePair<Mod, byte[]>)userState;
var modInfo = kvp.Key;
var serializedDataRet = kvp.Value;
MetaData.SaveMetadata(modInfo.Name, serializedDataRet);
ModRegistered(this, new EventArgs<Mod>(mod));
}
});
Interlocked.Increment(ref itemsSending);
}
catch (Exception e)
{
Trace.TraceError("Error registering new resource {0}: {1}", workItem.CacheItem.ShortPath, e);
}
}
else
{
Trace.TraceError("Could not unitsync file {0}", workItem.CacheItem.ShortPath);
CacheMarkFailedUnitSync(workItem.CacheItem.ShortPath);
}
return;
}
void GetResourceData(WorkItem work)
{
ResourceData result = null;
try
{
result = service.GetResourceData(work.CacheItem.Md5.ToString(), work.CacheItem.InternalName);
}
catch (Exception ex)
{
var args = new CancelEventArgs<CacheItem>(work.CacheItem);
RetryResourceCheck.Invoke(this, args);
if (!args.Cancel)
{
Trace.TraceError("Error getting resource data: {0}", ex);
AddWork(work.CacheItem, WorkItem.OperationType.ReAskServer, DateTime.Now.AddSeconds(RescheduleServerQuery), false);
return;
}
}
if (result == null)
{
if (!UseUnitSync || springPaths.SpringVersion == null)
{
Trace.WriteLine(String.Format("No server resource data for {0}, asking later", work.CacheItem.ShortPath));
AddWork(work.CacheItem, WorkItem.OperationType.ReAskServer, DateTime.Now.AddSeconds(UnitsyncMissingReaskQuery), false);
}
else {
Trace.WriteLine(String.Format("No server resource data for {0}, queing upload", work.CacheItem.ShortPath));
AddWork(work.CacheItem, WorkItem.OperationType.UnitSync, DateTime.Now, false);
}
return;
}
work.CacheItem.InternalName = result.InternalName;
work.CacheItem.ResourceType = result.ResourceType;
Trace.WriteLine(string.Format("Adding {0}", work.CacheItem.InternalName));
CacheItemAdd(work.CacheItem);
}
private void m_bs_PositionChanged(object sender, EventArgs e)
{
CancelEventArgs e2 = new CancelEventArgs();
OnPositionChanging(e2);
if (e2.Cancel)
{
return;
}
OnPositionChanged(e);
}
private void Algorithm_NameChanging(object sender, CancelEventArgs<string> e) {
OnNameChanging(e);
}
private void TextBox_Validation(object sender, CancelEventArgs e)
{
try
{
double value = System.Double.Parse(this.Text);
}
catch (System.Exception)
{
e.Cancel = true;
}
}
private void Problem_NameChanging(object sender, CancelEventArgs<string> e) {
OnNameChanging(e);
}
void OnJoin(string[] args)
{
if (!JoinedChannels.ContainsKey(args[0])) {
JoinedChannels.Add(args[0], Channel.Create(args[0]));
var cancelEventArgs = new CancelEventArgs<TasEventArgs>(new TasEventArgs(args));
PreviewChannelJoined(this, cancelEventArgs);
if (!cancelEventArgs.Cancel) ChannelJoined(this, new TasEventArgs(args));
}
}
private void Symbol_NameChanging(object sender, CancelEventArgs<string> e) {
if (symbols.ContainsKey(e.Value)) e.Cancel = true;
}
private void OnBackButtonPressed(CancelEventArgs args)
{
if (CanGoBack)
return;
var navigating = Navigating;
if (navigating == null)
{
RaiseNavigated(BackButtonNavigationEventArgs.Instance);
return;
}
var navArgs = new BackButtonNavigatingEventArgs();
navigating(this, navArgs);
args.Cancel = navArgs.Cancel;
}
/// <summary>
/// Handle back key presses.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
#if SILVERLIGHT
private void FeedbackOverlay_BackKeyPress(object sender, CancelEventArgs e)
/// <summary>
/// Intercept channel messages for attacking/defending
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
void TasOnPreviewSaid(object sender, CancelEventArgs<TasSayEventArgs> args)
{
if (args.Data.Text.StartsWith("!") && (args.Data.Place == SayPlace.Channel || args.Data.Place == SayPlace.User) && args.Data.UserName != GlobalConst.NightwatchName)
{
int targetPlanetId;
if (int.TryParse(args.Data.Text.Substring(1), out targetPlanetId)) JoinPlanet(args.Data.UserName, targetPlanetId);
}
}
protected virtual void OnNameChanging(CancelEventArgs<string> e) {
var handler = NameChanging;
if (handler != null) handler(this, e);
}
void InvokeSaid(TasSayEventArgs sayArgs)
{
var previewSaidEventArgs = new CancelEventArgs<TasSayEventArgs>(sayArgs);
PreviewSaid(this, previewSaidEventArgs);
if (!previewSaidEventArgs.Cancel) Said(this, sayArgs);
}
private void OnNameChanging(CancelEventArgs<string> e) {
var handler = NameChanging;
if (handler != null) handler(this, e);
}
bool IsBattleVisible(string modname)
{
if (FilterBattleByMod != null)
{
var e = new CancelEventArgs<string>(modname);
e.Cancel = false;
FilterBattleByMod(this, e);
return !e.Cancel;
}
else return true;
}
protected void optimizer_NameChanging(object sender, CancelEventArgs<string> e) {
OnNameChanging(new CancelEventArgs<string>(e.Value, e.Cancel));
}
public void LeaveChannel(string channelName)
{
var args = new CancelEventArgs<string>(channelName);
ChannelLeaving(this, args);
if (args.Cancel) return;
con.SendCommand("LEAVE", channelName);
JoinedChannels.Remove(channelName);
ChannelLeft(this, new TasEventArgs(channelName));
}
