public void FlaggedItemParsed(object sender, ResourceEventArgs e)
{
if (_currentURL != null && _currentFlag != null)
{
// Search for feed
IResource feed = null;
foreach (FeedInfo fi in _importedFeeds)
{
if (fi.url == _currentURL)
{
feed = fi.feed;
break;
}
}
if (feed != null)
{
// IResource item = null; // Get item by feed and e.resource!
// item.AddLink( "Flag", _currentFlag );
}
}
_currentURL = null;
_currentFlag = null;
// We don't need this one
e.Resource.Delete();
}
private void Resource_ResourceDisposing(object sender, ResourceEventArgs e)
{
if (e.ContentType == typeof(Pixmap) && e.Content.Res == this.targetPixmap)
{
this.Close();
}
}
private static void DeleteSourceMediaFile(ResourceEventArgs deleteEvent)
{
if (deleteEvent.IsResource)
{
IList <string> mediaPaths = GetSourceMediaPaths(deleteEvent.Content.Res);
for (int i = 0; i < mediaPaths.Count; i++)
{
if (File.Exists(mediaPaths[i]))
{
RecycleBin.SendSilent(mediaPaths[i]);
PathHelper.DeleteEmptyDirectory(Path.GetDirectoryName(mediaPaths[i]), true);
}
}
}
else if (deleteEvent.IsDirectory)
{
string mediaPath = Path.Combine(
EditorHelper.SourceMediaDirectory,
PathHelper.MakeFilePathRelative(deleteEvent.Path, DualityApp.DataDirectory));
if (Directory.Exists(mediaPath))
{
RecycleBin.SendSilent(mediaPath);
PathHelper.DeleteEmptyDirectory(Path.GetDirectoryName(mediaPath), true);
}
}
}
private void OnResourcesAdded(ResourceEventArgs e)
{
var n = ResourcesAdded;
if (n == null) return;
n(this, e);
}
/**
* When the unread count for a resource changes in the unread state, updates
* the rich text for the respective tree node.
*/
private void OnUnreadCountChanged(object sender, ResourceEventArgs e)
{
if (DecorationChanged != null)
{
DecorationChanged(this, new ResourceEventArgs(e.Resource));
}
}
/// <summary>
/// Event fired when the call has been updated.
/// </summary>
/// <param name="sender">The call.</param>
/// <param name="e">The event args containing call changes.</param>
private void CallOnUpdated(ICall sender, ResourceEventArgs <Call> e)
{
if (e.OldResource.State != e.NewResource.State && e.NewResource.State == CallState.Established)
{
// Call is established... do some work.
}
}
private void FileEventManager_ResourceChanged(object sender, ResourceEventArgs e)
{
if (e.IsResource)
{
this.OnResourceModified(e.Content);
}
}
private void LibraryAddedHandler(object sender, ResourceEventArgs <Library> e)
{
AddResource(_libraryRoot, e.Resource, IconIndex.Library, (subNode, r) => {
if (r == _controller.Project.DefaultLibrary)
{
subNode.ImageIndex = IconIndex.LibraryDefault;
subNode.SelectedImageIndex = IconIndex.LibraryDefault;
}
TreeNode tileSets = new TreeNode("Tilesets", IconIndex.FolderTiles, IconIndex.FolderTiles)
{
Name = "Tilesets"
};
TreeNode objects = new TreeNode("Objects", IconIndex.FolderObjects, IconIndex.FolderObjects)
{
Name = "Objects"
};
subNode.Nodes.Add(tileSets);
subNode.Nodes.Add(objects);
AddResources <TilePool>(tileSets, r.TilePoolManager.Pools, IconIndex.TileGroup);
AddResources <ObjectPool>(objects, r.ObjectPoolManager.Pools, IconIndex.ObjectGroup, (objSubNode, r2) => {
AddResources <ObjectClass>(objSubNode, r2.Objects, IconIndex.ObjectGroup);
});
});
if (_libraryRoot.Nodes.Count > 0)
{
_libraryRoot.Expand();
}
}
private void HandleResourceRemoved(object sender, ResourceEventArgs <TPool> e)
{
if (_poolResourceAddHandlers.ContainsKey(e.Uid))
{
e.Resource.ResourceAdded -= _poolResourceAddHandlers[e.Uid];
_poolResourceAddHandlers.Remove(e.Uid);
}
if (_poolResourceRemoveHandlers.ContainsKey(e.Uid))
{
e.Resource.ResourceRemoved -= _poolResourceRemoveHandlers[e.Uid];
_poolResourceRemoveHandlers.Remove(e.Uid);
}
List <Guid> removeQueue = new List <Guid>();
foreach (var item in _poolIndexMap)
{
if (item.Value == e.Resource)
{
removeQueue.Add(item.Key);
}
}
foreach (Guid key in removeQueue)
{
_poolIndexMap.Remove(key);
}
OnPoolRemoved(e.Resource);
}
/// <summary>
/// Event handler when participan is updated.
/// </summary>
/// <param name="sender">The sender</param>
/// <param name="args">The arguments</param>
private void OnParticipantUpdated(ICallParticipant sender, ResourceEventArgs <Participant> args)
{
var outcome = Serializer.SerializeObject(sender.Resource);
this.OutcomesLogMostRecentFirst.AddFirst("Participant Updated:\n" + outcome);
this.ParticipantOnUpdated(sender, args);
}
/// <summary>
/// Raises the <see cref="LayerRemoved"/> event.
/// </summary>
/// <param name="e">A <see cref="NamedResourceEventArgs{Layer}"/> containing the name of the removed layer.</param>
protected virtual void OnLayerRemoved(ResourceEventArgs <Layer> e)
{
if (LayerRemoved != null)
{
LayerRemoved(this, e);
}
OnModified(EventArgs.Empty);
}
/// <summary>
/// Event handler for call updated.
/// </summary>
/// <param name="sender">The event sender.</param>
/// <param name="args">The event arguments.</param>
private void OnCallUpdated(ICall sender, ResourceEventArgs <Call> args)
{
var outcome = Serializer.SerializeObject(sender.Resource);
this.OutcomesLogMostRecentFirst.AddFirst("Call Updated:\n" + outcome);
this.CallOnUpdated(sender, args);
}
/// <summary>
/// Event fired when a participant is updated.
/// </summary>
/// <param name="sender">Participant object.</param>
/// <param name="args">Event args containing the old values and the new values.</param>
private void OnParticipantUpdated(ICallParticipant sender, ResourceEventArgs <Participant> args)
{
var outcome = Serializer.SerializeObject(sender.Resource);
this.OutcomesLogMostRecentFirst.AddFirst("Participant Updated:\n" + outcome);
this.SubscribeToParticipantVideo(sender, forceSubscribe: false);
}
private void FileEventManager_ResourceModified(object sender, ResourceEventArgs e)
{
if (!e.IsResource)
{
return;
}
this.glControl.Invalidate();
}
/// <summary>
/// Event fired when the call has been updated.
/// </summary>
/// <param name="sender">The call.</param>
/// <param name="e">The event args containing call changes.</param>
private void CallOnUpdated(ICall sender, ResourceEventArgs <Call> e)
{
this.GraphLogger.Info($"Call status updated to {e.NewResource.State} - {e.NewResource.ResultInfo?.Message}");
// Event - Recording update e.g established/updated/start/ended
if (e.OldResource.State != e.NewResource.State && e.NewResource.State == CallState.Established)
{
}
}
protected virtual void OnLibraryModified(ResourceEventArgs <Library> e)
{
var ev = LibraryModified;
if (ev != null)
{
ev(this, e);
}
}
private void TilePoolAdded(object sender, ResourceEventArgs <TilePool> e)
{
AddPoolPresenter(e.Resource);
SelectTilePool(e.Uid);
OnSyncTilePoolList(EventArgs.Empty);
OnSyncTilePoolControl(EventArgs.Empty);
}
protected virtual void OnObjectModified(ResourceEventArgs <ObjectClass> e)
{
var ev = ObjectModified;
if (ev != null)
{
ev(this, e);
}
}
/// <summary>
/// 引发 <see cref="ResouceUndownload" /> 事件
/// </summary>
/// <param name="sender">引发此事件的源对象</param>
/// <param name="ea">包含此事件的参数</param>
public void OnResouceUndownload(object sender, ResourceEventArgs ea)
{
var handler = ResouceUndownload;
if (handler != null)
{
handler(sender, ea);
}
}
private void Tv_ResourceSelected(object sender, ResourceEventArgs e)
{
if (rpd == null)
{
rpd = new ResourcePropertiesDialog();
}
rpd.Resource = e.Resource;
}
/// <summary>
/// Event triggered when a participant's properties are updated.
/// </summary>
/// <param name="sender">Call participant.</param>
/// <param name="args">Event contains the old values and the new values for the participant.</param>
private void OnParticipantUpdated(ICallParticipant sender, ResourceEventArgs <Participant> args)
{
var outcome = Serializer.SerializeObject(sender.Resource);
this.OutcomesLogMostRecentFirst.AddFirst("Participant Updated:\n" + outcome);
// Subscribed participant might have disconnected video.
this.Subscribe();
}
/// <summary>
/// Event triggered when the call object is updated.
/// </summary>
/// <param name="sender">Call instance.</param>
/// <param name="args">Event args contains the old values and the new values for the call.</param>
private void OnCallUpdated(ICall sender, ResourceEventArgs <Call> args)
{
var outcome = Serializer.SerializeObject(sender.Resource);
this.OutcomesLogMostRecentFirst.AddFirst("Call Updated:\n" + outcome);
// Call state might have changed to established.
this.Subscribe();
}
protected virtual void OnResourceInvalidated(ResourceEventArgs e)
{
EventHandler <ResourceEventArgs> ev = ResourceInvalidated;
if (ev != null)
{
ev(this, e);
}
}
protected virtual void OnLevelModified(ResourceEventArgs <Level> e)
{
var ev = LevelModified;
if (ev != null)
{
ev(this, e);
}
}
private void HandleResourceInvalidated(object sender, ResourceEventArgs e)
{
var ev = ResourceInvalidated;
if (ev != null)
{
ev(this, e);
}
}
protected virtual void OnTilePoolModified(ResourceEventArgs <TilePool> e)
{
var ev = TilePoolModified;
if (ev != null)
{
ev(this, e);
}
}
public void Execute(object sender, ResourceEventArgs es)
{
if (!ChangeEnabledStateEventHandler(sender, es))
{
return;
}
Execute(es.Items);
}
private void rh_LoadedResource(object sender, ResourceEventArgs es)
{
foreach (SimPe.Events.ResourceContainer e in es)
{
if (e.HasResource)
{
resourceViewManager1.SelectResource(e.Resource);
}
}
}
internal void OnResourceRemoved(ResourceEventArgs args)
{
if (ResourceRemoved != null)
{
ResourceRemoved(this, args);
}
if (Parent != null)
{
Parent.OnResourceRemoved(args);
}
}
public void _tvFeeds_ResourceAdded(object sender, ResourceEventArgs e)
{
if (e.Resource.Type == "RSSFeedGroup")
{
_tvFeeds.SetNodeCheckState(e.Resource, CheckBoxState.Hidden);
}
else
{
_tvFeeds.SetNodeCheckState(e.Resource, CheckBoxState.Checked);
}
}
/// <summary>
/// Event fired when the call has been updated.
/// </summary>
/// <param name="sender">The call.</param>
/// <param name="e">The event args containing call changes.</param>
private void CallOnUpdated(ICall sender, ResourceEventArgs <Call> e)
{
if (e.OldResource.State != e.NewResource.State && e.NewResource.State == CallState.Established)
{
// Call is established. We should start receiving Audio, we can inform clients that we have started recording.
this.OnRecordingStatusFlip(sender, null);
// for testing purposes, flip the recording status automatically at intervals
this.recordingStatusFlipTimer.Enabled = true;
}
}
private void OnResourceAdded(ResourceEventArgs args)
{
this.Resource.OnResourceAdded(args);
}
static void engine_PackagedItemResource(object sender, ResourceEventArgs e)
{
Console.WriteLine("Packaged Resource: " + e.Resource.ExtractToPath);
}
/// <summary>
/// Raises the <see cref="LayerRemoved"/> event.
/// </summary>
/// <param name="e">A <see cref="NamedResourceEventArgs{Layer}"/> containing the name of the removed layer.</param>
protected virtual void OnLayerRemoved (ResourceEventArgs<Layer> e)
{
if (LayerRemoved != null) {
LayerRemoved(this, e);
}
OnModified(EventArgs.Empty);
}
private void HandleResourceRemoved(object sender, ResourceEventArgs e)
{
var ev = ResourceRemoved;
if (ev != null)
ev(this, e);
}
protected virtual void OnResourceRemoved(ResourceEventArgs e)
{
EventHandler<ResourceEventArgs> ev = ResourceRemoved;
if (ev != null)
ev(this, e);
}
private void Resource_ResourceDisposing(object sender, ResourceEventArgs e)
{
if (!e.IsResource) return;
// Deselect the current tileset, if it's being disposed.
// This is required since we don't always react to Deselect
// events, which the editor provides on Resource disposal.
if (this.SelectedTileset == e.Content.As<Tileset>())
{
this.SelectedTileset = null;
}
}
internal void OnResourceRemoved(ResourceEventArgs args)
{
if (ResourceRemoved != null)
{
ResourceRemoved(this, args);
}
if (Parent != null)
Parent.OnResourceRemoved(args);
}
