Beispiel #1
0
        /// <summary>
        /// Handler for ajax requests to /settings/gui
        /// </summary>
        /// <param name="ctx"></param>
        public static void Process(LPWebContext ctx)
        {
            try
            {
                string cmd = ctx.Request["cmd"] ?? "load";
                int    x = 0, y = 0;
                int.TryParse(ctx.Request["x"], out x);
                int.TryParse(ctx.Request["y"], out y);
                // TODO: add key commands

                switch (cmd.ToLower())
                {
                case "up":
                    UserSession.Current.Gui.Context.MouseUp(x, y);
                    break;

                case "down":
                    UserSession.Current.Gui.Context.MouseDown(x, y, System.Windows.Forms.Keys.None);
                    break;

                case "move":
                    UserSession.Current.Gui.Context.MouseMove(x, y);
                    break;

                default:
                    ctx.Response.Write(UserSession.Current.Gui.Context.GetLastRenderAsBase64());
                    break;
                }
            }
            catch (Exception ex)
            {
                ctx.Response.Send500(ex.ToString());
            }
        }
Beispiel #2
0
        /// <summary>
        /// Handler for ajax requests to /logs/
        /// </summary>
        /// <param name="ctx"></param>
        public static void Process(LPWebContext ctx)
        {
            try
            {
                string logType = GetFilename(ctx.Request.Path);

                // get requests for data since an ordinal
                int ordinal = 0;
                int.TryParse(ctx.Request["i"], out ordinal);



                switch (logType)
                {
                case "console":
                    ctx.Response.Write(JsonConvert.SerializeObject(UserSession.Current.Console.Messages.GetSinceOrdinal(ordinal)));
                    break;

                case "midi":
                    ctx.Response.Write(JsonConvert.SerializeObject(UserSession.Current.MidiMap.Log.GetSinceOrdinal(ordinal)));
                    break;

                case "osc":
                    ctx.Response.Write(JsonConvert.SerializeObject(UserSession.Current.OSC.Log.GetSinceOrdinal(ordinal)));
                    break;

                case "lag":
                    /*int count = 50;
                     * int.TryParse(ctx.Request["count"], out count);
                     * ctx.Response.Write(JsonConvert.SerializeObject(MIDI.MidiOutputThread.Lag.GetRecent(count)));
                     * break;*/
                    throw new Exception("lag screen is now obsolete.  will be replaces with full kernel debugger");

                default:
                    throw new Exception("Unknown log type: " + logType);
                }
            }
            catch (Exception ex)
            {
                ctx.Response.Send500(ex.ToString());
            }
        }
Beispiel #3
0
        /// <summary>
        /// Handler for ajax requests to /settings/implant
        /// </summary>
        /// <param name="ctx"></param>
        public static void Process(LPWebContext ctx)
        {
            try
            {
                string cmd = ctx.Request["cmd"] ?? "load";
                switch (cmd.ToLower())
                {
                case "implantlist":
                {
                    var files = Util.FileIO.ListFiles(
                        new Util.FilePath()
                        {
                            BaseFolder = Core.Settings.ImplantFolder,
                            Filename   = "*.js"
                        },
                        s => !s.StartsWith("~system/") && !Path.GetFileName(s).StartsWith(".")
                        );
                    ctx.Response.Write(JsonConvert.SerializeObject(files));
                }
                break;

                case "devicelist":
                {
                    // devices currently available for implant mapping
                    var deviceNames = new List <string>();
                    foreach (var mapping in UserSession.Current.Devices.Mapped)
                    {
                        // TODO: device which are appropriate to be mapped
                        if (mapping.Hardware is MIDI.Hardware.MidiXYHardwareInterface)
                        {
                            deviceNames.Add(mapping.Device.Name);
                        }
                    }
                    ctx.Response.Write(JsonConvert.SerializeObject(deviceNames));
                }
                break;

                case "save":
                {
                    // gotta parse out a new range object either way
                    var rangeJson = ImplantItemJson.Range.FromRequest(ctx.Request);
                    var range     = rangeJson.ToRangeMap();

                    // must be a new item if not found
                    var item = UserSession.Current.Implants.GetById(ctx.Request["id"]);
                    if (item == null)
                    {
                        var    vpath     = ctx.Request["vpath"];
                        var    id        = ctx.Request["id"];
                        string oscFormat = ctx.Request["oscFormat"];

                        int mode = 0;
                        int.TryParse(ctx.Request["mode"], out mode);

                        var implant = UserSession.Current.Implants.Load(vpath, range, oscFormat);
                        implant.AssignedMode = mode;
                        implant.ImplantID    = id;
                    }
                    else
                    {
                        var id = ctx.Request["id"];

                        /*
                         * var vpath = ctx.Request["vpath"];
                         * if (vpath != item.ImplantType.VPath) // TODO: point at vpath
                         * {
                         *  throw new Exception("Cannot current change the type of implant this way.");
                         * }
                         */

                        if (ctx.Request["oscFormat"] != null)
                        {
                            item.OscFormat = ctx.Request["oscFormat"];
                        }
                        item.ActiveArea = range;

                        if (ctx.Request["mode"] != null)
                        {
                            item.AssignedMode = int.Parse(ctx.Request["mode"]);
                        }
                    }
                    ctx.Response.Write("Saving ID #" + ctx.Request["id"]);
                    UserSession.Current.Save();
                }
                break;

                case "run":
                    UserSession.Current.Implants.Start(ctx.Request["id"]);
                    UserSession.Current.Save();
                    ctx.Response.Write("Running ID #" + ctx.Request["id"]);
                    break;

                case "stop":
                    UserSession.Current.Implants.Stop(ctx.Request["id"]);
                    UserSession.Current.Save();
                    ctx.Response.Write("Stopping ID #" + ctx.Request["id"]);
                    break;

                case "unload":
                    UserSession.Current.Implants.Unload(ctx.Request["id"]);
                    UserSession.Current.Save();
                    ctx.Response.Write("Unloading ID #" + ctx.Request["id"]);
                    break;

                case "reload":
                {
                    UserSession.Current.Implants.Reload(ctx.Request["id"]);
                    UserSession.Current.Save();
                    ctx.Response.Write("Reload ID #" + ctx.Request["id"]);
                }
                break;

                case "texteditor":
                {
                    // just for fun
                    var item = UserSession.Current.Implants.GetById(ctx.Request["id"]);
                    if (item == null)
                    {
                        throw new Exception("Could not find ImplantID " + ctx.Request["id"]);
                    }
                    Util.LPConsole.WriteLine("WebServer", "Starting text editor ({0}) on file {1}", Core.Settings.TextEditor, item.ImplantType.Path.FullPath);

                    var proc = new Process();
                    proc.StartInfo.FileName        = Core.Settings.Terminal;
                    proc.StartInfo.Arguments       = Core.Settings.TextEditor + " " + item.ImplantType.Path.FullPath;
                    proc.StartInfo.UseShellExecute = false;
                    proc.Start();

                    //System.Diagnostics.Process.Start(Core.Settings.TextEditor, item.ImplantType.Path.FullPath);
                    //System.Diagnostics.Process.Start(Core.Settings.TextEditor + " " + item.ImplantType.Path.FullPath);



                    ctx.Response.Write("Launching text editor for ID #" + ctx.Request["id"]);
                }
                break;

                default:
                {
                    // just return the list for all loaded implants
                    var list = new List <ImplantItemJson>();
                    foreach (var implant in UserSession.Current.Implants.Items)
                    {
                        list.Add(ImplantItemJson.Convert(implant));
                    }
                    ctx.Response.Write(JsonConvert.SerializeObject(list));
                }
                break;
                }
            }
            catch (Exception ex)
            {
                ctx.Response.Send500(ex.ToString());
            }
        }
        /// <summary>
        /// Handler for ajax requests to /settings/midimap
        /// </summary>
        /// <param name="ctx"></param>
        public static void Process(LPWebContext ctx)
        {
            try
            {
                string cmd = ctx.Request["cmd"] ?? "load";
                switch (cmd.ToLower())
                {
                case "outputdevices":     // list of MIDI devices we could output to
                {
                    var list = new List <string>();
                    list.Add("All Midi");
                    foreach (var d in UserSession.Current.Devices[typeof(MidiOutputHardwareInterface)])        //[MidiDeviceMapping.MidiOutput])
                    {
                        list.Add(d.Device.Name);
                    }
                    ctx.Response.Write(JsonConvert.SerializeObject(list));
                }
                break;

                case "implants":     // list of implants we could use as a source
                {
                    var list = new List <string>();
                    list.Add("Any Implant");
                    foreach (var i in UserSession.Current.Implants.Running)
                    {
                        list.Add(i.GetSourceName());
                    }
                    ctx.Response.Write(JsonConvert.SerializeObject(list));
                }
                break;

                case "save":
                {
                    var item = UserSession.Current.MidiMap.GetById(ctx.Request["id"]);

                    // must be a new item if not found
                    if (item == null)
                    {
                        item                 = new OscToMidiMap();
                        item.ID              = ctx.Request["id"];
                        item.OscAddress      = ctx.Request["oscAddress"];
                        item.OscValueFrom    = double.Parse(ctx.Request["oscValueFrom"]);
                        item.OscValueTo      = double.Parse(ctx.Request["oscValueTo"]);
                        item.OscSource       = ctx.Request["oscSource"];
                        item.MidiType        = ctx.Request["midiType"].GetMidiMessageType();  //OscToMidiMap.FromString(ctx.Request["midiType"]);
                        item.MidiNote        = ctx.Request["midiNote"];
                        item.MidiValueFrom   = int.Parse(ctx.Request["midiValueFrom"]);
                        item.MidiValueTo     = int.Parse(ctx.Request["midiValueTo"]);
                        item.MidiDestination = ctx.Request["midiDestination"];
                        if (item.OscSource.ToLower() == "any implant")
                        {
                            item.OscSource = null;
                        }
                        if (item.MidiDestination.ToLower() == "all midi")
                        {
                            item.MidiDestination = null;
                        }
                        UserSession.Current.MidiMap.Mappings.Add(item);
                    }
                    else
                    {
                        item.OscAddress      = ctx.Request["oscAddress"];
                        item.OscValueFrom    = double.Parse(ctx.Request["oscValueFrom"]);
                        item.OscValueTo      = double.Parse(ctx.Request["oscValueTo"]);
                        item.OscSource       = ctx.Request["oscSource"];
                        item.MidiType        = ctx.Request["midiType"].GetMidiMessageType();
                        item.MidiNote        = ctx.Request["midiNote"];
                        item.MidiValueFrom   = int.Parse(ctx.Request["midiValueFrom"]);
                        item.MidiValueTo     = int.Parse(ctx.Request["midiValueTo"]);
                        item.MidiDestination = ctx.Request["midiDestination"];
                        if (item.OscSource.ToLower() == "any implant")
                        {
                            item.OscSource = null;
                        }
                        if (item.MidiDestination.ToLower() == "all midi")
                        {
                            item.MidiDestination = null;
                        }
                    }
                    ctx.Response.Write("Saving ID #" + ctx.Request["id"]);
                    UserSession.Current.Save();
                }
                break;

                case "remove":
                {
                    UserSession.Current.MidiMap.DeleteById(ctx.Request["id"]);
                    UserSession.Current.Save();
                    ctx.Response.Write("Deleting ID #" + ctx.Request["id"]);
                }
                break;

                default:
                {
                    // just return the list for all current device mappings
                    var list = new List <MappingItemJson>();
                    foreach (var mapping in UserSession.Current.MidiMap.Mappings)
                    {
                        var item = new MappingItemJson();
                        item.id              = mapping.ID;
                        item.oscSource       = mapping.OscSource ?? "Any Implant";
                        item.oscAddress      = mapping.OscAddress;
                        item.oscValueFrom    = mapping.OscValueFrom;
                        item.oscValueTo      = mapping.OscValueTo;
                        item.midiDestination = mapping.MidiDestination ?? "All Midi";
                        item.midiType        = mapping.MidiType.GetString();
                        item.midiNote        = mapping.MidiNote;
                        item.midiValueFrom   = mapping.MidiValueFrom;
                        item.midiValueTo     = mapping.MidiValueTo;
                        list.Add(item);
                    }
                    ctx.Response.Write(JsonConvert.SerializeObject(list));
                }
                break;
                }
            }
            catch (Exception ex)
            {
                ctx.Response.Send500(ex.ToString());
            }
        }
Beispiel #5
0
        /// <summary>
        /// Handler for ajax requests to /settings/devices
        /// </summary>
        /// <param name="ctx"></param>
        public static void Process(LPWebContext ctx)
        {
            try
            {
                string cmd = ctx.Request["cmd"] ?? "load";
                switch (cmd.ToLower())
                {
                case "interfaces":
                {
                    // list of all products supported
                    ctx.Response.Write(JsonConvert.SerializeObject(MIDI.Hardware.MidiHardwareTypes.Available));
                }
                break;

                case "map":
                {
                    // change device mapping
                    var id       = ctx.Request["id"];
                    var mappedAs = ctx.Request["mappedAs"];
                    UserSession.Current.Devices.Map(id, mappedAs);        //.GetMidiDeviceMapping());
                    UserSession.Current.Save();
                }
                break;

                case "enable":
                {
                    // change enabled flag on device
                    var  id      = ctx.Request["id"];
                    bool enabled = false;
                    if (bool.TryParse(ctx.Request["enabled"], out enabled))
                    {
                        UserSession.Current.Devices.GetMappedDeviceById(id).Enabled = enabled;
                        UserSession.Current.Save();
                    }
                }
                break;

                case "refresh":
                {
                    UserSession.Current.Devices.Refresh();
                }
                break;

                default:
                {
                    // just return the list for all current device mappings
                    var list = new List <DeviceItemJson>();
                    foreach (var device in UserSession.Current.Devices.Available)
                    {
                        var mapping = UserSession.Current.Devices.GetMapping(device);
                        var item    = new DeviceItemJson();
                        item.id        = device.ID;
                        item.name      = device.Name;
                        item.hasInput  = device.CanRead;
                        item.hasOutput = device.CanWrite;
                        //MidiDeviceMapping mappedAs = mapping == null ? MidiDeviceMapping.None : mapping.MappedAs;
//                                item.mappedAs = mappedAs.GetString();
                        item.mappedAs = mapping == null || mapping.Hardware == null ? "---" : mapping.Hardware.Name;
                        item.enabled  = mapping == null ? false : mapping.Enabled;
                        list.Add(item);
                    }
                    ctx.Response.Write(JsonConvert.SerializeObject(list));
                }
                break;
                }
            }
            catch (Exception ex)
            {
                ctx.Response.Send500(ex.ToString());
            }
        }