Пример #1
0
        //save sequence
        private void button3_Click(object sender, RoutedEventArgs e)
        {
            if (SelectedSequence == null)
            {//add new sequence
                //SoundServiceSingleton.Instance.RemoveAllSoundsForUser(UserService.SelectedUser);
                SoundSequence soundSequence = new SoundSequence();
                foreach (var sound in SoundsInSequence)
                {
                    SoundSetting soundSetting = new SoundSetting()
                    {
                        Sound = sound
                    };
                    soundSequence.Sounds.Add(soundSetting);
                }

                if (IsUserSequence.HasValue && IsUserSequence.Value == true && UserService.SelectedUser != null)
                {
                    soundSequence.User = UserService.SelectedUser;
                }
                else
                {
                    soundSequence.User = null;
                }

                soundSequence.Name = SequenceName;

                SoundServiceSingleton.Instance.SaveSoundSequence(soundSequence);


                //reload sequences combobox after add new
                LoadSequences();
            }
            else
            {//update existing
                SelectedSequence.Name = SequenceName;
                SelectedSequence.Sounds.Clear();
                SoundsInSequence.ForEach(x => SelectedSequence.Sounds.Add(new SoundSetting()
                {
                    Sound = x
                }));

                if (IsUserSequence.HasValue && IsUserSequence.Value == true && UserService.SelectedUser != null)
                {
                    SelectedSequence.User = UserService.SelectedUser;
                }
                else
                {
                    SelectedSequence.User = null;
                }

                SoundServiceSingleton.Instance.SaveSoundSequence(SelectedSequence);
            }
        }
Пример #2
0
        public static SoundFile <ISoundFile> GetInfo(SoundArchive a, SoundArchive.NewFileEntryType type, int lastEntry, string filePath)
        {
            //File wizard.
            FileWizard w = new FileWizard();

            w.type = type;

            //Add existing files.
            foreach (var f in a.Files)
            {
                w.existingFiles.Items.Add(f.FileName + "." + f.FileExtension);
            }

            //Prepare info.
            w.referenceFileExternally.Enabled = false;
            w.referenceFileExternally.Checked = type == SoundArchive.NewFileEntryType.Stream;
            w.blankFile.Enabled       = type != SoundArchive.NewFileEntryType.Stream && type != SoundArchive.NewFileEntryType.Prefetch;
            w.useExistingFile.Checked = true;
            w.useExistingFile.Enabled = w.newFile.Checked = a.Files.Count == 0;
            w.useExistingFile.Enabled = !w.useExistingFile.Enabled;
            w.okButton.Enabled        = false;

            //Stream specifics.
            if (type == SoundArchive.NewFileEntryType.Stream)
            {
                w.blankFile.Enabled = false;
            }

            //Show.
            w.ShowDialog();

            //Return data.
            if (w.cancel)
            {
                return(new SoundFile <ISoundFile>()
                {
                    FileId = -1
                });
            }
            else
            {
                //Get versions.
                byte maj = 1;
                byte min = 0;
                byte rev = 0;

                //Use existing file.
                if (w.useExistingFile.Checked)
                {
                    return(new SoundFile <ISoundFile>()
                    {
                        Reference = a.Files[w.existingFiles.SelectedIndex]
                    });
                }

                //Use new file.
                else if (w.newFile.Checked)
                {
                    if (w.referenceFileExternally.Checked)
                    {
                        return(new SoundFile <ISoundFile>()
                        {
                            Reference = a.AddNewFile(type, lastEntry, null, false, GetRelativePath(w.newFilePath.Text, Path.GetDirectoryName(filePath)))
                        });
                    }
                    else
                    {
                        return(new SoundFile <ISoundFile>()
                        {
                            Reference = a.AddNewFile(type, lastEntry, SoundArchiveReader.ReadFile(File.ReadAllBytes(w.newFilePath.Text)))
                        });
                    }
                }

                //Blank file.
                else if (w.blankFile.Checked)
                {
                    ISoundFile f = null;
                    switch (type)
                    {
                    case SoundArchive.NewFileEntryType.Bank:
                        foreach (var fi in a.Files)
                        {
                            if (fi != null)
                            {
                                if (fi.File != null)
                                {
                                    var z = fi.File as SoundBank;
                                    if (z != null)
                                    {
                                        maj = z.Version.Major;
                                        min = z.Version.Minor;
                                        rev = z.Version.Revision;
                                        break;
                                    }
                                }
                            }
                        }
                        f = new SoundBank()
                        {
                            Version = new FileWriter.Version(maj, min, rev)
                        };
                        break;

                    case SoundArchive.NewFileEntryType.Group:
                        foreach (var fi in a.Files)
                        {
                            if (fi != null)
                            {
                                if (fi.File != null)
                                {
                                    var z = fi.File as Group;
                                    if (z != null)
                                    {
                                        maj = z.Version.Major;
                                        min = z.Version.Minor;
                                        rev = z.Version.Revision;
                                        break;
                                    }
                                }
                            }
                        }
                        f = new Group()
                        {
                            Version = new FileWriter.Version(maj, min, rev)
                        };
                        break;

                    case SoundArchive.NewFileEntryType.Sequence:
                        foreach (var fi in a.Files)
                        {
                            if (fi != null)
                            {
                                if (fi.File != null)
                                {
                                    var z = fi.File as SoundSequence;
                                    if (z != null)
                                    {
                                        maj = z.Version.Major;
                                        min = z.Version.Minor;
                                        rev = z.Version.Revision;
                                        break;
                                    }
                                }
                            }
                        }
                        f = new SoundSequence()
                        {
                            Version = new FileWriter.Version(maj, min, rev)
                        };
                        break;

                    case SoundArchive.NewFileEntryType.WaveArchive:
                        foreach (var fi in a.Files)
                        {
                            if (fi != null)
                            {
                                if (fi.File != null)
                                {
                                    var z = fi.File as SoundWaveArchive;
                                    if (z != null)
                                    {
                                        maj = z.Version.Major;
                                        min = z.Version.Minor;
                                        rev = z.Version.Revision;
                                        break;
                                    }
                                }
                            }
                        }
                        f = new SoundWaveArchive()
                        {
                            Version = new FileWriter.Version(maj, min, rev)
                        };
                        break;

                    case SoundArchive.NewFileEntryType.WaveSoundData:
                        foreach (var fi in a.Files)
                        {
                            if (fi != null)
                            {
                                if (fi.File != null)
                                {
                                    var z = fi.File as WaveSoundData;
                                    if (z != null)
                                    {
                                        maj = z.Version.Major;
                                        min = z.Version.Minor;
                                        rev = z.Version.Revision;
                                        break;
                                    }
                                }
                            }
                        }
                        f = new WaveSoundData()
                        {
                            Version = new FileWriter.Version(maj, min, rev)
                        };
                        break;
                    }
                    return(new SoundFile <ISoundFile>()
                    {
                        Reference = a.AddNewFile(type, lastEntry, f)
                    });
                }

                //Null file.
                else
                {
                    return(new SoundFile <ISoundFile>()
                    {
                        FileId = -2
                    });
                }
            }
        }
Пример #3
0
 public void SaveSoundSequence(SoundSequence soundSequence)
 {
     SoundSequenceRepositorySingleton.Instance.Save(soundSequence);
     SoundSequenceRepositorySingleton.Instance.Flush();
 }