Пример #1
0
        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            Core.SetWnd(this);
            CuelistCtrl.Init();
            FollowCtrl.Init();
            GoCtrl.Init();
            LogCtrl.Init();
            LogCtrl.Status("CueController 3.43b");
            MidiController.Init();
            MidiInputCtrl.Init();
            MidiOutputCtrl.Init();
            PbCtrl.Init();
            BeamerlistCtrl.Init();
            RecentFilesCtrl.Init();
            ReadWriteCtrl.Init();
            MatrixCtrl.Init();
            ScriptlistCtrl.Init();
            CopyCutCtrl.Init();
            OscCtrl.Init();
            OscListCtrl.Init();

            string[] args = Environment.GetCommandLineArgs();
            if (args.Length >= 2)
            {
                ReadWriteCtrl.Read(args[1]);
            }
        }
Пример #2
0
 /// <summary>
 /// Stop all runing processes, if programm is closed.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void MainWindow_Closed(object sender, System.EventArgs e)
 {
     MidiController.Close();
     MidiInputCtrl.Close();
     PbCtrl.Disconnect();
     OscCtrl.Close();
 }
Пример #3
0
        public static void ExecuteCueSend(Cue cue)
        {
            if (cue.send != null)
            {
                switch (cue.send.type)
                {
                case SendType.NOTE:
                    MidiOutputCtrl.SendNote(cue.send.note);
                    break;

                case SendType.MATRIX:
                    MatrixCtrl.SendMatrixCmd(cue.send.matrixCmd);
                    break;

                case SendType.MSC:
                    MidiOutputCtrl.SendMSC(cue.send.mscCmd);
                    break;

                case SendType.MUTE:
                    switch (cue.send.mute.Item1)
                    {
                    case MuteType.ALL:
                        MidiInputCtrl.NoteMute(cue.send.mute.Item2);
                        MidiInputCtrl.MscMute(cue.send.mute.Item2);
                        OscCtrl.OscMute(cue.send.mute.Item2);
                        break;

                    case MuteType.MSC:
                        MidiInputCtrl.MscMute(cue.send.mute.Item2);
                        break;

                    case MuteType.NOTE:
                        MidiInputCtrl.NoteMute(cue.send.mute.Item2);
                        break;

                    case MuteType.OSC:
                        OscCtrl.OscMute(cue.send.mute.Item2);
                        break;
                    }
                    break;

                case SendType.SC:
                    PbCtrl.Play(cue.send.pbCue);
                    break;

                case SendType.SCRIPT:
                    ScriptlistCtrl.ExecuteScript(cue.send.scriptNr);
                    break;

                case SendType.SHUTTER:
                    BeamerlistCtrl.Shutter(cue.send.beamerShutter.Item1, cue.send.beamerShutter.Item2);
                    break;

                case SendType.PB:
                    PbCtrl.ExecuteCmd(cue.send.pbCmd);
                    break;

                case SendType.OSC:
                    OscCtrl.Send(cue.send.oscCmd);
                    break;
                }
            }
        }
Пример #4
0
        private static void InterLoop()
        {
            try
            {
                float[] lastVal = new float[51];

                while (!_shouldStop)
                {
                    for (int i = 0; i < 51; ++i)
                    {
                        foreach (PbCmdArg pbCmdArg in ctrlVals.pbCmdArgs[i])
                        {
                            float scale = pbCmdArg.max - pbCmdArg.min;
                            float end   = pbCmdArg.min + (ccValues[i] * scale);

                            if (lastVal[i] != ccValues[i])
                            {
                                if (!initialized[i])
                                {
                                    pbCmdArg.val   = end;
                                    pbCmdArg.step  = 0;
                                    initialized[i] = true;

                                    Application.Current.Dispatcher.Invoke(new Action(() =>
                                    {
                                        PbCtrl.ExecuteCmdArg(pbCmdArg, pbCmdArg.val);
                                    }));
                                }
                                else
                                {
                                    float diff = end - pbCmdArg.val;
                                    float step = pbCmdArg.interp;
                                    if (step <= 0)
                                    {
                                        step = 1;
                                    }
                                    pbCmdArg.step = diff / step;
                                }
                            }

                            if (pbCmdArg.step < 0 && pbCmdArg.val > end || pbCmdArg.step > 0 && pbCmdArg.val < end)
                            {
                                pbCmdArg.val += pbCmdArg.step;

                                float min = Math.Min(pbCmdArg.min, pbCmdArg.max);
                                float max = Math.Max(pbCmdArg.min, pbCmdArg.max);

                                if (pbCmdArg.val < min)
                                {
                                    pbCmdArg.val = min;
                                }

                                else if (pbCmdArg.val > max)
                                {
                                    pbCmdArg.val = max;
                                }

                                Application.Current.Dispatcher.Invoke(new Action(() =>
                                {
                                    PbCtrl.ExecuteCmdArg(pbCmdArg, pbCmdArg.val);
                                }));
                            }
                        }

                        if (lastVal[i] != ccValues[i])
                        {
                            lastVal[i] = ccValues[i];

                            if (ccValues[i] <= 0)
                            {
                                foreach (PbCmd pbCmdOff in ctrlVals.pbCmdOff[i])
                                {
                                    Application.Current.Dispatcher.Invoke(new Action(() =>
                                    {
                                        PbCtrl.ExecuteCmd(pbCmdOff);
                                    }));
                                }

                                foreach (string ccCmdOff in ctrlVals.ccCmdOff[i])
                                {
                                    ExecuteCcCmd(ccCmdOff);
                                }
                            }
                            else if (ccValues[i] >= 1)
                            {
                                foreach (PbCmd pbCmdOn in ctrlVals.pbCmdOn[i])
                                {
                                    Application.Current.Dispatcher.Invoke(new Action(() =>
                                    {
                                        PbCtrl.ExecuteCmd(pbCmdOn);
                                    }));
                                }

                                foreach (string ccCmdOn in ctrlVals.ccCmdOn[i])
                                {
                                    ExecuteCcCmd(ccCmdOn);
                                }
                            }
                        }
                    }
                    Thread.Sleep(40);
                }
            }
            catch
            {
                LogCtrl.ThreadSafeError("MIDI Controller thread crashed!");
            }
        }