private string[] GetSubitemNames()
{
AudioItem curItem = currentItem;
if (curItem == null || curItem.subItems == null)
{
return(new string[0]);
}
var names = new string[curItem.subItems.Length];
for (int i = 0; i < curItem.subItems.Length; i++)
{
AudioSubItemType subitemType = curItem.subItems[i] != null ? curItem.subItems[i].SubItemType : AudioSubItemType.Clip;
if (subitemType == AudioSubItemType.Item)
{
names[i] = string.Format("ITEM {0}: {1}", i, (curItem.subItems[i].ItemModeAudioID ?? "*undefined*"));
}
else
{
names[i] = string.Format("CLIP {0}: {1}", i, (curItem.subItems[i] != null ? curItem.subItems[i].Clip ? curItem.subItems[i].Clip.name : "*unset*" : ""));
}
}
return(names);
}
private void Awake()
{
if (ambientsRoot != null)
{
fillAudioSources(ambientsRoot.GetComponents <AudioSource>(), ambients);
}
if (musicsRoot != null)
{
fillAudioSources(musicsRoot.GetComponents <AudioSource>(), musics);
}
if (shortsRoot != null)
{
fillAudioSources(shortsRoot.GetComponents <AudioSource>(), shorts);
}
if (playerEffectsRoot != null)
{
fillAudioSources(playerEffectsRoot.GetComponents <AudioSource>(), playerEffects);
}
if (villainEffectsRoot != null)
{
fillAudioSources(villainEffectsRoot.GetComponents <AudioSource>(), villainEffects);
}
if (powerupsRoot != null)
{
fillAudioSources(powerupsRoot.GetComponents <AudioSource>(), powerups);
}
if (UiEffetcsRoot != null)
{
fillAudioSources(UiEffetcsRoot.GetComponents <AudioSource>(), UiEffetcs);
}
footSteps = getAudoClip("PlayerFootSteps");
}
/// <summary>
/// 检测并返回一个Audio Item
/// </summary>
/// <param name="_name">音效名字</param>
/// <param name="_category">音效类别</param>
/// <returns></returns>
public AudioItem CheckAudioItem(string _name, string _category)
{
if (true == string.IsNullOrEmpty(_name))
{
return(null);
}
if (true == AudioController.IsValidAudioID(_name))
{
return(AudioController.GetAudioItem(_name));
}
AudioClip audioClip = null;
// 加载音频资源
if (null != loadResEvent)
{
var audioObject = loadResEvent(_name, "audio");
if (null != audioObject && true == audioObject is AudioClip)
{
audioClip = (AudioClip)audioObject;
}
}
if (null == audioClip)
{
this.Warr(StringCacheFactory.GetFree().Add("无法加载音频 = ").Add(_name));
return(null);
}
var audio_category = AudioController.GetCategory(_category);
if (null != audio_category)
{
AudioItem audioItem = AudioController.AddToCategory(audio_category, audioClip, _name);
return(audioItem);
}
return(null);
}
private static AudioItem CreateAudioItem(bool enabled, bool randomPitch, float pitch, float minPitch, float maxPitch, bool changeVol, float vol, params AudioClip[] clips)
{
AudioItem item = new AudioItem(enabled, randomPitch, pitch, minPitch, maxPitch, changeVol, vol);
int clipSize = 0;
for (int i = 0; i < clips.Length; i++)
{
if (clips[i] != null)
{
clipSize++;
}
}
item.AudioClips = new AudioClip[clipSize];
int index = 0;
for (int i = 0; i < clips.Length; i++)
{
if (clips[i] != null)
{
item.AudioClips[index] = clips[i];
index++;
}
}
return(item);
}
public AudioDynamicItem CreateDynamicItem(Func<AudioDynamicItem, AudioDynamicData, AudioSettingsBase> getNextSettings, AudioSpatializer spatializer, AudioItem parent)
{
AudioDynamicItem item = Pool<AudioDynamicItem>.Create(AudioDynamicItem.Default);
item.Initialize(getNextSettings, spatializer, parent);
return item;
}
private AudioItem checkSourcesForItemOnce(AudioReference reference, AudioLoadResultHandler resultHandler, bool[] reported)
{
foreach (AudioSourceManager sourceManager in sourceManagers)
{
AudioItem item = sourceManager.loadItem(this, reference);
if (item != null)
{
if (item is AudioTrack)
{
log.debug("Loaded a track with identifier {} using {}.", reference.identifier, sourceManager.GetType().Name);
reported[0] = true;
resultHandler.trackLoaded((AudioTrack)item);
}
else if (item is AudioPlaylist)
{
log.debug("Loaded a playlist with identifier {} using {}.", reference.identifier, sourceManager.GetType().Name);
reported[0] = true;
resultHandler.playlistLoaded((AudioPlaylist)item);
}
return(item);
}
}
return(null);
}
public IEnumerator FadeIn(AudioItem audioItem, GameObject gameObject, AudioMixerGroup audioMixerGroup)
{
if (gameObject.GetComponent <AudioSource>() == null || gameObject.GetComponent <AudioSource>().isPlaying)
{
audioItem.myAudioSource = gameObject.AddComponent <AudioSource>();
}
audioItem.myAudioSource.outputAudioMixerGroup = audioMixerGroup;
audioItem.myAudioSource.loop = audioItem.isLooping;
audioItem.myAudioSource.playOnAwake = audioItem.playOnAwake;
audioItem.myAudioSource.clip = audioItem.myClip;
myAudioSource.volume = _minVolume;
float audioVolume = myAudioSource.volume;
myAudioSource.Play();
while (myAudioSource.volume < _maxVolume)
{
audioVolume += speed;
myAudioSource.volume = audioVolume;
yield return(new WaitForSeconds(0.1F));
}
}
private int FindIdlePort()
{
int index;
for (index = 0; index < m_audios.Count; ++index)
{
if (!m_audios[index].audio.isPlaying)
{
break;
}
}
//如果找不到空闲的, 申请空间, 继续播放
if (index == m_audios.Count)
{
AudioItem tmp = new AudioItem();
tmp.audio = ObjectEX.AddComponent <AudioSource>(m_audioParent);
if (tmp.audio != null)
{
tmp.id = 0;
tmp.guid = Guid.Empty;
m_audios.Add(tmp);
}
else
{
return(-1);
}
}
return(index);
}
public AudioItem PlayOneShotSound(AudioClip clip, float volume, float spatialBlend, int audioGroup, Vector3 position = new Vector3())
{
if (clip == null)
{
return(null);
}
for (int i = 0; i < _audioItems.Count; i++)
{
if (!_audioItems[i].isPlaying)
{
AudioItem audioItem = _audioItems[i];
audioItem.isPlaying = true;
audioItem.transform.gameObject.SetActive(true);
audioItem.transform.position = position;
audioItem.audioSource.clip = clip;
audioItem.audioSource.volume = volume;
audioItem.audioSource.spatialBlend = spatialBlend;
if (_audioGroups.Count > audioGroup)
{
audioItem.audioSource.outputAudioMixerGroup = _audioGroups[audioGroup];
}
audioItem.coroutine = AudioItemCoroutine(i);
StartCoroutine(audioItem.coroutine);
audioItem.audioSource.Play();
return(audioItem);
}
}
return(null);
}
/// <summary>
/// Copy constructor
/// </summary>
public AudioItem(AudioItem orig)
{
Name = orig.Name;
Loop = orig.Loop;
loopSequenceCount = orig.loopSequenceCount;
loopSequenceOverlap = orig.loopSequenceOverlap;
loopSequenceRandomDelay = orig.loopSequenceRandomDelay;
loopSequenceRandomPitch = orig.loopSequenceRandomPitch;
loopSequenceRandomVolume = orig.loopSequenceRandomVolume;
DestroyOnLoad = orig.DestroyOnLoad;
Volume = orig.Volume;
SubItemPickMode = orig.SubItemPickMode;
MinTimeBetweenPlayCalls = orig.MinTimeBetweenPlayCalls;
MaxInstanceCount = orig.MaxInstanceCount;
Delay = orig.Delay;
RandomVolume = orig.RandomVolume;
RandomPitch = orig.RandomPitch;
RandomDelay = orig.RandomDelay;
overrideAudioSourceSettings = orig.overrideAudioSourceSettings;
audioSource_MinDistance = orig.audioSource_MinDistance;
audioSource_MaxDistance = orig.audioSource_MaxDistance;
spatialBlend = orig.spatialBlend;
for (int i = 0; i < orig.subItems.Length; ++i)
{
ArrayHelper.AddArrayElement(ref subItems, new AudioSubItem(orig.subItems[i], this));
}
}
/// <summary>
/// Die Daten einer Tonspur sollen angezeigt werden.
/// </summary>
/// <param name="sender">Wird ignoriert.</param>
/// <param name="e">Wird ignoriert.</param>
private void selAudio_SelectedIndexChanged(object sender, EventArgs e)
{
// Disable first
selAudioType.Enabled = false;
selAudioPID.Enabled = false;
txAudioLanguage.Enabled = false;
cmdDelAudio.Enabled = false;
// Reset
selAudioType.SelectedItem = null;
selAudioPID.Value = selAudioPID.Maximum;
txAudioLanguage.Text = null;
// Get the selection
AudioItem item = (AudioItem)selAudio.SelectedItem;
if (null == item)
{
return;
}
// Fill in all
switch (item.Information.AudioType)
{
case AudioTypes.MP2: selAudioType.SelectedIndex = 0; break;
case AudioTypes.AC3: selAudioType.SelectedIndex = 1; break;
}
// Finish
txAudioLanguage.Text = item.Information.Language;
selAudioPID.Value = item.Information.AudioStream;
cmdDelAudio.Enabled = true;
}
public IActionResult Edit([FromBody] AudioItem item)
{
try
{
if (item == null || !ModelState.IsValid)
{
return(BadRequest(ErrorCode.SomeFieldsRequired.ToString()));
}
var existingItem = _audioListRepository.Find(item);
if (existingItem == null)
{
return(NotFound(ErrorCode.RecordNotFound.ToString()));
}
if (item.ToBeDeleted)
{
_audioListRepository.Delete(item);
}
else
{
_audioListRepository.Update(item);
}
}
catch (Exception)
{
return(BadRequest(ErrorCode.CouldNotUpdateItem.ToString()));
}
return(NoContent());
}
/// <summary>
/// This method gets called for each audio file you drop in the drop area.
/// </summary>
/// <param name="filePath">
/// The path of the file dropped.
/// </param>
private bool AddAudioFile(AudioClip audioClip)
{
// Make sure the file isn't already added
if (_audioManagerPrefab.AudioItems.Select(item => item.Clips[0]).Contains(audioClip))
{
// Return if the file is already in the list
return(false);
}
// Add an audio item to the array
List <AudioItem> audioItems = _audioManagerPrefab.AudioItems.ToList();
AudioClip[] clip = { audioClip };
var newAudiItem = new AudioItem
{
Clips = clip,
Volume = 1,
Name = audioClip.name,
Type = audioClip.length > 8 ? AudioItem.SoundType.Music : AudioItem.SoundType.SoundEffect
};
audioItems.Add(newAudiItem);
_audioManagerPrefab.AudioItems = audioItems.ToArray();
Debug.Log("Added " + audioClip.name);
return(true);
}
private void AddSelectedItemsToCollection()
{
// Make sure that at least one audio item is added
if (AudioManagerPrefab.AudioItems.Length == 0)
{
return;
}
AudioItem selectedAudioItem = AudioManagerPrefab.AudioItems[_selectedAudioIndex];
var clipsToAdd = new List <AudioClip>(selectedAudioItem.Clips);
foreach (Object obj in Selection.objects)
{
if (AssetDatabase.Contains(obj) && obj is AudioClip && !clipsToAdd.Contains(obj as AudioClip))
{
clipsToAdd.Add(obj as AudioClip);
}
}
// Apply new collection
selectedAudioItem.Clips = clipsToAdd.ToArray();
// Set dirty and repaint
EditorUtility.SetDirty(AudioManagerPrefab.gameObject);
Repaint();
}
/// <summary>
/// Asserts that the <paramref name="item"/> contains equivalent values from the <paramref name="sqlItem"/>.
/// </summary>
/// <param name="sqlItem">The item with expected values.</param>
/// <param name="item">The item with actual values.</param>
private static void AssertItem(SqlItem sqlItem, AudioItem item)
{
if (item != null)
{
var resource = sqlItem.Resources.First();
Assert.AreEqual(resource.AudioFormat.Duration, item.Duration);
}
}
private void UpdateVolumeSettings()
{
foreach (AudioSource audioSource in audioSources)
{
AudioItem audioItem = AudioItems.FirstOrDefault(ai => ai.Clips.Contains(audioSource.clip));
audioSource.GetComponent <AudioSourceComp>().UpdateVolume(Settings.MasterVolume, audioItem.Type == AudioItem.SoundType.Music ? Settings.MusicVolume : Settings.SoundEffectsVolume);
}
}
public override bool AddAudioItemToCategory(ref AudioItem aiItem, string categoryId)
{
if (wrappedService != null)
{
Debug.LogFormat("Add Audio Item {0} To Category: {1}", aiItem.itemId, categoryId);
return wrappedService.AddAudioItemToCategory(ref aiItem, categoryId);
}
return false;
}
public AudioItem getAudoClip(string clipName)
{
AudioItem clip = null;
foreach (AudioItem item in ambients)
{
if (item.audioSource.clip.name.Equals(clipName))
{
clip = item;
}
}
foreach (AudioItem item in musics)
{
if (item.audioSource.clip.name.Equals(clipName))
{
clip = item;
}
}
foreach (AudioItem item in shorts)
{
if (item.audioSource.clip.name.Equals(clipName))
{
clip = item;
}
}
foreach (AudioItem item in playerEffects)
{
if (item.audioSource.clip.name.Equals(clipName))
{
clip = item;
}
}
foreach (AudioItem item in villainEffects)
{
if (item.audioSource.clip.name.Equals(clipName))
{
clip = item;
}
}
foreach (AudioItem item in powerups)
{
if (item.audioSource.clip.name.Equals(clipName))
{
clip = item;
}
}
foreach (AudioItem item in UiEffetcs)
{
if (item.audioSource.clip.name.Equals(clipName))
{
clip = item;
}
}
return(clip);
}
/// <summary>
/// Plays a sound with the given arguments, all overloads just delegates responsibity to this method.
/// </summary>
/// <param name="audioItem">
/// The audio item to play a sound from.
/// </param>
/// <param name="volume">
/// Volume factor from 0 to 1. (null means audio items standard volume)
/// </param>
public void PlaySound(AudioItem audioItem, float?volume, Vector3?position, Transform parent)
{
RemoveAllMissingSources();
// We need an audio source to play a sound
var audioSource = new AudioSource();
bool didFindAudioSource = false;
// Loops through all audio sources we've created so far TODO: check for destroyed audio sources
foreach (AudioSource source in audioSources)
{
// If an existing audio source is not playing any sound, select that one
if (!source.isPlaying)
{
audioSource = source;
didFindAudioSource = true;
break;
}
}
// If we didn't find a usable audiosource in the scene, create a new one
if (!didFindAudioSource)
{
// Create audio source
audioSource = new GameObject("AudioSource").AddComponent <AudioSource>();
audioSource.gameObject.AddComponent <AudioSourceComp>();
// Make sure play on awake defaults to false
audioSource.playOnAwake = false;
// TODO: Enable hide of audio sources
//audioSource.gameObject.hideFlags = HideFlags.HideInHierarchy;
// Add new audio source to our list
audioSources.Add(audioSource);
}
// Assign position, default to origin
audioSource.transform.position = (position ?? Vector3.zero);
// Assign parent, null means no parent
audioSource.transform.parent = parent;
// Assign the clip to the selected audio source
audioSource.clip = audioItem.GetClip();
// Apply settings to audio source
ApplySettingsToAudioSource(audioSource, audioItem, volume);
// Set destroy on load
audioSource.GetComponent <AudioSourceComp>().DoDestroyOnLoad = !audioItem.DontDestroyOnLoad;
// Play the clip with the selected audio source
audioSource.Play();
}
async Task <bool> BeWithinAudioBounds(Command command, long arg, CancellationToken cancellationToken)
{
AudioItem item = await db.Audio
.AsNoTracking()
.SingleAsync(
x => x.Id == command.Id,
cancellationToken);
return(arg < item.Duration);
}
public void AudioItemInstantiation()
{
var options = new AudioItemOptions();
SetAudioItemOptions(options);
var audio_item = new AudioItem("-1", "-1", options);
AssertAudioItem(audio_item, options);
AssertAudioItem(audio_item, audio_item.GetOptions());
}
void OnAddItemClicked(object sender, EventArgs e)
{
var audioItem = new AudioItem();
audioItem.Username = (string)App.Current.Properties["Username"];
var audioPage = new AudioItemPage(true);
audioPage.BindingContext = audioItem;
Navigation.PushAsync(audioPage, true);
}
public bool IsTrackPlaying(string key)
{
AudioItem item = FindAudioTrack(key);
if (item != null)
{
return(bgSource.clip == item.audioSource && bgSource.isPlaying);
}
return(false);
}
public IEnumerator TestPlayOneSound()
{
item = new AudioItem(true, true, 1f, 0.9f, 1.1f, true, 1f, step1);
Assert.IsNull(source.clip);
item.Play(source);
yield return(null);
Assert.AreEqual(source.clip, step1);
}
private void RemoveClipFromCollection(int itemIndex)
{
AudioItem selectedAudioItem = AudioManagerPrefab.AudioItems[_selectedAudioIndex];
var clips = new List <AudioClip>(AudioManagerPrefab.AudioItems[_selectedAudioIndex].Clips);
clips.RemoveAt(itemIndex);
selectedAudioItem.Clips = clips.ToArray();
}
private void UpdateLyrics(File reader, AudioItem audioItem)
{
if (!audioItem.IsLyricsDirty)
{
return;
}
reader.Tag.Lyrics = audioItem.Lyrics;
audioItem.IsLyricsDirty = false;
}
/// <summary>
/// This is automaticly called when the window loses focus.
/// </summary>
private void OnLostFocus()
{
// Cancel removing an item when window loses focus
_itemToRemove = null;
// TODO: Stop playing sound here
// Repaint the window
Repaint();
}
/// <summary>
/// 播放音效,可以指定具体的播放位置
/// </summary>
/// <param name="_name">音效名字</param>
/// <param name="_vol">音效音量</param>
public AudioObject PlaySFX(string _name, float _vol)
{
AudioItem audioItem = CheckAudioItem(_name, AUDIO_CONTROLLER_SFX_CATEGORY);
if (null != audioItem)
{
return(AudioController.Play(_name, _vol));
}
return(null);
}
float _GetRandomLoopSequenceDelay(AudioItem audioItem)
{
float retVal = -audioItem.loopSequenceOverlap;
if (audioItem.loopSequenceRandomDelay > 0)
{
retVal += Random.Range(0, audioItem.loopSequenceRandomDelay);
}
return(retVal);
}
public void PlayAudio(AudioClip clip)
{
if (Database.Instance.localData.isOpenSound)
{
if (clip != null)
{
AudioItem item = poolAudioItem.BorrowObject <AudioItem>();
item.PlayAudio(clip, poolAudioItem);
}
}
}
public void StopBGM()
{
if (m_bgm == null)
{
return;
}
m_bgm._audioSource.Stop();
StartCoroutine(Recycle(m_bgm._handle));
m_bgm = null;
}
public override ServerObject GetMetadata()
{
Track t = new Track((IntPtr)this.ObjectData);
AudioItem track = new AudioItem(new MediaServerLocation(typeof(SpotifyTrackHandler), new string[] { this.ObjectData.ToString() }), MediaFormats.LPCM);
track.Title = t.Name;
track.Artists.AddRange(t.Artists);
track.Seconds = t.Seconds;
track.TrackNumber = t.TrackNumber;
if (t.Album != null) {
track.Album = t.Album.Name;
track.AlbumArtist = t.Album.Artist;
track.AlbumArt = new ImageResource(new MediaServerLocation(typeof(AlbumArtHandler), new string[] { t.Album.AlbumPtr.ToString() }), MediaFormats.JPEG);
}
return track;
}
public static void ShowPreviewButton(Rect rect, AudioSettingsBase settings)
{
if (AudioManager.Find() == null)
return;
// Check if scrollbar is visible
if (Screen.width - rect.x - rect.width > 5f)
rect.x = Screen.width - 40f;
else
rect.x = Screen.width - 24f;
rect.width = 21f;
rect.height = 16f;
GUIStyle buttonStyle = new GUIStyle("MiniToolbarButtonLeft");
buttonStyle.fixedHeight += 1;
if (GUI.Button(rect, "", buttonStyle))
{
Selection.activeObject = settings;
if (_previewSettings != settings || (_previewItem != null && _previewItem.State == AudioItem.AudioStates.Stopping))
{
StopPreview();
EditorUtility.SetDirty(settings);
_previewSettings = settings;
_previewItem = AudioManager.Instance.CreateItem(_previewSettings);
_previewItem.OnStop += item => { StopPreview(); EditorUtility.SetDirty(settings); EditorApplication.RepaintProjectWindow(); };
_previewItem.Play();
}
else if (_previewItem != null)
_previewItem.Stop();
else
StopPreview();
}
bool playing = _previewItem == null || _previewItem.State == AudioItem.AudioStates.Stopping || _previewSettings != settings;
GUIStyle labelStyle = new GUIStyle("boldLabel");
labelStyle.fixedHeight += 1;
labelStyle.fontSize = playing ? 14 : 20;
labelStyle.contentOffset = playing ? new Vector2(2f, -1f) : new Vector2(2f, -8f);
labelStyle.clipping = TextClipping.Overflow;
GUI.Label(rect, playing ? "►" : "■", labelStyle);
}
internal int _GetIndexOf( AudioItem audioItem )
{
if ( AudioItems == null ) return -1;
for ( int i = 0; i < AudioItems.Length; i++ )
{
if ( audioItem == AudioItems[ i ] ) return i;
}
return -1;
}
public AudioItem CreateItem(AudioSettingsBase settings, AudioSpatializer spatializer, AudioItem parent)
{
if (settings == null)
return null;
AudioItem item;
switch (settings.Type)
{
default:
AudioSourceItem sourceItem = Pool<AudioSourceItem>.Create(AudioSourceItem.Default);
AudioSource source = ComponentPool<AudioSource>.Create(AudioManager.Instance.Reference);
source.Copy(AudioManager.Instance.Reference, AudioManager.Instance.UseCustomCurves);
sourceItem.Initialize((AudioSourceSettings)settings, source, spatializer, parent);
item = sourceItem;
break;
case AudioItem.AudioTypes.MixContainer:
AudioMixContainerItem mixContainerItem = Pool<AudioMixContainerItem>.Create(AudioMixContainerItem.Default);
mixContainerItem.Initialize((AudioMixContainerSettings)settings, spatializer, parent);
item = mixContainerItem;
break;
case AudioItem.AudioTypes.RandomContainer:
AudioRandomContainerItem randomContainerItem = Pool<AudioRandomContainerItem>.Create(AudioRandomContainerItem.Default);
randomContainerItem.Initialize((AudioRandomContainerSettings)settings, spatializer, parent);
item = randomContainerItem;
break;
case AudioItem.AudioTypes.EnumeratorContainer:
AudioEnumeratorContainerItem enumeratorContainerItem = Pool<AudioEnumeratorContainerItem>.Create(AudioEnumeratorContainerItem.Default);
enumeratorContainerItem.Initialize((AudioEnumeratorContainerSettings)settings, spatializer, parent);
item = enumeratorContainerItem;
break;
case AudioItem.AudioTypes.SwitchContainer:
AudioSwitchContainerItem switchContainerItem = Pool<AudioSwitchContainerItem>.Create(AudioSwitchContainerItem.Default);
switchContainerItem.Initialize((AudioSwitchContainerSettings)settings, spatializer, parent);
item = switchContainerItem;
break;
case AudioItem.AudioTypes.SequenceContainer:
AudioSequenceContainerItem sequenceContainerItem = Pool<AudioSequenceContainerItem>.Create(AudioSequenceContainerItem.Default);
sequenceContainerItem.Initialize((AudioSequenceContainerSettings)settings, spatializer, parent);
item = sequenceContainerItem;
break;
}
return item;
}
static void StopPreview()
{
if (AudioManager.Find() == null)
return;
if (_previewItem != null)
{
_previewItem.StopImmediate();
_previewItem = null;
_previewSettings = null;
}
}
public void Activate(AudioItem item)
{
_toUpdate.Add(item);
}
public void TrimInstances(AudioItem item, int maxInstances)
{
if (!_idActiveItems.ContainsKey(item.Id))
_idActiveItems[item.Id] = new List<AudioItem>();
List<AudioItem> _activeItems = _idActiveItems[item.Id];
if (maxInstances > 0)
while (_activeItems.Count >= maxInstances)
_activeItems.Pop().StopImmediate();
_idActiveItems[item.Id].Add(item);
}
public void Deactivate(AudioItem item)
{
if (_idActiveItems.ContainsKey(item.Id))
_idActiveItems[item.Id].Remove(item);
_toUpdate.Remove(item);
}
/// <summary>
/// Ergänzt eine neue Tonspur.
/// </summary>
/// <param name="sender">Wird ignoriert.</param>
/// <param name="e">Wird ignoriert.</param>
private void cmdAddAudio_Click( object sender, EventArgs e )
{
// Create new
AudioInformation audio = new AudioInformation { AudioType = AudioTypes.MP2, AudioStream = 0, Language = "Deutsch" };
// Create list
List<AudioInformation> audios = new List<AudioInformation>();
// Fill list
if (null != CurrentModifier.AudioStreams)
audios.AddRange( CurrentModifier.AudioStreams );
// Append new
audios.Add( audio );
// Push back
CurrentModifier.AudioStreams = audios.ToArray();
// New item
AudioItem item = new AudioItem( audio );
// Push back
selAudio.Items.Add( item );
// Select it
selAudio.SelectedItem = item;
// Update
selAudio_SelectedIndexChanged( selAudio, EventArgs.Empty );
// Enable edit
txAudioLanguage.Enabled = true;
selAudioType.Enabled = true;
selAudioPID.Enabled = true;
}
