Executable.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Xml.Serialization;

namespace Seci.Definitions
{
    public class Executable : IDisposable
    {
        //Members
        private String _name;
        private String _filePath;
        private String _owningComponent;   
        private int _positionX;
        private int _positionY;
        private int _width;
        private int _height;
        private Process _process;
        private bool _disposed;

        //Properties
        public String Name { get { return _name; } set { _name = value; } }
        public String FilePath { get { return _filePath; } set { _filePath = value; } }
        public int PositionX { get { return _positionX; } set { _positionX = value; } }
        public int PositionY { get { return _positionY; } set { _positionY = value; } }
        [XmlIgnore] public String OwningComponent { get { return _owningComponent; } set { _owningComponent = value; } }

        public Executable()
        {

        }

        public Executable(String filepath)
        {
            _filePath = filepath;
           
            _positionX = 200; //default value
            _positionY = 200; //default value

            Load();
            getSize();
        }

        public void Load()
        {
            if (_process == null)
            {
                _process = new Process();

                _process.StartInfo.FileName = _filePath;
                _process.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
                _process.Start();

                //Need to wait three seconds
                System.Threading.Thread.Sleep(3000);
            }
        }

        public Boolean Hide()
        {
            Helpers.NativeMethods.ShowWindow(_process.MainWindowHandle.ToInt32(), 0);

            //Get the position (and size?)
            GetPosition();

            return true;
        }

        public Boolean Show()
        {
            Helpers.NativeMethods.ShowWindow(_process.MainWindowHandle.ToInt32(), 9);
            Helpers.NativeMethods.SetForegroundWindow(_process.MainWindowHandle.ToInt32());

            return true;
        }

        private void getSize()
        {
            if (Helpers.NativeMethods.IsIconic(_process.MainWindowHandle.ToInt32()) == 0)
            {
                //Not minimised, so get size
                Helpers.Rect rect = new Helpers.Rect();

                Helpers.NativeMethods.GetWindowRect(_process.MainWindowHandle.ToInt32(), out rect);

                _width = rect.Width - rect.X;
                _height = rect.Height - rect.Y;
            }
        }

        public void GetPosition()
        {
            if (Helpers.NativeMethods.IsIconic(_process.MainWindowHandle.ToInt32()) == 0)
            {
                //Not minimised, so get size
                Helpers.Rect rect = new Helpers.Rect();

                Helpers.NativeMethods.GetWindowRect(_process.MainWindowHandle.ToInt32(), out rect);

                _positionX = rect.X;
                _positionY = rect.Y;
            }
        }

        public void Move()
        {
            //First getsize to check that it hasn't changed
            getSize();
            Helpers.NativeMethods.MoveWindow(_process.MainWindowHandle, _positionX, _positionY, _width, _height, true);
        }

        public void Move(int xPos, int yPos)
        {
            //First getsize to check that it hasn't changed
            getSize();

            //Then move it and update positions
            Helpers.NativeMethods.MoveWindow(_process.MainWindowHandle, xPos, yPos, _width, _height, true);
            _positionX = xPos;
            _positionY = yPos;
        }

        #region IDisposable Members

        public void Dispose()
        {
            try
            {
                Dispose(true);
            }
            finally
            {
                GC.SuppressFinalize(this);
            }
        }

        ~Executable()
        {
            Dispose(false);
        }

        protected virtual void Dispose(Boolean disposing)
        {
            //Check has not already been disposed.
            if (!_disposed)
            {
                if (_process != null && !_process.HasExited)
                {
                    _process.Kill();
                    _process.Dispose();
                }
                
                _process = null;
            }
            _disposed = true;
        }

        #endregion
    }
}