ViTabControl.xaml.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace SeciControls
{
    public partial class ViTabControl : UserControl
    {
        private Dictionary<String, ViHostWrapper> _hostLookup = new Dictionary<String, ViHostWrapper>();
        private String _prevTab = "";

        private String _dummyTabName = "";

        public ViTabControl()
        {
            InitializeComponent();
        }

        #region Tabs

        public Boolean AddDummyTab(String tabname)
        {
            if (_hostLookup.ContainsKey(tabname))
            {
                HideTab(tabname);
                return false;
            }

            ViHostWrapper newHost = new ViHostWrapper();
            TabItem newTab = new TabItem();
            newTab.Header = tabname;
            newTab.Content = newHost;

            ScrollingTabControl.Items.Add(newTab);

            _hostLookup.Add(tabname, newHost);
            _dummyTabName = tabname;
            HideTab(tabname);

            return true;
        }

        public Boolean AddTab(String tabname)
        {
            if (_hostLookup.ContainsKey(tabname))
            {
                return false;
            }

            ViHostWrapper newHost = new ViHostWrapper();
            TabItem newTab = new TabItem();
            newTab.FontSize = 13;
            newTab.Header = tabname;
            newTab.Content = newHost;

            if (_hostLookup.ContainsKey(_dummyTabName))
            {
                int index = GetTabIndex(_dummyTabName);

                if (index != -1)
                {
                    ScrollingTabControl.Items.Insert(index, newTab);
                }
                else
                {
                    throw new Exception("Cannot get index of ScrollingTabControl");
                }
            }
            else
            {
                ScrollingTabControl.Items.Add(newTab);
            }

            _hostLookup.Add(tabname, newHost);

            return true;
        }

        public void RemoveTab(String tabname)
        {
            TabItem temp = GetTab(tabname);

            if (temp != null)
            {
                _hostLookup.Remove(tabname);
                ScrollingTabControl.Items.Remove(temp);
            }
        }

        public void RenameTab(String current, String newname)
        {
            if (_hostLookup.ContainsKey(newname))
            {
                throw new Exception("Name already used");
            }

            TabItem temp = GetTab(current);
            temp.Header = newname;

            ViHostWrapper tokeep = _hostLookup[current];
            _hostLookup.Remove(current);
            _hostLookup.Add(newname, tokeep);
        }

        public Boolean TabNameValid(string tabname)
        {
            return _hostLookup.ContainsKey(tabname);
        }

        private TabItem GetTab(String tabname)
        {
            foreach (Object tab in ScrollingTabControl.Items)
            {
                TabItem temp = (TabItem)tab;
                if (temp.Header.ToString() == tabname)
                {
                    return temp;
                }
            }
            return null;
        }

        private int GetTabIndex(String tabname)
        {
            for (int i = 0; i < ScrollingTabControl.Items.Count; ++i)
            {
                TabItem temp = (TabItem)ScrollingTabControl.Items[i];
                if (temp.Header.ToString() == tabname)
                {
                    return i;
                }
            }
            return -1;
        }

        public void SwapTabs(String tab1, String tab2)
        {
            int item1 = GetTabIndex(tab1);
            int item2 = GetTabIndex(tab2);

            if (item1 != -1 && item2 != -1)
            {
                TabItem temp = (TabItem)ScrollingTabControl.Items[item1];
                ScrollingTabControl.Items.RemoveAt(item1);
                ScrollingTabControl.Items.Insert(item2, temp);
            }
        }

        public List<String> GetTabNames(Boolean includeEmpty)
        {
            List<String> names = new List<string>();

            for (int i = 0; i < ScrollingTabControl.Items.Count; ++i)
            {
                TabItem temp = (TabItem)ScrollingTabControl.Items[i];

                if (includeEmpty || _hostLookup[temp.Header.ToString()].GetViNames().Count > 0)
                {
                    names.Add(temp.Header.ToString());
                }
            }

            return names;
        }

        public List<String> GetTabVis(String tabname)
        {
            return _hostLookup[tabname].GetViNames();
        }

        public Boolean DoesTabContainsVi(String tabname, String viname)
        {
            foreach (String vi in GetTabVis(tabname))
            {
                if (vi.ToLower() == viname.ToLower())
                {
                    return true;
                }
            }

            return false;
        }

        public void RemoveAllTabs()
        {
            List<String> keys = _hostLookup.Keys.ToList<String>();

            for (int i = keys.Count - 1; i >= 0; --i)
            {
                _hostLookup[keys[i]].RemoveAllVIs();
                RemoveTab(keys[i]);
            }
        }

        public void CascadeAllTabs()
        {
            List<String> keys = _hostLookup.Keys.ToList<String>();

            foreach (String key in keys)
            {
                _hostLookup[key].CascadeVIs();
            }
        }

        public void HideTab(string tabname)
        {
            if (ScrollingTabControl.Items != null && !string.IsNullOrEmpty(tabname))
            {
                foreach (TabItem tab in ScrollingTabControl.Items)
                {
                    if (tab.Header.ToString() == tabname)
                    {
                        tab.Visibility = Visibility.Collapsed;
                        return;
                    }
                }
            }
        }

        public void UnhideTab(string tabname)
        {
            if (ScrollingTabControl.Items != null && !string.IsNullOrEmpty(tabname))
            {
                foreach (TabItem tab in ScrollingTabControl.Items)
                {
                    if (tab.Header.ToString() == tabname)
                    {
                        tab.Visibility = Visibility.Visible;
                        return;
                    }
                }
            }
        }

        public void SelectTab(string tabname)
        {
            if (ScrollingTabControl.Items != null && !string.IsNullOrEmpty(tabname))
            {
                foreach (TabItem tab in ScrollingTabControl.Items)
                {
                    if (tab.Header.ToString() == tabname)
                    {
                        ScrollingTabControl.SelectedItem = tab;
                        return;
                    }
                }
            }
        }

        public void SelectTab(int index)
        {
            ScrollingTabControl.SelectedIndex = index;
        }

        public void SetToFirstVisible()
        {
            if (ScrollingTabControl.Items != null)
            {
                for (int i = 0; i < ScrollingTabControl.Items.Count; ++i)
                {
                    TabItem tab = ScrollingTabControl.Items[i] as TabItem;

                    if (tab != null && tab.Visibility == Visibility.Visible)
                    {
                        SelectTab(i);
                        return;
                    }
                }
            }
        }

        Boolean _settingOrder;

        public void SetTabOrder(Seci.SerialisableList<Seci.Definitions.Tab> list)
        {
            _settingOrder = true;

            try
            {
                for (int i = 0; i < list.Count; ++i)
                {
                    int index = GetTabIndex(list[i].Name);
                    if (index != -1)
                    {
                        TabItem temp = (TabItem)ScrollingTabControl.Items[index];
                        ScrollingTabControl.Items.RemoveAt(index);
                        ScrollingTabControl.Items.Insert(i, temp);
                    }
                }
            }
            catch
            {
            }

            _settingOrder = false;
        }

        private void ScrollingTabControl_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (e.Source is TabControl && !_settingOrder)
            {
                TabControl cntrl = sender as TabControl;
                String tabname = "";

                if (cntrl.SelectedIndex != -1)
                {
                    tabname = cntrl.Items[cntrl.SelectedIndex].ToString();
                    tabname = tabname.Substring(0, tabname.IndexOf(" Content")).Substring(tabname.IndexOf("Header:") + 7);
                    _hostLookup[tabname].SetVisible(true);
                }

                if (_prevTab != "" && tabname != "")
                {
                    _hostLookup[_prevTab].SetVisible(false);
                }
                _prevTab = tabname;
            }
        }

        public void StartTimers(int interval)
        {
            List<String> keys = _hostLookup.Keys.ToList<String>();

            foreach (String k in keys)
            {
                _hostLookup[k].StartTimer(interval);
            }
        }

        #endregion

        #region VIs

        public void AddVi(String tabname, String filename)
        {
            _hostLookup[tabname].AddVI(filename);
        }

        public void AddVi(String tabname, String filename, int x, int y)
        {
            _hostLookup[tabname].AddVI(filename, x, y);
        }

        public void RemoveVi(String tabname, String filename)
        {
            _hostLookup[tabname].RemoveVI(filename);
        }

        public void RemoveVi(String filename)
        {
            foreach (String tabname in _hostLookup.Keys.ToList<String>())
            {
                if (_hostLookup[tabname].GetViNames().Contains(filename))
                {
                    _hostLookup[tabname].RemoveVI(filename);
                }
            }
        }

        public List<String> GetAllVisInTabs()
        {
            List<String> names = new List<string>();
            List<String> keys = _hostLookup.Keys.ToList<String>();

            foreach (String key in keys)
            {
                names.AddRange(_hostLookup[key].GetViNames());
            }

            return names;
        }

        #endregion

    }
}