VRPNGUIController.cs

Go to the documentation of this file.

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.UI;
using System;

namespace VRPN
{
    // A GUI controller for the VRPN GUI.
    // This controller must be instantiated as a component to the top-level canvas/game object of the GUI.
    public class VRPNGUIController: MonoBehaviour {

        // The state of the VRPN connections GUI.
        // It is used during a tool instance selection to restore the GUI widgets values as expected.
        struct VRPNToolConnections {
            public string ff_server;
            public bool ff_server_connected;
            public string tracker_server;
            public bool tracker_server_connected;
            public string buttons_server;
            public bool buttons_server_connected;

            public VRPNToolConnections(string ff_server = default(String), bool ff_server_connected = false, string tracker_server = default(String), bool tracker_server_connected = false, string buttons_server = default(String), bool buttons_server_connected = false) {
                this.ff_server = ff_server;
                this.ff_server_connected = ff_server_connected;
                this.tracker_server = tracker_server;
                this.tracker_server_connected = tracker_server_connected;
                this.buttons_server = buttons_server;
                this.buttons_server_connected = buttons_server_connected;
            }
        }

        /*
         * References to GUI elements.
         */
        Dropdown tool_types_dropdown;
        Button tool_addition_button;

        Dropdown tools_dropdown;
        Button tool_deletion_button;

        InputField tool_ff_server_field;
        InputField tool_tracker_server_field;
        InputField tool_buttons_server_field;

        Toggle tool_ff_server_toggle;
        Toggle tool_tracker_server_toggle;
        Toggle tool_buttons_server_toggle;

        // A reference to the globally available VRPN manager.
        VRPNManager manager;

        // The index of the currently GUI selected tool.
        int current_tool_index;

        // The list of VRPN connections for each instantiated tool.
        List<VRPNToolConnections> connections = new List<VRPNToolConnections>();

        // Find and setup GUI elements in the canvas children.
        // Set the controller and the associated GUI into the expected state.
        public void Start() {
            manager = UnityMolMain.getVRPNManager();
            current_tool_index = 0;

            tool_types_dropdown = transform.Find("Tools Canvas/Tools Dropdown").gameObject.GetComponent<Dropdown>();
            tool_addition_button = transform.Find("Tools Canvas/Tools Addition Button").gameObject.GetComponent<Button>();

            tools_dropdown = transform.Find("Tools Canvas/Tool Instances Dropdown").gameObject.GetComponent<Dropdown>();
            tool_deletion_button = transform.Find("Tools Canvas/Tool Deletion Button").gameObject.GetComponent<Button>();

            tool_ff_server_field = transform.Find("Connections Canvas/FF Server Field").gameObject.GetComponent<InputField>();
            tool_tracker_server_field = transform.Find("Connections Canvas/Tracker Server Field").gameObject.GetComponent<InputField>();
            tool_buttons_server_field = transform.Find("Connections Canvas/Buttons Server Field").gameObject.GetComponent<InputField>();

            tool_ff_server_field.onValueChanged.AddListener(delegate{ResetFieldColorBlock(tool_ff_server_field);});
            tool_tracker_server_field.onValueChanged.AddListener(delegate{ResetFieldColorBlock(tool_tracker_server_field);});
            tool_buttons_server_field.onValueChanged.AddListener(delegate{ResetFieldColorBlock(tool_buttons_server_field);});

            tool_addition_button.onClick.AddListener(() => CreateTool());
            tools_dropdown.onValueChanged.AddListener((int tool_index) => SelectTool(tool_index));
            tool_deletion_button.onClick.AddListener(() => DeleteTool());

            tool_ff_server_toggle = transform.Find("Connections Canvas/FF Server Toggle").gameObject.GetComponent<Toggle>();
            tool_tracker_server_toggle = transform.Find("Connections Canvas/Tracker Server Toggle").gameObject.GetComponent<Toggle>();
            tool_buttons_server_toggle = transform.Find("Connections Canvas/Buttons Server Toggle").gameObject.GetComponent<Toggle>();

            tool_ff_server_toggle.isOn = false;
            tool_tracker_server_toggle.isOn = false;
            tool_buttons_server_toggle.isOn = false;

            tool_ff_server_toggle.onValueChanged.AddListener(ToggleFFServer);
            tool_tracker_server_toggle.onValueChanged.AddListener(ToggleTrackerServer);
            tool_buttons_server_toggle.onValueChanged.AddListener(ToggleButtonsServer);

            DisableToolConnectionsPanel();
        }

        void ResetFieldColorBlock(InputField f) {
            f.colors = ColorBlock.defaultColorBlock;
        }

        void Update() {
            this.manager.DeviceLoop();
        }

        //
        // Where most of the magic happens.
        // You will find here a few procedures setting the GUI state as expected and the widget callbacks.
        // See the "Start()" procedure to find callbacks associations.
        //

        void RestoreToolConnectionsState(VRPNToolConnections c) {
            tool_ff_server_field.text = c.ff_server;
            tool_ff_server_toggle.isOn = c.ff_server_connected;

            tool_tracker_server_field.text = c.tracker_server;
            tool_tracker_server_toggle.isOn = c.tracker_server_connected;

            tool_buttons_server_field.text = c.buttons_server;
            tool_buttons_server_toggle.isOn = c.buttons_server_connected;

            tool_ff_server_field.interactable = !c.ff_server_connected;
            tool_tracker_server_field.interactable = !c.tracker_server_connected;
            tool_buttons_server_field.interactable = !c.buttons_server_connected;
        }

        void EnableToolConnectionsPanel() {
            tool_ff_server_field.interactable = true;
            tool_ff_server_toggle.interactable = true;
            tool_tracker_server_field.interactable = true;
            tool_tracker_server_toggle.interactable = true;
            tool_buttons_server_field.interactable = true;
            tool_buttons_server_toggle.interactable = true;
        }

        void DisableToolConnectionsPanel() {
            tool_ff_server_field.interactable = false;
            tool_ff_server_toggle.interactable = false;
            tool_tracker_server_field.interactable = false;
            tool_tracker_server_toggle.interactable = false;
            tool_buttons_server_field.interactable = false;
            tool_buttons_server_toggle.interactable = false;
        }

        void EmptyToolConnectionsPanel() {
            tool_ff_server_field.text = "";
            tool_tracker_server_field.text = "";
            tool_buttons_server_field.text = "";
            tool_ff_server_toggle.isOn = false;
            tool_tracker_server_toggle.isOn = false;
            tool_buttons_server_toggle.isOn = false;
        }

        void CreateTool() {
            VRPNToolType tool_type = (VRPNToolType)Enum.ToObject(typeof(VRPNToolType), tool_types_dropdown.value);

            int index = manager.InstantiateTool(tool_type);

            Dropdown.OptionData od = new Dropdown.OptionData();
            od.text = tool_type.ToString();

            List<Dropdown.OptionData> lod = new List<Dropdown.OptionData>();
            lod.Add(od);

            VRPNToolConnections connection_strings_instance = new VRPNToolConnections(String.Empty, false, String.Empty, false, String.Empty, false);
            connections.Add(connection_strings_instance);

            tools_dropdown.AddOptions(lod);

            tool_deletion_button.interactable = true;

            EnableToolConnectionsPanel();

            SelectTool(index);

            tools_dropdown.value = index;
        }

        void DeleteTool() {
            int current_tool = tools_dropdown.value;

            tools_dropdown.options.RemoveAt(current_tool);

            connections.RemoveAt(current_tool);

            tools_dropdown.value = 0;

            if (tools_dropdown.options.Count == 0)
            {
                EmptyToolConnectionsPanel();
                DisableToolConnectionsPanel();
                tools_dropdown.ClearOptions();
                tool_deletion_button.interactable = false;
            }

            manager.RemoveTool(current_tool);
        }

        void SelectTool(int tool_index) {
            Debug.Log("Tool Selection Callback");
            Debug.Log("Selected tool: " + tool_index);

            current_tool_index = tool_index;

            VRPNToolConnections c = connections[tool_index];

            tool_ff_server_field.text = c.ff_server;
            tool_tracker_server_field.text = c.tracker_server;
            tool_buttons_server_field.text = c.buttons_server;

            EnableToolConnectionsPanel();

            RestoreToolConnectionsState(c);
        }

        void ToggleFFServer(bool isOn) {
            // This callback gets called even when setting the GUI state programmatically.
            //  It thus can be executed when there is no tool instance, so no connections.
            VRPNToolConnections current_c;
            try {
                current_c = connections[current_tool_index];
            }
            catch (ArgumentOutOfRangeException) {
                return;
            }

            if (isOn) {
                current_c.ff_server = tool_ff_server_field.text;
                current_c.ff_server_connected = true;

                connections[current_tool_index] = current_c;

                ConnectToFFServer(current_tool_index);
            }
            else {
                current_c.ff_server_connected = false;

                connections[current_tool_index] = current_c;

                DisconnectFromFFServer(current_tool_index);
            }
        }

        void ToggleTrackerServer(bool isOn) {
            // This callback gets called even when setting the GUI state programmatically.
            //  It thus can be executed when there is no tool instance, so no connections.
            VRPNToolConnections current_c;
            try {
                current_c = connections[current_tool_index];
            }
            catch (ArgumentOutOfRangeException) {
                return;
            }

            if (isOn) {
                current_c.tracker_server = tool_tracker_server_field.text;
                current_c.tracker_server_connected = true;

                connections[current_tool_index] = current_c;

                ConnectToTrackerServer(current_tool_index);
            }
            else {
                current_c.tracker_server_connected = false;

                connections[current_tool_index] = current_c;

                DisconnectFromTrackerServer(current_tool_index);
            }
        }

        void ToggleButtonsServer(bool isOn) {
            // This callback gets called even when setting the GUI state programmatically.
            //  It thus can be executed when there is no tool instance, so no connections.
            VRPNToolConnections current_c;
            try {
                current_c = connections[current_tool_index];
            }
            catch (ArgumentOutOfRangeException) {
                return;
            }

            if (isOn) {
                current_c.buttons_server = tool_buttons_server_field.text;
                current_c.tracker_server_connected = true;

                connections[current_tool_index] = current_c;

                ConnectToButtonsServer(current_tool_index);
            }
            else {
                current_c.tracker_server_connected = false;

                connections[current_tool_index] = current_c;

                DisconnectFromButtonsServer(current_tool_index);
            }
        }

        void ConnectToFFServer(int tool_index) {
            Debug.Log("ConnectToFFServer");
            bool result = manager.ConnectToolToForceFeedback(tool_index, tool_ff_server_field.text);
            if (result == false) {
                ColorBlock cb = tool_ff_server_field.colors;
                cb.normalColor = new Color(1f, 0.4f, 0.4f);
                cb.highlightedColor = new Color(1f, 0.4f, 0.4f);
                tool_ff_server_field.colors = cb;
                tool_ff_server_toggle.isOn = false;
            } else {
                tool_ff_server_field.interactable = false;
            }
        }

        void ConnectToTrackerServer(int tool_index) {
            Debug.Log("ConnectToTrackerServer");
            bool result = manager.ConnectToolToTracker(tool_index, tool_tracker_server_field.text);
            if (result == false) {
                ColorBlock cb = tool_tracker_server_field.colors;
                cb.normalColor = new Color(1f, 0.4f, 0.4f);
                cb.highlightedColor = new Color(1f, 0.4f, 0.4f);
                tool_tracker_server_field.colors = cb;
                tool_tracker_server_toggle.isOn = false;
            } else {
                tool_tracker_server_field.interactable = false;
            }
        }

        void ConnectToButtonsServer(int tool_index) {
            Debug.Log("ConnectToButtonServer");
            bool result = manager.ConnectToolToButtons(tool_index, tool_buttons_server_field.text);
            if (result == false) {
                ColorBlock cb = tool_buttons_server_field.colors;
                cb.normalColor = new Color(1f, 0.4f, 0.4f);
                cb.highlightedColor = new Color(1f, 0.4f, 0.4f);
                tool_buttons_server_field.colors = cb;
                tool_buttons_server_toggle.isOn = false;
            } else {
                tool_buttons_server_field.interactable = false;
            }
        }

        void DisconnectFromFFServer(int tool_index) {
            Debug.Log("DisconnectFromFFServer");
            tool_ff_server_field.interactable = true;
            manager.DisconnectToolFromForceFeedback(tool_index);
        }

        void DisconnectFromTrackerServer(int tool_index) {
            Debug.Log("DisconnectFromTrackerServer");
            tool_tracker_server_field.interactable = true;
            Debug.Log(manager.DisconnectToolFromTracker(tool_index));
        }

        void DisconnectFromButtonsServer(int tool_index) {
            Debug.Log("DisconnectFromButtonsServer");
            tool_buttons_server_field.interactable = true;
            manager.DisconnectToolFromButtons(tool_index);
        }
    }

}