private void Unbind(Action action)
 {
     for (int i = 0; i < GameInputMapping.KeyBindings.Length; i++)
     {
         BindingEntry bindingEntry = GameInputMapping.KeyBindings[i];
         if (bindingEntry.mAction == action)
         {
             bindingEntry.mKeyCode           = KKeyCode.None;
             bindingEntry.mModifier          = Modifier.None;
             GameInputMapping.KeyBindings[i] = bindingEntry;
         }
     }
 }
Exemplo n.º 2
0
    public KInputController AddGamepadController(int gamepad_index)
    {
        KInputController kInputController = new KInputController(true);

        BindingEntry[] bindingEntries = GameInputMapping.GetBindingEntries();
        for (int i = 0; i < bindingEntries.Length; i++)
        {
            BindingEntry bindingEntry = bindingEntries[i];
            kInputController.Bind(BindingEntry.GetGamepadKeyCode(gamepad_index, bindingEntry.mButton), Modifier.None, bindingEntry.mAction);
        }
        AddController(kInputController);
        return(kInputController);
    }
Exemplo n.º 3
0
        public static bool GameInputMapping_FindEntry_Prefix(Action mAction, ref BindingEntry __result)
        {
            foreach (BindingEntry keyBinding in GameInputMapping.KeyBindings)
            {
                if (keyBinding.mAction == mAction)
                {
                    __result = keyBinding;
                    return(false);
                }
            }

            __result = new BindingEntry(null, GamepadButton.NumButtons, KKeyCode.None, Modifier.None, Action.NumActions, false, false);
            return(false);
        }
Exemplo n.º 4
0
 public void RebindControls()
 {
     foreach (KInputController mController in mControllers)
     {
         mController.ClearBindings();
         BindingEntry[] bindingEntries = GameInputMapping.GetBindingEntries();
         for (int i = 0; i < bindingEntries.Length; i++)
         {
             BindingEntry bindingEntry = bindingEntries[i];
             mController.Bind(bindingEntry.mKeyCode, bindingEntry.mModifier, bindingEntry.mAction);
         }
         mController.HandleCancelInput();
     }
 }
Exemplo n.º 5
0
        public static bool GameInputMapping_CompareActionKeyCodes_Prefix(Action a, Action b, ref bool __result)
        {
            BindingEntry entry1 = GameInputMapping.FindEntry(a);
            BindingEntry entry2 = GameInputMapping.FindEntry(b);

            if (!(entry1.mAction == Action.NumActions || entry2.mAction == Action.NumActions) && entry1.mKeyCode == entry2.mKeyCode)
            {
                __result = entry1.mModifier == entry2.mModifier;
                return(false);
            }

            __result = false;
            return(false);
        }
    private BindingEntry GetFirstUnbound()
    {
        BindingEntry result = default(BindingEntry);

        for (int i = 0; i < GameInputMapping.KeyBindings.Length; i++)
        {
            BindingEntry result2 = GameInputMapping.KeyBindings[i];
            if (result2.mKeyCode == KKeyCode.None)
            {
                return(result2);
            }
        }
        return(result);
    }
    private BindingEntry GetDuplicatedBinding(string activeScreen, BindingEntry new_binding)
    {
        BindingEntry result = default(BindingEntry);

        for (int i = 0; i < GameInputMapping.KeyBindings.Length; i++)
        {
            BindingEntry bindingEntry = GameInputMapping.KeyBindings[i];
            if (new_binding.IsBindingEqual(bindingEntry) && (bindingEntry.mGroup == null || bindingEntry.mGroup == activeScreen || bindingEntry.mGroup == "Root" || activeScreen == "Root") && (!(activeScreen == "Root") || !bindingEntry.mIgnoreRootConflics) && (!(bindingEntry.mGroup == "Root") || !new_binding.mIgnoreRootConflics))
            {
                return(bindingEntry);
            }
        }
        return(result);
    }
    private int NumUnboundActions()
    {
        int num = 0;

        for (int i = 0; i < GameInputMapping.KeyBindings.Length; i++)
        {
            BindingEntry bindingEntry = GameInputMapping.KeyBindings[i];
            if (bindingEntry.mKeyCode == KKeyCode.None && (BuildMenu.UseHotkeyBuildMenu() || !bindingEntry.mIgnoreRootConflics))
            {
                num++;
            }
        }
        return(num);
    }
Exemplo n.º 9
0
 public static BindingEntry FindEntry(Action mAction)
 {
     BindingEntry[] keyBindings = KeyBindings;
     for (int i = 0; i < keyBindings.Length; i++)
     {
         BindingEntry result = keyBindings[i];
         if (result.mAction == mAction)
         {
             return(result);
         }
     }
     Debug.Assert(false, "Unbound action " + mAction.ToString());
     return(KeyBindings[0]);
 }
Exemplo n.º 10
0
    public static BindingEntry[] FindEntriesByKeyCode(KKeyCode keycode)
    {
        List <BindingEntry> list = new List <BindingEntry>();

        BindingEntry[] keyBindings = KeyBindings;
        for (int i = 0; i < keyBindings.Length; i++)
        {
            BindingEntry item = keyBindings[i];
            if (item.mKeyCode == keycode)
            {
                list.Add(item);
            }
        }
        return(list.ToArray());
    }
 private void CollectScreens()
 {
     screens.Clear();
     for (int i = 0; i < GameInputMapping.KeyBindings.Length; i++)
     {
         BindingEntry bindingEntry = GameInputMapping.KeyBindings[i];
         if (bindingEntry.mGroup != null && bindingEntry.mRebindable && !screens.Contains(bindingEntry.mGroup))
         {
             if (bindingEntry.mGroup == "Root")
             {
                 activeScreen = screens.Count;
             }
             screens.Add(bindingEntry.mGroup);
         }
     }
 }
Exemplo n.º 12
0
    protected override void OnPrefabInit()
    {
        BindingEntry[] bindingEntries = GameInputMapping.GetBindingEntries();
        string         text           = string.Empty;

        BindingEntry[] array = bindingEntries;
        for (int i = 0; i < array.Length; i++)
        {
            BindingEntry bindingEntry = array[i];
            text += bindingEntry.mAction.ToString();
            text += ": ";
            text += bindingEntry.mKeyCode.ToString();
            text += "\n";
        }
        controlLabel.text = text;
    }
Exemplo n.º 13
0
    public static HashSet <KeyCode> GetKeyCodes()
    {
        HashSet <KeyCode> hashSet = new HashSet <KeyCode>();

        BindingEntry[] bindingEntries = GetBindingEntries();
        for (int i = 0; i < bindingEntries.Length; i++)
        {
            BindingEntry bindingEntry = bindingEntries[i];
            if (bindingEntry.mKeyCode < KKeyCode.KleiKeys)
            {
                hashSet.Add((KeyCode)bindingEntry.mKeyCode);
            }
        }
        hashSet.Add(KeyCode.LeftAlt);
        hashSet.Add(KeyCode.LeftControl);
        hashSet.Add(KeyCode.LeftShift);
        hashSet.Add(KeyCode.CapsLock);
        return(hashSet);
    }
Exemplo n.º 14
0
            public static void Postfix(ref BindingEntry[] __result)
            {
                try
                {
                    if (State.Config.LogElementsData)
                    {
                        var values = Enum.GetNames(typeof(SimHashes));
                        Array.Sort(values);
                        string elementsLog = "";
                        foreach (var name in values)
                        {
                            elementsLog += Environment.NewLine + name;
                        }
                        Common.Logger.Log("Elements list: " + elementsLog);
                    }

                    try
                    {
                        List <BindingEntry> bind  = __result.ToList();
                        BindingEntry        entry = new BindingEntry
                                                    (
                            "Root",
                            GamepadButton.NumButtons,
                            KKeyCode.F6,
                            Modifier.Alt,
                            (Action)IDs.ToggleMaterialColorOverlayAction,
                            true,
                            true
                                                    );
                        bind.Add(entry);
                        __result = bind.ToArray();
                    }
                    catch (Exception e)
                    {
                        Common.Logger.LogOnce("Keybindings failed:\n", e);
                        throw;
                    }
                }
                catch (Exception e)
                {
                    Common.Logger.LogOnce("Global_GenerateDefaultBindings.Postfix", e);
                }
            }
Exemplo n.º 15
0
        private void GenericComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            ComboBox cb = sender as ComboBox;

            // Should never be false
            if (cb != null)
            {
                //bindings[cb.Name].SetValue(bindings[cb.Name].)
                BindingEntry be = bindings[cb.Name];
                if (be.parent != null)
                {
                    be.fi.SetValue(be.parent.GetValue(Settings.s), cb.SelectedIndex);
                }
                else
                {
                    be.fi.SetValue(Settings.s, cb.SelectedIndex);
                }
            }
        }
Exemplo n.º 16
0
        private void DrawPicker(Rect position, SerializedProperty property)
        {
            int index = EditorGUI.Popup(position, cache.CurrentIndex, cache.CachedOptions);

            if (index != cache.CurrentIndex)
            {
                if (index > 0)
                {
                    string       bindingId = cache.CachedOptionIds[index];
                    BindingEntry entry     = cache.BindingMap[bindingId];
                    SetBinding(property, entry.Component, entry.PropertyName);
                }
                else
                {
                    SetBinding(property, null, "");
                }

                cache.CurrentIndex = index;
            }
        }
Exemplo n.º 17
0
        /// <summary>
        /// Adds a key binding to the game for this custom Action. It must be done after mods
        /// are loaded.
        /// </summary>
        /// <param name="binding">The default key binding for this action.</param>
        internal void AddKeyBinding(PKeyBinding binding)
        {
            var currentBindings = GameInputMapping.DefaultBindings;

            if (binding == null)
            {
                throw new ArgumentNullException("binding");
            }
            if (currentBindings != null)
            {
                // Only if GameInputMapping is initialized
                Action action     = GetKAction();
                bool   inBindings = false;
                int    n          = currentBindings.Length;
                for (int i = 0; i < n && !inBindings; i++)
                {
                    var cb = currentBindings[i];
                    if (cb.mAction == action)
                    {
                        // Already exists, but it really should not
                        PActionManager.LogKeyBindWarning(("Action {0} already exists; " +
                                                          "assigned to KeyCode {1}").F(action, cb.mKeyCode));
                        inBindings = true;
                        break;
                    }
                }
                if (!inBindings)
                {
                    var newBindings = new BindingEntry[n + 1];
                    Array.Copy(currentBindings, newBindings, n);
                    newBindings[n] = new BindingEntry(PActionManager.CATEGORY, binding.
                                                      GamePadButton, binding.Key, binding.Modifiers, action, true, false);
                    GameInputMapping.SetDefaultKeyBindings(newBindings);
                }
            }
            else
            {
                // Queue into PActionManager
                PActionManager.Instance.QueueKeyBind(this, binding);
            }
        }
Exemplo n.º 18
0
 public static void LoadBindings()
 {
     KeyBindings = (BindingEntry[])DefaultBindings.Clone();
     if (File.Exists(BindingsFilename))
     {
         string text = File.ReadAllText(BindingsFilename);
         if (text != null && !(text == string.Empty))
         {
             BindingEntry[] array = null;
             try
             {
                 array = JsonConvert.DeserializeObject <BindingEntry[]>(text);
             }
             catch
             {
                 DebugUtil.LogErrorArgs("Error parsing", BindingsFilename);
             }
             if (array != null && array.Length != 0)
             {
                 for (int i = 0; i < KeyBindings.Length; i++)
                 {
                     BindingEntry   bindingEntry = KeyBindings[i];
                     BindingEntry[] array2       = array;
                     for (int j = 0; j < array2.Length; j++)
                     {
                         BindingEntry bindingEntry2 = array2[j];
                         if (bindingEntry2.mAction == bindingEntry.mAction && bindingEntry.mRebindable)
                         {
                             BindingEntry bindingEntry3 = bindingEntry;
                             bindingEntry3.mButton   = bindingEntry2.mButton;
                             bindingEntry3.mKeyCode  = bindingEntry2.mKeyCode;
                             bindingEntry3.mModifier = bindingEntry2.mModifier;
                             KeyBindings[i]          = bindingEntry3;
                             break;
                         }
                     }
                 }
             }
         }
     }
 }
    private void Bind(KKeyCode kkey_code, Modifier modifier)
    {
        BindingEntry bindingEntry = new BindingEntry(screens[activeScreen], GamepadButton.NumButtons, kkey_code, modifier, actionToRebind, true, ignoreRootConflicts);
        int          num          = 0;

        while (true)
        {
            if (num >= GameInputMapping.KeyBindings.Length)
            {
                return;
            }
            BindingEntry bindingEntry2 = GameInputMapping.KeyBindings[num];
            if (bindingEntry2.mRebindable && bindingEntry2.mAction == actionToRebind)
            {
                break;
            }
            num++;
        }
        BindingEntry duplicatedBinding = GetDuplicatedBinding(screens[activeScreen], bindingEntry);

        GameInputMapping.KeyBindings[num] = bindingEntry;
        LocText componentInChildren = activeButton.GetComponentInChildren <LocText>();

        componentInChildren.text = GetBindingText(bindingEntry);
        if (duplicatedBinding.mAction != 0 && duplicatedBinding.mAction != actionToRebind)
        {
            confirmDialog = Util.KInstantiateUI(confirmPrefab.gameObject, base.transform.gameObject, false).GetComponent <ConfirmDialogScreen>();
            string key         = "STRINGS.INPUT_BINDINGS." + duplicatedBinding.mGroup.ToUpper() + "." + duplicatedBinding.mAction.ToString().ToUpper();
            string arg         = Strings.Get(key);
            string bindingText = GetBindingText(duplicatedBinding);
            string text        = string.Format(UI.FRONTEND.INPUT_BINDINGS_SCREEN.DUPLICATE, arg, bindingText);
            Unbind(duplicatedBinding.mAction);
            confirmDialog.PopupConfirmDialog(text, null, null, null, null, null, null, null, null, true);
            confirmDialog.gameObject.SetActive(true);
        }
        Global.Instance.GetInputManager().RebindControls();
        waitingForKeyPress = false;
        actionToRebind     = Action.NumActions;
        activeButton       = null;
        BuildDisplay();
    }
Exemplo n.º 20
0
 public static void Postfix(ref BindingEntry[] __result)
 {
     try
     {
         List <BindingEntry> bind  = __result.ToList();
         BindingEntry        entry = new BindingEntry(
             "Root",
             GamepadButton.NumButtons,
             KKeyCode.F6,
             Modifier.Alt,
             (Action)IDs.ToggleMaterialColorOverlayAction,
             true,
             true);
         bind.Add(entry);
         __result = bind.ToArray();
     }
     catch (Exception e)
     {
         State.Logger.Log("Keybindings failed:\n" + e);
         throw;
     }
 }
    private void BuildDisplay()
    {
        string text = screens[activeScreen];
        string key  = "STRINGS.INPUT_BINDINGS." + text.ToUpper() + ".NAME";

        screenTitle.text = Strings.Get(key);
        if (entryPool == null)
        {
            entryPool = new UIPool <HorizontalLayoutGroup>(entryPrefab.GetComponent <HorizontalLayoutGroup>());
        }
        DestroyDisplay();
        int num = 0;

        for (int i = 0; i < GameInputMapping.KeyBindings.Length; i++)
        {
            BindingEntry binding = GameInputMapping.KeyBindings[i];
            if (binding.mGroup == screens[activeScreen] && binding.mRebindable)
            {
                GameObject gameObject          = entryPool.GetFreeElement(parent, true).gameObject;
                LocText    componentInChildren = gameObject.transform.GetChild(0).GetComponentInChildren <LocText>();
                string     key2 = "STRINGS.INPUT_BINDINGS." + binding.mGroup.ToUpper() + "." + binding.mAction.ToString().ToUpper();
                componentInChildren.text = Strings.Get(key2);
                LocText key_label = gameObject.transform.GetChild(1).GetComponentInChildren <LocText>();
                key_label.text = GetBindingText(binding);
                KButton button = gameObject.GetComponentInChildren <KButton>();
                button.onClick += delegate
                {
                    waitingForKeyPress  = true;
                    actionToRebind      = binding.mAction;
                    ignoreRootConflicts = binding.mIgnoreRootConflics;
                    activeButton        = button;
                    key_label.text      = UI.FRONTEND.INPUT_BINDINGS_SCREEN.WAITING_FOR_INPUT;
                };
                gameObject.transform.SetSiblingIndex(num);
                num++;
            }
        }
    }
Exemplo n.º 22
0
 private static void AddBindings(HashedString parent_category, BuildMenu.DisplayInfo display_info, List <BindingEntry> bindings)
 {
     if (display_info.data != null)
     {
         Type type = display_info.data.GetType();
         if (typeof(IList <BuildMenu.DisplayInfo>).IsAssignableFrom(type))
         {
             IList <BuildMenu.DisplayInfo> list = (IList <BuildMenu.DisplayInfo>)display_info.data;
             foreach (BuildMenu.DisplayInfo item2 in list)
             {
                 AddBindings(display_info.category, item2, bindings);
             }
         }
         else if (typeof(IList <BuildMenu.BuildingInfo>).IsAssignableFrom(type))
         {
             string       str      = HashCache.Get().Get(parent_category);
             TextInfo     textInfo = new CultureInfo("en-US", false).TextInfo;
             string       group    = textInfo.ToTitleCase(str) + " Menu";
             BindingEntry item     = new BindingEntry(group, GamepadButton.NumButtons, display_info.keyCode, Modifier.None, display_info.hotkey, true, true);
             bindings.Add(item);
         }
     }
 }
            public static void Postfix(ref BindingEntry[] __result)
            {
                if (State.ConfiguratorState.LogElementsData)
                {
                    State.Logger.Log("Element List:");
                    var values = Enum.GetNames(typeof(SimHashes));
                    Array.Sort(values);
                    string elementsLog = "";
                    foreach (var name in values)
                    {
                        elementsLog += Environment.NewLine + name;
                        //ElementLoader.GetElementIndex(i);
                        //ElementLoader.FindElementByName(i);
                    }
                    State.Logger.Log(elementsLog);
                }

                try
                {
                    List <BindingEntry> bind  = __result.ToList();
                    BindingEntry        entry = new BindingEntry(
                        "Root",
                        GamepadButton.NumButtons,
                        KKeyCode.F6,
                        Modifier.Alt,
                        (Action)IDs.ToggleMaterialColorOverlayAction,
                        true,
                        true);
                    bind.Add(entry);
                    __result = bind.ToArray();
                }
                catch (Exception e)
                {
                    State.Logger.Log("Keybindings failed:\n" + e);
                    throw;
                }
            }
Exemplo n.º 24
0
    public static void SaveBindings()
    {
        if (!Directory.Exists(Util.RootFolder()))
        {
            Directory.CreateDirectory(Util.RootFolder());
        }
        List <BindingEntry> list = new List <BindingEntry>();

        BindingEntry[] keyBindings = KeyBindings;
        for (int i = 0; i < keyBindings.Length; i++)
        {
            BindingEntry   bindingEntry    = keyBindings[i];
            bool           flag            = false;
            BindingEntry[] defaultBindings = DefaultBindings;
            foreach (BindingEntry b in defaultBindings)
            {
                if (bindingEntry == b)
                {
                    flag = true;
                    break;
                }
            }
            if (!flag && bindingEntry.mRebindable)
            {
                list.Add(bindingEntry);
            }
        }
        if (list.Count > 0)
        {
            string contents = JsonConvert.SerializeObject(list);
            File.WriteAllText(BindingsFilename, contents);
        }
        else if (File.Exists(BindingsFilename))
        {
            File.Delete(BindingsFilename);
        }
    }
Exemplo n.º 25
0
        /// <summary>
        /// Adds a key binding to the game for this custom Action. It must be done after mods
        /// are loaded.
        /// </summary>
        /// <param name="binding">The default key binding for this action.</param>
        internal void AddKeyBinding(PKeyBinding binding)
        {
            var currentBindings = GameInputMapping.DefaultBindings;

            if (binding == null)
            {
                throw new ArgumentNullException("binding");
            }
            if (currentBindings != null)
            {
                Action action     = GetKAction();
                bool   inBindings = false;
                // Only if GameInputMapping is initialized
                int n = currentBindings.Length;
                for (int i = 0; i < n && !inBindings; i++)
                {
                    if (currentBindings[i].mAction == action)
                    {
                        inBindings = true;
                        break;
                    }
                }
                if (!inBindings)
                {
                    var newBindings = new BindingEntry[n + 1];
                    Array.Copy(currentBindings, newBindings, n);
                    newBindings[n] = new BindingEntry(PActionManager.CATEGORY, binding.
                                                      GamePadButton, binding.Key, binding.Modifiers, action, true, false);
                    GameInputMapping.SetDefaultKeyBindings(newBindings);
                }
            }
            else
            {
                // Queue into PActionManager
                PActionManager.Instance.QueueKeyBind(this, binding);
            }
        }
Exemplo n.º 26
0
        /// <summary>
        /// Gets the action's command as a user-friendly string. Only works if the Steam
        /// Controller is not in use.
        /// </summary>
        /// <param name="inputBinding">The input binding for the command.</param>
        /// <param name="text">The location where the result will be stored</param>
        private static void GetActionString(ref BindingEntry inputBinding, StringBuilder text)
        {
            var    keyCode  = inputBinding.mKeyCode;
            var    modifier = inputBinding.mModifier;
            var    modText  = MODIFERS;
            string raw      = StringFormatter.ToUpper(GameUtil.GetKeycodeLocalized(keyCode));

            if (modifier == Modifier.None)
            {
                text.Append(raw);
            }
            else
            {
                bool first = true;
                if ((modifier & Modifier.Alt) != 0)
                {
                    text.Append(modText[0]);
                    first = false;
                }
                if ((modifier & Modifier.Ctrl) != 0)
                {
                    if (!first)
                    {
                        text.Append(" + ");
                    }
                    text.Append(modText[1]);
                    first = false;
                }
                if ((modifier & Modifier.Shift) != 0)
                {
                    if (!first)
                    {
                        text.Append(" + ");
                    }
                    text.Append(modText[2]);
                    first = false;
                }
                switch (modifier)
                {
                case Modifier.CapsLock:
                    if (!first)
                    {
                        text.Append(" + ");
                    }
                    text.Append(modText[3]);
                    break;

                case Modifier.Backtick:
                    if (!first)
                    {
                        text.Append(" + ");
                    }
                    text.Append(modText[4]);
                    break;

                default:
                    break;
                }
                text.Append(" + ").Append(raw);
            }
        }
Exemplo n.º 27
0
 /// <summary>
 /// Called when a binding completes.
 /// </summary>
 /// <param name="changed">The completed entry.</param>
 private void EntryCompleted(BindingEntry entry)
 {
     this.Remove(entry);
 }
Exemplo n.º 28
0
 /// <summary>
 /// Removes the specified binding entry and updates the current value.
 /// </summary>
 /// <param name="entry">The binding entry to remove.</param>
 private void Remove(BindingEntry entry)
 {
     entry.Dispose();
     this.bindings.Remove(entry);
     this.UpdateValue();
 }
Exemplo n.º 29
0
        private void toolStripButton1_Click(object sender, EventArgs e)
        {
            if (!IBMiUtils.IsValueObjectName(objectName.Text))
            {
                MessageBox.Show("Object name is not valid.");
                objectName.Focus();
                return;
            }
            if (objectType.Text == "")
            {
                MessageBox.Show("Object type is not valid.");
                objectType.Focus();
                return;
            }
            if (IBMiUtils.IsValueObjectName(objectLib.Text) == false && objectLib.Text != "*LIBL")
            {
                MessageBox.Show("Object library name is not valid.");
                objectLib.Focus();
                return;
            }
            if (objectActivation.Text == "")
            {
                MessageBox.Show("Object activation is not valid.");
                objectType.Focus();
                return;
            }

            BindingEntry Entry = new BindingEntry();

            Entry.BindingLib   = Library;
            Entry.BindingObj   = Object;
            Entry.Name         = objectName.Text.Trim();
            Entry.Library      = objectLib.Text.Trim();
            Entry.Type         = objectType.Text;
            Entry.Activation   = objectActivation.Text;
            Entry.CreationDate = "";
            Entry.CreationTime = "";

            string command  = "ADDBNDDIRE BNDDIR(" + Library + "/" + Object + ") OBJ((" + Entry.Library + "/" + Entry.Name + " " + Entry.Type + " " + Entry.Activation + "))";
            Thread gothread = new Thread((ThreadStart) delegate
            {
                if (IBMi.RunCommands(new string[1] {
                    command
                }) == false)
                {
                    ListViewItem Item = new ListViewItem(new string[6] {
                        Entry.Name, Entry.Type, Entry.Library, Entry.Activation, Entry.CreationDate, Entry.CreationTime
                    });
                    Item.Tag = Entry;
                    this.Invoke((MethodInvoker) delegate
                    {
                        entriesList.Items.Add(Item);
                    });
                }
                else
                {
                    MessageBox.Show("Unable to create binding entry.");
                }
            });

            gothread.Start();
        }