Merge remote-tracking branch 'origin/master'

Conflicts:
	CompactWindow.cs
	NativeMethods.cs
	Program.cs

Author: Alex Camilleri

App.config

@@ -2,5 +2,5 @@
 <configuration>
     <startup> 
 
-    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5"/></startup>
+    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup>
 </configuration>

BorderlessGaming.csproj

@@ -9,7 +9,7 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>BorderlessGaming</RootNamespace>
     <AssemblyName>BorderlessGaming</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <TargetFrameworkProfile />
     <PublishUrl>publish\</PublishUrl>
@@ -57,7 +57,7 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Newtonsoft.Json, Version=4.5.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
-      <HintPath>..\packages\Newtonsoft.Json.5.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
+      <HintPath>..\packages\Newtonsoft.Json.5.0.8\lib\net40\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -107,7 +107,9 @@
       <DependentUpon>Resources.resx</DependentUpon>
       <DesignTime>True</DesignTime>
     </Compile>
-    <None Include="app.manifest" />
+    <None Include="app.manifest">
+      <SubType>Designer</SubType>
+    </None>
     <None Include="packages.config" />
     <None Include="Properties\Settings.settings">
       <Generator>SettingsSingleFileGenerator</Generator>

CompactWindow.cs

@@ -186,13 +186,20 @@ private void RemoveBorder(String procName) //actually make it frameless
                        | WindowStyleFlags.ExtendedComposited)));
 
 
-                var bounds = Screen.PrimaryScreen.Bounds;
+                //Get the screen bounds from the screen the window is currently active on.  
+                //If on multiple screens it will grab bounds from the screen it is most on.  
+                //If not on any screen it grabs bounds from the screen closest
+                var bounds = Screen.FromHandle(pFoundWindow).Bounds;
+                
                 if (!_borderlessWindows.Contains(pFoundWindow.ToInt32().ToString()))
                 {
-                    Native.SetWindowPos(pFoundWindow, 0, bounds.X, bounds.Y, bounds.Width, bounds.Height, SetWindowPosFlags.NoZOrder | SetWindowPosFlags.ShowWindow);
+                    //Using bounds.X and bounds.Y instead of 0, 0 so it will orient the window 
+                    //on the screen it is currently occupying instead of using the primary screen
+                    Native.SetWindowPos(pFoundWindow, 0, bounds.X, bounds.Y, bounds.Width, bounds.Height, SWP_NOZORDER | SWP_SHOWWINDOW);
                     _borderlessWindows.Add(pFoundWindow.ToInt32().ToString());
                 } //today I learn the definition of a hot fix
-
+                
+                
                 //no more outside window
                 //    CheckNativeResult(() => Native.MoveWindow(pFoundWindow, 0, 0, bounds.Width, bounds.Height, true));
                 //resets window to main monito

CompactWindow.cs.orig

@@ -0,0 +1,338 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Diagnostics;
+using System.Drawing;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Windows.Forms;
+using BorderlessGaming.WindowsApi;
+
+namespace BorderlessGaming
+{
+    public partial class CompactWindow : Form
+    {
+        private const int SW_SHOW = 0x05;
+        private const int WS_EX_APPWINDOW = 0x40000;
+        private const int GWL_EXSTYLE = -0x14; //never want to hunt this down again
+        private const int WS_EX_DLGMODALFRAME = 0x0001;
+        private const int WS_EX_TOOLWINDOW = 0x0080;
+        private const short SWP_NOMOVE = 0X2;
+        private const short SWP_NOSIZE = 1;
+        private const short SWP_NOZORDER = 0X4;
+        private const int SWP_SHOWWINDOW = 0x0040;
+
+        public static uint MF_BYPOSITION = 0x400;
+        public static uint MF_REMOVE = 0x1000;
+        public static int GWL_STYLE = -16;
+        private readonly List<string> _borderlessWindows = new List<string>();
+        private readonly List<string> _processDataList = new List<string>();
+        private readonly List<string> _tempList = new List<string>();
+        private IntPtr _formHandle;
+        private bool _gameFound;
+        private string _selectedFavoriteProcess;
+        private string _selectedProcessName;
+        private BackgroundWorker _worker;
+
+        public CompactWindow()
+        {
+            InitializeComponent();
+            CenterToScreen();
+            PopulateList();
+            ListenForGameLaunch();
+            if (favoritesList == null) return;
+            favoritesList.DataSource = Favorites.List;
+        }
+
+
+
+        private void ListenForGameLaunch()
+        {
+            _formHandle = Handle;
+
+            _worker = new BackgroundWorker();
+            _worker.DoWork += _BackgroundWork;
+            _worker.RunWorkerCompleted += _BackgroundWorkCompleted;
+
+            if (workerTimer != null)
+                workerTimer.Start();
+        }
+
+        public static IntPtr FindWindowHandle(string processName, IntPtr ignoreHandle)
+        {
+            var process =
+                Process.GetProcesses()
+                    .FirstOrDefault(
+                        p =>
+                            p != null && p.ProcessName.Equals(processName, StringComparison.InvariantCultureIgnoreCase) &&
+                            p.MainWindowHandle != IntPtr.Zero && p.MainWindowHandle != ignoreHandle &&
+                            !string.IsNullOrEmpty(p.MainWindowTitle));
+
+            return process != null ? process.MainWindowHandle : IntPtr.Zero;
+        }
+
+        private void _BackgroundWork(object sender, DoWorkEventArgs e)
+        {
+            IntPtr handle;
+            var breakLoop = false;
+            var windowText = "";
+            while (true)
+            {
+                processList.Invoke((MethodInvoker)delegate
+                {
+                    //Code to modify control will go here
+                    processList.DataSource = null;
+                    processList.Items.Clear();
+                    _processDataList.Clear();
+                    PopulateList();
+                });
+
+
+                Favorites.List.ForEach(wndName =>
+                {
+                    handle = FindWindowHandle(wndName, _formHandle);
+
+                    if (handle != IntPtr.Zero)
+                    {
+                        windowText = wndName;
+                        breakLoop = true;
+                    }
+                });
+
+                if (breakLoop)
+                {
+                    Thread.Sleep(2000);
+                    RemoveBorder(windowText);
+                    break;
+                }
+
+                Thread.Sleep(9000);
+            }
+        }
+
+        private void _BackgroundWorkCompleted(object sender, RunWorkerCompletedEventArgs e)
+        {
+            if (!IsDisposed)
+            {
+            }
+        }
+
+        private void PopulateList() //Adds active windows to the processDataList
+        {
+            _tempList.Add("Refreshing...");
+            processList.DataSource = _tempList;
+            var processlist = Process.GetProcesses();
+
+            foreach (
+                var process in
+                    processlist.Where(process => process != null)
+                        .Where(process => !process.ProcessName.Equals("explorer")))
+            {
+                if (String.IsNullOrEmpty(process.MainWindowTitle))
+                {
+                    Native.SetWindowText(process.MainWindowHandle, process.ProcessName);
+                }
+                if (process.MainWindowTitle.Length <= 0) continue;
+                _processDataList.Add(process.ProcessName);
+            }
+
+
+            UpdateList();
+        }
+
+
+        private void RemoveBorder(String procName) //actually make it frameless
+        {
+            var Procs = Process.GetProcesses();
+            foreach (var proc in Procs)
+            {
+                if (_gameFound.Equals(true))
+                {
+                    _gameFound = false;
+                    return;
+                }
+
+                if (!proc.ProcessName.Equals(procName)) continue;
+                var pFoundWindow = proc.MainWindowHandle;
+                var style = Native.GetWindowLong(pFoundWindow, GWL_STYLE);
+
+                //get menu
+                var HMENU = Native.GetMenu(proc.MainWindowHandle);
+                //get item count
+                var count = Native.GetMenuItemCount(HMENU);
+                //loop & remove
+                for (var i = 0; i < count; i++)
+                {
+                    Native.RemoveMenu(HMENU, 0, (MF_BYPOSITION | MF_REMOVE));
+                    Native.RemoveMenu(HMENU, 0, (MF_BYPOSITION | MF_REMOVE));
+                }
+
+                //force a redraw
+                Native.DrawMenuBar(proc.MainWindowHandle);
+                Native.SetWindowLong(pFoundWindow, GWL_STYLE,
+                    (style &
+                     ~(WindowStyleFlags.ExtendedDlgmodalframe
+                       | WindowStyleFlags.Caption
+                       | WindowStyleFlags.ThickFrame
+                       | WindowStyleFlags.Minimize
+                       | WindowStyleFlags.Maximize
+                       | WindowStyleFlags.SystemMenu
+                       | WindowStyleFlags.MaximizeBox
+                       | WindowStyleFlags.MinimizeBox
+                       | WindowStyleFlags.Border
+                       | WindowStyleFlags.ExtendedComposited)));
+
+
+<<<<<<< HEAD:CompactWindow.cs
+                var bounds = Screen.PrimaryScreen.Bounds;
+                if (!_borderlessWindows.Contains(pFoundWindow.ToInt32().ToString()))
+                {
+                    Native.SetWindowPos(pFoundWindow, 0, bounds.X, bounds.Y, bounds.Width, bounds.Height, SetWindowPosFlags.NoZOrder | SetWindowPosFlags.ShowWindow);
+                    _borderlessWindows.Add(pFoundWindow.ToInt32().ToString());
+                } //today I learn the definition of a hot fix
+
+=======
+                //Get the screen bounds from the screen the window is currently active on.  
+                //If on multiple screens it will grab bounds from the screen it is most on.  
+                //If not on any screen it grabs bounds from the screen closest
+                var bounds = Screen.FromHandle(pFoundWindow).Bounds;
+                
+                if (!_borderlessWindows.Contains(pFoundWindow.ToInt32().ToString()))
+                {
+                    //Using bounds.X and bounds.Y instead of 0, 0 so it will orient the window 
+                    //on the screen it is currently occupying instead of using the primary screen
+                    Native.SetWindowPos(pFoundWindow, 0, bounds.X, bounds.Y, bounds.Width, bounds.Height, SWP_NOZORDER | SWP_SHOWWINDOW);
+                    _borderlessWindows.Add(pFoundWindow.ToInt32().ToString());
+                } //today I learn the definition of a hot fix
+                
+                
+>>>>>>> origin/master:Borderless.cs
+                //no more outside window
+                //    CheckNativeResult(() => Native.MoveWindow(pFoundWindow, 0, 0, bounds.Width, bounds.Height, true));
+                //resets window to main monito
+
+                _gameFound = true;
+            }
+
+            _gameFound = false;
+        }
+
+        private void ProcessListSelectedIndexChanged(object sender, EventArgs e)
+        {
+            if (e == null) throw new ArgumentNullException("e");
+            _selectedProcessName = processList.GetItemText(processList.SelectedItem);
+            selectedProcess.Text = _selectedProcessName + " is selected!";
+        }
+
+        private void MakeBorderless(object sender, EventArgs e)
+        {
+            RemoveBorder(_selectedProcessName);
+        }
+
+        private void BlogButtonClick(object sender, EventArgs e)
+        {
+            GotoSite("http://andrew.codeusa.net/");
+        }
+
+
+        private void GitHubButtonClick(object sender, EventArgs e)
+        {
+            GotoSite("https://github.com/Codeusa/Borderless-Gaming");
+        }
+
+        public void GotoSite(string url) //open url
+        {
+            Process.Start(url);
+        }
+
+        private void UpdateList() // sets data sources
+        {
+            processList.DataSource = _processDataList;
+        }
+
+        private void workerTimer_Tick(object sender, EventArgs e)
+        {
+            if (_worker.IsBusy) return;
+            _worker.RunWorkerAsync();
+        }
+
+        private void SendToFavorites(object sender, EventArgs e)
+        {
+            if (_selectedProcessName == null || !Favorites.CanAdd(_selectedProcessName))
+            {
+                MessageBox.Show("Unable to add " + _selectedProcessName + " already added!", "Uh oh!",
+                    MessageBoxButtons.OK, MessageBoxIcon.Error);
+            }
+            else
+            {
+                Favorites.AddGame(_selectedProcessName);
+                Favorites.Save("./Favorites.json");
+                favoritesList.DataSource = null;
+                favoritesList.DataSource = Favorites.List;
+                MessageBox.Show(_selectedProcessName + " added to favorites", "Victory!",
+                    MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
+            }
+        }
+
+        private void BugReportClick(object sender, EventArgs e)
+        {
+            GotoSite("https://github.com/Codeusa/Borderless-Gaming/issues");
+        }
+
+
+        private void RemoveFavoriteButton(object sender, EventArgs e)
+        {
+            if (_selectedFavoriteProcess == null || !Favorites.CanRemove(_selectedFavoriteProcess))
+            {
+                MessageBox.Show("Unable to remove " + _selectedFavoriteProcess + " does not exist!", "Uh oh!",
+                    MessageBoxButtons.OK, MessageBoxIcon.Error);
+            }
+            else
+            {
+                Favorites.Remove("./Favorites.json", _selectedFavoriteProcess);
+                favoritesList.DataSource = null;
+                favoritesList.DataSource = Favorites.List;
+            }
+        }
+
+        private void FavoritesListSelectedIndexChanged(object sender, EventArgs e)
+        {
+            if (e == null) throw new ArgumentNullException("e");
+            _selectedFavoriteProcess = favoritesList.GetItemText(favoritesList.SelectedItem);
+        }
+
+        private void SupportButtonClick(object sender, EventArgs e)
+        {
+            GotoSite("https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=TWHNPSC7HRNR2");
+        }
+
+        protected override void OnResize(EventArgs e)
+        {
+            base.OnResize(e);
+            //determine whether the cursor is in the taskbar because Microsoft 
+            var cursorNotInBar = Screen.GetWorkingArea(this).Contains(Cursor.Position);
+            if (WindowState != FormWindowState.Minimized || !cursorNotInBar) return;
+            ShowInTaskbar = false;
+            notifyIcon.Visible = true;
+            //  notifyIcon.Icon = SystemIcons.Application;
+            notifyIcon.BalloonTipText = "Borderless Gaming Minimized";
+            notifyIcon.ShowBalloonTip(2000);
+            Hide();
+        }
+
+        private void TrayIconOpen(object sender, EventArgs e)
+        {
+            Show();
+            WindowState = FormWindowState.Normal;
+            ShowInTaskbar = true;
+        }
+
+        private void TrayIconExit(object sender, EventArgs e)
+        {
+            Environment.Exit(0);
+        }
+    }
+}