CycleButton() public static method

public static CycleButton ( int selected, GUIContent options ) : int
selected int
options GUIContent
return int
        public override void OnPreviewSettings()
        {
            MovieTextureInspector.Init();
            EditorGUI.BeginDisabledGroup(Application.isPlaying || this.targets.Length > 1);
            MovieTexture target    = this.target as MovieTexture;
            AudioClip    audioClip = target.audioClip;
            bool         flag      = PreviewGUI.CycleButton(!target.isPlaying ? 0 : 1, MovieTextureInspector.s_PlayIcons) != 0;

            if (flag != target.isPlaying)
            {
                if (flag)
                {
                    target.Stop();
                    target.Play();
                    if ((Object)audioClip != (Object)null)
                    {
                        AudioUtil.PlayClip(audioClip);
                    }
                }
                else
                {
                    target.Pause();
                    if ((Object)audioClip != (Object)null)
                    {
                        AudioUtil.PauseClip(audioClip);
                    }
                }
            }
            EditorGUI.EndDisabledGroup();
        }
        public override void OnPreviewSettings()
        {
            MovieTextureInspector.Init();
            EditorGUI.BeginDisabledGroup(Application.isPlaying || base.targets.Length > 1);
            MovieTexture movieTexture = this.target as MovieTexture;
            AudioClip    audioClip    = movieTexture.audioClip;
            bool         flag         = PreviewGUI.CycleButton((!movieTexture.isPlaying) ? 0 : 1, MovieTextureInspector.s_PlayIcons) != 0;

            if (flag != movieTexture.isPlaying)
            {
                if (flag)
                {
                    movieTexture.Stop();
                    movieTexture.Play();
                    if (audioClip != null)
                    {
                        AudioUtil.PlayClip(audioClip);
                    }
                }
                else
                {
                    movieTexture.Pause();
                    if (audioClip != null)
                    {
                        AudioUtil.PauseClip(audioClip);
                    }
                }
            }
            EditorGUI.EndDisabledGroup();
        }
Beispiel #3
0
        public override void OnPreviewSettings()
        {
            Init();

            // Disallow playing movie previews in play mode. Better not to interfere
            // with any playback the game does.
            // Also disallow if more than one MovieClip selected (for now).
            using (new EditorGUI.DisabledScope(Application.isPlaying || targets.Length > 1))
            {
                MovieTexture t         = target as MovieTexture;
                AudioClip    ac        = t.audioClip;
                bool         isPlaying = PreviewGUI.CycleButton(t.isPlaying ? 1 : 0, s_PlayIcons) != 0;
                if (isPlaying != t.isPlaying)
                {
                    if (isPlaying)
                    {
                        t.Stop();
                        t.Play();
                        if (ac != null)
                        {
                            AudioUtil.PlayClip(ac);
                        }
                    }
                    else
                    {
                        t.Pause();
                        if (ac != null)
                        {
                            AudioUtil.PauseClip(ac);
                        }
                    }
                }
            }
        }
 public override void OnPreviewSettings()
 {
     Init();
     using (new EditorGUI.DisabledScope(Application.isPlaying || (base.targets.Length > 1)))
     {
         MovieTexture target    = base.target as MovieTexture;
         AudioClip    audioClip = target.audioClip;
         bool         flag      = PreviewGUI.CycleButton(!target.isPlaying ? 0 : 1, s_PlayIcons) != 0;
         if (flag != target.isPlaying)
         {
             if (flag)
             {
                 target.Stop();
                 target.Play();
                 if (audioClip != null)
                 {
                     AudioUtil.PlayClip(audioClip);
                 }
             }
             else
             {
                 target.Pause();
                 if (audioClip != null)
                 {
                     AudioUtil.PauseClip(audioClip);
                 }
             }
         }
     }
 }
        public override void OnPreviewSettings()
        {
            VideoClipImporter importer = (VideoClipImporter)target;

            EditorGUI.BeginDisabledGroup(Application.isPlaying);
            m_IsPlaying = PreviewGUI.CycleButton(m_IsPlaying ? 1 : 0, s_Styles.playIcons) != 0;
            EditorGUI.EndDisabledGroup();
        }
        public override void OnPreviewSettings()
        {
            VideoClipImporter videoClipImporter = (VideoClipImporter)base.target;

            EditorGUI.BeginDisabledGroup(Application.isPlaying || this.HasModified() || videoClipImporter.useLegacyImporter);
            this.m_IsPlaying = (PreviewGUI.CycleButton((!this.m_IsPlaying) ? 0 : 1, VideoClipImporterInspector.s_Styles.playIcons) != 0);
            EditorGUI.EndDisabledGroup();
        }
Beispiel #7
0
        public override void OnPreviewSettings()
        {
            if (s_DefaultIcon == null)
            {
                Init();
            }

            AudioClip clip = target as AudioClip;

            using (new EditorGUI.DisabledScope(AudioUtil.IsMovieAudio(clip)))
            {
                bool isEditingMultipleObjects = targets.Length > 1;

                using (new EditorGUI.DisabledScope(isEditingMultipleObjects))
                {
                    bool oldAutoPlay = isEditingMultipleObjects ? false : m_bAutoPlay;
                    bool newAutoPlay = PreviewGUI.CycleButton(oldAutoPlay ? 1 : 0, s_AutoPlayIcons) != 0;
                    if (oldAutoPlay != newAutoPlay)
                    {
                        m_bAutoPlay = newAutoPlay;
                        InspectorWindow.RepaintAllInspectors();
                    }

                    bool oldLoop = isEditingMultipleObjects ? false : m_bLoop;
                    bool newLoop = PreviewGUI.CycleButton(oldLoop ? 1 : 0, s_LoopIcons) != 0;
                    if (oldLoop != newLoop)
                    {
                        m_bLoop = newLoop;
                        if (playing)
                        {
                            AudioUtil.LoopClip(clip, newLoop);
                        }
                        InspectorWindow.RepaintAllInspectors();
                    }
                }

                using (new EditorGUI.DisabledScope(isEditingMultipleObjects && !playing && m_PlayingInspector != this))
                {
                    bool curPlaying = m_PlayingInspector == this && playing;
                    bool newPlaying = PreviewGUI.CycleButton(curPlaying ? 1 : 0, s_PlayIcons) != 0;

                    if (newPlaying != curPlaying)
                    {
                        AudioUtil.StopAllClips();

                        if (newPlaying)
                        {
                            AudioUtil.PlayClip(clip, 0, m_bLoop);
                            m_PlayingClip      = clip;
                            m_PlayingInspector = this;
                        }
                    }
                }
            }
        }
        public override void OnPreviewSettings()
        {
            if (AudioClipInspector.s_DefaultIcon == null)
            {
                AudioClipInspector.Init();
            }
            AudioClip audioClip = base.target as AudioClip;

            using (new EditorGUI.DisabledScope(AudioUtil.IsMovieAudio(audioClip)))
            {
                bool flag = base.targets.Length > 1;
                using (new EditorGUI.DisabledScope(flag))
                {
                    bool flag2 = !flag && AudioClipInspector.m_bAutoPlay;
                    bool flag3 = PreviewGUI.CycleButton((!flag2) ? 0 : 1, AudioClipInspector.s_AutoPlayIcons) != 0;
                    if (flag2 != flag3)
                    {
                        AudioClipInspector.m_bAutoPlay = flag3;
                        InspectorWindow.RepaintAllInspectors();
                    }
                    bool flag4 = !flag && AudioClipInspector.m_bLoop;
                    bool flag5 = PreviewGUI.CycleButton((!flag4) ? 0 : 1, AudioClipInspector.s_LoopIcons) != 0;
                    if (flag4 != flag5)
                    {
                        AudioClipInspector.m_bLoop = flag5;
                        if (AudioClipInspector.playing)
                        {
                            AudioUtil.LoopClip(audioClip, flag5);
                        }
                        InspectorWindow.RepaintAllInspectors();
                    }
                }
                using (new EditorGUI.DisabledScope(flag && !AudioClipInspector.playing && AudioClipInspector.m_PlayingInspector != this))
                {
                    bool flag6 = AudioClipInspector.m_PlayingInspector == this && AudioClipInspector.playing;
                    bool flag7 = PreviewGUI.CycleButton((!flag6) ? 0 : 1, AudioClipInspector.s_PlayIcons) != 0;
                    if (flag7 != flag6)
                    {
                        AudioUtil.StopAllClips();
                        if (flag7)
                        {
                            AudioUtil.PlayClip(audioClip, 0, AudioClipInspector.m_bLoop);
                            AudioClipInspector.m_PlayingClip      = audioClip;
                            AudioClipInspector.m_PlayingInspector = this;
                        }
                    }
                }
            }
        }
        public override void OnPreviewSettings()
        {
            if (s_DefaultIcon == null)
            {
                Init();
            }

            AudioClip clip = target as AudioClip;

            m_MultiEditing = targets.Length > 1;

            {
                using (new EditorGUI.DisabledScope(m_MultiEditing))
                {
                    s_AutoPlay = s_AutoPlay && !m_MultiEditing;
                    s_AutoPlay = PreviewGUI.CycleButton(s_AutoPlay ? 1 : 0, s_AutoPlayIcons) != 0;
                }

                bool loop = s_Loop;
                s_Loop = PreviewGUI.CycleButton(s_Loop ? 1 : 0, s_LoopIcons) != 0;
                if ((loop != s_Loop) && playing)
                {
                    AudioUtil.LoopClip(clip, s_Loop);
                }

                using (new EditorGUI.DisabledScope(m_MultiEditing && !playing))
                {
                    bool newPlaying = PreviewGUI.CycleButton(playing ? 1 : 0, s_PlayIcons) != 0;

                    if (newPlaying != playing)
                    {
                        if (newPlaying)
                        {
                            PlayClip(clip, 0, s_Loop);
                        }
                        else
                        {
                            AudioUtil.StopClip(m_Clip);
                            m_Clip            = null;
                            s_PlayingInstance = null;
                        }
                    }
                }
            }
        }
        public override void OnPreviewSettings()
        {
            if (AudioClipInspector.s_DefaultIcon == null)
            {
                AudioClipInspector.Init();
            }
            AudioClip audioClip = base.target as AudioClip;

            using (new EditorGUI.DisabledScope(AudioUtil.IsMovieAudio(audioClip)))
            {
                bool flag = base.targets.Length > 1;
                using (new EditorGUI.DisabledScope(flag))
                {
                    AudioClipInspector.m_bAutoPlay = (!flag && AudioClipInspector.m_bAutoPlay);
                    AudioClipInspector.m_bAutoPlay = (PreviewGUI.CycleButton((!AudioClipInspector.m_bAutoPlay) ? 0 : 1, AudioClipInspector.s_AutoPlayIcons) != 0);
                }
                bool bLoop = AudioClipInspector.m_bLoop;
                AudioClipInspector.m_bLoop = (PreviewGUI.CycleButton((!AudioClipInspector.m_bLoop) ? 0 : 1, AudioClipInspector.s_LoopIcons) != 0);
                if (bLoop != AudioClipInspector.m_bLoop && this.playing)
                {
                    AudioUtil.LoopClip(audioClip, AudioClipInspector.m_bLoop);
                }
                using (new EditorGUI.DisabledScope(flag && !this.playing))
                {
                    bool flag2 = PreviewGUI.CycleButton((!this.playing) ? 0 : 1, AudioClipInspector.s_PlayIcons) != 0;
                    if (flag2 != this.playing)
                    {
                        if (flag2)
                        {
                            AudioUtil.PlayClip(audioClip, 0, AudioClipInspector.m_bLoop);
                            this.m_PlayingClip = audioClip;
                        }
                        else
                        {
                            AudioUtil.StopAllClips();
                            this.m_PlayingClip = null;
                        }
                    }
                }
            }
        }
        public override void OnPreviewSettings()
        {
            if ((UnityEngine.Object)AudioClipInspector.s_DefaultIcon == (UnityEngine.Object)null)
            {
                AudioClipInspector.Init();
            }
            AudioClip target = this.target as AudioClip;

            EditorGUI.BeginDisabledGroup(AudioUtil.IsMovieAudio(target));
            bool disabled = this.targets.Length > 1;

            EditorGUI.BeginDisabledGroup(disabled);
            AudioClipInspector.m_bAutoPlay = !disabled && AudioClipInspector.m_bAutoPlay;
            AudioClipInspector.m_bAutoPlay = PreviewGUI.CycleButton(!AudioClipInspector.m_bAutoPlay ? 0 : 1, AudioClipInspector.s_AutoPlayIcons) != 0;
            EditorGUI.EndDisabledGroup();
            bool bLoop = AudioClipInspector.m_bLoop;

            AudioClipInspector.m_bLoop = PreviewGUI.CycleButton(!AudioClipInspector.m_bLoop ? 0 : 1, AudioClipInspector.s_LoopIcons) != 0;
            if (bLoop != AudioClipInspector.m_bLoop && this.playing)
            {
                AudioUtil.LoopClip(target, AudioClipInspector.m_bLoop);
            }
            EditorGUI.BeginDisabledGroup(disabled && !this.playing);
            bool flag = PreviewGUI.CycleButton(!this.playing ? 0 : 1, AudioClipInspector.s_PlayIcons) != 0;

            if (flag != this.playing)
            {
                if (flag)
                {
                    AudioUtil.PlayClip(target, 0, AudioClipInspector.m_bLoop);
                    this.m_PlayingClip = target;
                }
                else
                {
                    AudioUtil.StopAllClips();
                    this.m_PlayingClip = (AudioClip)null;
                }
            }
            EditorGUI.EndDisabledGroup();
            EditorGUI.EndDisabledGroup();
        }
Beispiel #12
0
        public override void OnPreviewSettings()
        {
            if (s_DefaultIcon == null)
            {
                Init();
            }
            AudioClip target = this.target as AudioClip;

            EditorGUI.BeginDisabledGroup(AudioUtil.IsMovieAudio(target));
            bool disabled = base.targets.Length > 1;

            EditorGUI.BeginDisabledGroup(disabled);
            m_bAutoPlay = !disabled ? m_bAutoPlay : false;
            m_bAutoPlay = PreviewGUI.CycleButton(!m_bAutoPlay ? 0 : 1, s_AutoPlayIcons) != 0;
            EditorGUI.EndDisabledGroup();
            bool bLoop = m_bLoop;

            m_bLoop = PreviewGUI.CycleButton(!m_bLoop ? 0 : 1, s_LoopIcons) != 0;
            if ((bLoop != m_bLoop) && this.playing)
            {
                AudioUtil.LoopClip(target, m_bLoop);
            }
            EditorGUI.BeginDisabledGroup(disabled && !this.playing);
            bool flag3 = PreviewGUI.CycleButton(!this.playing ? 0 : 1, s_PlayIcons) != 0;

            if (flag3 != this.playing)
            {
                if (flag3)
                {
                    AudioUtil.PlayClip(target, 0, m_bLoop);
                    this.m_PlayingClip = target;
                }
                else
                {
                    AudioUtil.StopAllClips();
                    this.m_PlayingClip = null;
                }
            }
            EditorGUI.EndDisabledGroup();
            EditorGUI.EndDisabledGroup();
        }
        public override void OnPreviewSettings()
        {
            WebCamTextureInspector.Init();
            GUI.enabled = !Application.isPlaying;
            WebCamTexture webCamTexture = base.target as WebCamTexture;
            bool          flag          = PreviewGUI.CycleButton((!webCamTexture.isPlaying) ? 0 : 1, WebCamTextureInspector.s_PlayIcons) != 0;

            if (flag != webCamTexture.isPlaying)
            {
                if (flag)
                {
                    webCamTexture.Stop();
                    webCamTexture.Play();
                }
                else
                {
                    webCamTexture.Pause();
                }
            }
            GUI.enabled = true;
        }
        public override void OnPreviewSettings()
        {
            Init();
            GUI.enabled = !Application.isPlaying;
            WebCamTexture target = this.target as WebCamTexture;
            bool          flag   = PreviewGUI.CycleButton(!target.isPlaying ? 0 : 1, s_PlayIcons) != 0;

            if (flag != target.isPlaying)
            {
                if (flag)
                {
                    target.Stop();
                    target.Play();
                }
                else
                {
                    target.Pause();
                }
            }
            GUI.enabled = true;
        }
        public override void OnPreviewSettings()
        {
            Init();

            // Disallow playing movie previews in play mode. Better not to interfere
            // with any playback the game does.
            GUI.enabled = !Application.isPlaying;
            WebCamTexture t         = target as WebCamTexture;
            bool          isPlaying = PreviewGUI.CycleButton(t.isPlaying ? 1 : 0, s_PlayIcons) != 0;

            if (isPlaying != t.isPlaying)
            {
                if (isPlaying)
                {
                    t.Stop();
                    t.Play();
                }
                else
                {
                    t.Pause();
                }
            }
            GUI.enabled = true;
        }
 public override void OnPreviewSettings()
 {
     EditorGUI.BeginDisabledGroup(Application.isPlaying);
     m_IsPlaying = PreviewGUI.CycleButton(m_IsPlaying ? 1 : 0, Styles.playIcons) != 0;
     EditorGUI.EndDisabledGroup();
 }