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); }