ViHost.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace SeciControls
{
    public partial class ViHost : UserControl
    {
        Dictionary<string, TitleHandleTuple> _viNames = new Dictionary<string, TitleHandleTuple>();
        Dictionary<string, string> _formNames = new Dictionary<string, string>();
        public List<string> ViNames { get { return _viNames.Keys.ToList<String>(); } }

        private Boolean _visible = false;
        private Boolean _isFirstTime = true;
        BackgroundWorker _worker = new BackgroundWorker();
        private delegate void UpdateGuiDelegate();

        public ViHost()
        {
            InitializeComponent();
            _worker.DoWork += new DoWorkEventHandler(_worker_DoWork);
            _worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(_worker_RunWorkerCompleted);
        }

        public void AddVI(String filename, int x, int y)
        {
            if (_viNames.ContainsKey(filename))
            {
                _viNames.Remove(filename);
            }

            Seci.Managers.LabViewMgr.ShowVI(filename);

            //Get the title of the frontpanel (needed for finding the window handle)
            Seci.Managers.LabViewMgr.UpdateFrontPanelTitle(filename);

            //Give the VI time to load
            System.Threading.Thread.Sleep(500);

            //Find the handle
            TitleHandleTuple viHandle = findViHandle(filename);

            if (viHandle != null)
            {
                //Capture the VI window
                WinApi.SetParent(viHandle.Handle, this.panel1.Handle);

                //Force the VI to redraw itself
                repaintVi(filename);

                //Move the VI to the required position
                positionVi(filename, x, y);

                _viNames.Add(filename, viHandle);
            }
        }

        public void RemoveVI(String filename)
        {
            IntPtr viHandle = IntPtr.Zero;

            viHandle = _viNames[filename].Handle;

            //Free the VI from the MDI
            WinApi.SetParent(viHandle, IntPtr.Zero);

            Seci.Managers.LabViewMgr.SetVisibilityToDefault(filename);

            _viNames.Remove(filename);

            if (_viNames.Count == 0)
            {
                timer1.Stop();
            }
        }

        public void RemoveAllVIs()
        {
            foreach (String name in ViNames)
            {
                RemoveVI(name);
            }
        }

        private static TitleHandleTuple findViHandle(String viName)
        {
            String viTitle = Seci.Managers.LabViewMgr.GetFrontPanelTitle(viName);

            return getHandle(viTitle);
        }

        private static TitleHandleTuple getHandle(String windowTitle)
        {
            IntPtr viHandle = WinApi.FindWindow(null, windowTitle);

            if (viHandle == IntPtr.Zero)
            {
                //Try adding "Front Panel" to windowTitle
                windowTitle += " Front Panel";
                viHandle = WinApi.FindWindow(null, windowTitle);
            }

            if (viHandle == IntPtr.Zero)
            {
                windowTitle += " *";
                viHandle = WinApi.FindWindow(null, windowTitle);
            }

            if (viHandle != IntPtr.Zero)
            {
                return new TitleHandleTuple(windowTitle.Trim(), viHandle);
            }

            return null;
        }

        private void repaintVi(String filename)
        {
            Seci.Managers.LabViewMgr.MinimiseVI(filename);
            Seci.Managers.LabViewMgr.RestoreVI(filename);
        }

        private void positionVi(String filename, int x, int y)
        {
            Seci.Managers.LabViewMgr.RestoreVI(filename);
            Seci.Managers.LabViewMgr.SetFrontPanelBounds(filename, new int[] { x, y });
        }

        private void bringViToFront(String filename)
        {
            Seci.Managers.LabViewMgr.ShowVI(filename);
        }

        public void CascadeVis()
        {
            int count = 0;

            //Move the scrollbars back to their start position
            this.panel1.HorizontalScroll.Value = 0;
            this.panel1.VerticalScroll.Value = 0;

            for (int i = 0; i < ViNames.Count; ++i)
            {
                if (!Seci.Managers.LabViewMgr.IsVIHidden(ViNames[i]))
                {
                    positionVi(ViNames[i], 40 * count, 40 * count);
                    bringViToFront(ViNames[i]);
                    ++count;
                }
            }
        }

        private void cascadeVIsToolStripMenuItem_Click(object sender, EventArgs e)
        {
            CascadeVis();
        }

        private void moveVisToConfigPositions()
        {
            //updateHandles();
            foreach (String name in ViNames)
            {
                if (Seci.Managers.LabViewMgr.DoesVIExist(name))
                {
                    int[] bounds = Seci.Managers.ConfigurationMgr.GetConfigPanelPosition(name, false);

                    if (bounds != null && bounds.Length == 2)
                    {
                        //DO WE NEED THIS LOOP?
                        while (true)
                        {
                            positionVi(name, bounds[0], bounds[1]);

                            WinApi.Rect viRect;
                            int x;
                            int y;
                            getVIPosition(name, out viRect, out x, out y);

                            if (x - 1 == bounds[0] && y - 1 == bounds[1]) break;
                        }
                    }
                }
            }
        }

        private void updateHandles()
        {
            foreach (String name in ViNames)
            {
                try
                {
                    //If the VI window is closed for any reason then we need to skip
                    //it, otherwise Seci will try to use all 100% of the processor!
                    if (Seci.Managers.LabViewMgr.DoesVIExist(name) && !Seci.Managers.LabViewMgr.IsVIHidden(name))
                    {
                        int length = WinApi.GetWindowTextLength(_viNames[name].Handle.ToInt32()) + 1;
                        StringBuilder title = new StringBuilder(length);
                        WinApi.GetWindowText(_viNames[name].Handle.ToInt32(), title, length);

                        //If the title has changed then it is likely the handle has changed
                        //So find the new handle...
                        if (title.ToString().Trim() != _viNames[name].Title || _viNames[name].Handle == IntPtr.Zero)
                        {
                            TitleHandleTuple viHandle = findViHandle(name);

                            if (viHandle != null)
                            {
                                WinApi.SetParent(viHandle.Handle, this.panel1.Handle);
                                _viNames[name].Handle = viHandle.Handle;
                                _viNames[name].Title = viHandle.Title.Trim(); //title.ToString().Trim();

                                //Get the previous position as the most recent position may be wrong
                                int[] bounds = Seci.Managers.ConfigurationMgr.GetConfigPanelPosition(name, true);
                                if (bounds != null)
                                {
                                    positionVi(name, bounds[0] - 1, bounds[1] - 1);
                                }
                                else
                                {
                                    positionVi(name, 0, 0);
                                }
                            }
                        }
                    }
                }
                catch
                {
                }
            }
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            try
            {
                if (!_worker.IsBusy)
                {
                    if (this.Handle != null)
                    {
                        _worker.RunWorkerAsync();
                    }
                }
            }
            catch (Exception err)
            {
            }
        }

        void _worker_DoWork(object sender, DoWorkEventArgs e)
        {
            timer1.Stop();

            if (this.InvokeRequired)
            {
                this.Invoke(new UpdateGuiDelegate(work), null);
            }
        }

        void _worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            timer1.Start();
        }

        private void work()
        {
            int Xmax = 0;
            int Ymax = 0;

            //Here we go through all the VIs and work out the maximum x and y positions of the VI.
            //The size marker is moved to this position and the MDI will respond to this,
            //for example: if the marker is off the MDI then the MDI will have scroll bars.
            foreach (string vi in ViNames)
            {
                try
                {
                    if (Seci.Managers.LabViewMgr.DoesVIExist(vi))
                    {
                        if (!Seci.Managers.LabViewMgr.IsVIHidden(vi))
                        {
                            WinApi.Rect viRect;
                            int x;
                            int y;

                            //Get the current position of the VI
                            getVIPosition(vi, out viRect, out x, out y);

                            //Need to write the position back for saving.
                            //When a VI is started the position will change temporary
                            //we don't want to update the value in that case, when this 
                            //happens the y will go to a unlikely -ve value
                            if (y >= -30 && _visible)
                            {
                                Seci.Managers.ConfigurationMgr.SetConfigPanelPosition(vi, x, y);
                            }

                            int adjustedX = x + viRect.Width - viRect.X;
                            int adjustedY = y + viRect.Height - viRect.Y;

                            if (adjustedX > Xmax)
                            {
                                Xmax = adjustedX;
                            }

                            if (adjustedY > Ymax)
                            {
                                Ymax = adjustedY;
                            }
                        }
                    }
                }
                catch
                {
                }
            }

            updateHandles();

            //Move the marker to the correct position
            sizeMarker.Location = new Point(Xmax, Ymax);
        }

        private void getVIPosition(string vi, out WinApi.Rect viRect, out int x, out int y)
        {
            viRect = new WinApi.Rect();
            WinApi.GetWindowRect(_viNames[vi].Handle, out viRect);

            WinApi.Rect thisRect = new WinApi.Rect();
            WinApi.GetWindowRect(this.Handle, out thisRect);

            x = viRect.X - thisRect.X;
            y = viRect.Y - thisRect.Y;
        }

        private class TitleHandleTuple
        {
            public string Title;
            public IntPtr Handle;

            public TitleHandleTuple(String title, IntPtr handle)
            {
                Title = title;
                Handle = handle;
            }
        }

        public void StartTimer(int interval)
        {
            timer1.Interval = interval;
            timer1.Start();
        }

        public void SetVisible(Boolean visible)
        {
            //A crude hack to get round the problem where the VI is moved to the 
            //wrong position the first time the tab is selected
            if (_isFirstTime)
            {
                moveVisToConfigPositions();
                _isFirstTime = false;
            }

            _visible = visible;

            //If the user has "accidently" closed a VI then reopen it next time the tab is opened
            if (visible == true)
            {
                foreach (string vi in ViNames)
                {
                    if (Seci.Managers.LabViewMgr.IsVIHidden(vi))
                    {
                        Seci.Managers.LabViewMgr.ShowVI(vi);
                    }
                }
            }
        }
    }
}