Implemented universal searching of GetTopMostWindow (any applications)

apdevelop · apdevelop · commit 836ee3603f34 · 2016-06-14T11:38:44.000+03:00
diff --git a/Src/ScreenGrid.Models.Tests/FlatImageTests.cs b/Src/ScreenGrid.Models.Tests/FlatImageTests.cs
@@ -61,11 +61,11 @@ public void FindBordersTest()
         }
 
         [Test]
-        public void FindBoundingsOfInnerImage()
+        public void FindBoundsOfInnerImage()
         {
             var flatImage = LoadFlatImageFromResource("ScreenGrid.Models.Tests.Resources.ImageSimple.png");
 
-            var result = flatImage.FindBoundingsOfInnerImage();
+            var result = flatImage.FindBoundsOfInnerImage();
 
             Assert.AreEqual(12, result.X);
             Assert.AreEqual(10, result.Y);
diff --git a/Src/ScreenGrid.Models/AppsInterop/NativeWindow.cs b/Src/ScreenGrid.Models/AppsInterop/NativeWindow.cs
@@ -89,7 +89,7 @@ public Bitmap GetShot()
             return WinApiInterop.NativeMethods.GetWindowImage(this.hWnd, 0, 0, (rect.Right - rect.Left) + 1, (rect.Bottom - rect.Top) + 1); // TODO: +1 ?
         }
 
-        public static NativeWindow GetTopMostWindow(IEnumerable<string> classNames)
+        public static NativeWindow GetTopMostWindow()
         {
             // Is there are win32 function to get a list off all top level windows
             // with a given class name?
@@ -98,23 +98,21 @@ public static NativeWindow GetTopMostWindow(IEnumerable<string> classNames)
             // about.
 
             // https://code.msdn.microsoft.com/windowsapps/Enumerate-top-level-9aa9d7c1
-
-            var results = new List<IntPtr>();
-            //WinApiInterop.WinApiUtils.EnumWindows(new WinApiInterop.WinApiUtils.EnumWindowsProc(EnumTheWindows), IntPtr.Zero);
-
             // http://stackoverflow.com/a/296014
 
+            var results = new List<NativeWindow>();
             WinApiInterop.NativeMethods.EnumWindows((hWnd, lParam) =>
             {
-                var win = new NativeWindow(hWnd);
-
-                foreach (var className in classNames)
+                var window = new NativeWindow(hWnd);
+                
+                // Skip some
+                if ((!window.IsMinimized) && (window.IsVisible))
                 {
-                    if ((String.Compare(win.ClassName, className, StringComparison.OrdinalIgnoreCase) == 0) &&
-                        (!win.IsMinimized) && 
-                        (win.IsVisible))
+                    var className = window.ClassName;
+                    // TODO: better checks for inappropriate windows
+                    if ((className != "Shell_TrayWnd") && (className != "Button") && (!className.Contains("ScreenGrid")))
                     {
-                        results.Add(hWnd);
+                        results.Add(window);
                     }
                 }
 
@@ -123,12 +121,17 @@ public static NativeWindow GetTopMostWindow(IEnumerable<string> classNames)
 
             if (results.Count > 0)
             {
-                return new NativeWindow(results[0]);
+                return results[0];
             }
             else
             {
                 return null;
             }
         }
+
+        public override string ToString()
+        {
+            return this.ClassName;
+        }
     }
 }
diff --git a/Src/ScreenGrid.Models/FlatImage.cs b/Src/ScreenGrid.Models/FlatImage.cs
@@ -89,7 +89,7 @@ private IList<IntegerSegment> FindVerticalZeroSegments(int ix, int minimalSegmen
             return IntegerSegmentUtils.FindZeroSegments(FlatImage.GetDerivative(this.GetVerticalStripe(ix)), minimalSegmentLength);
         }
 
-        public Models.Geometry.Rectangle FindBoundingsOfInnerImage()
+        public Models.Geometry.Rectangle FindBoundsOfInnerImage()
         {
             // TODO: add tests for this method
             const int minimalSegmentLength = 8;
diff --git a/Src/ScreenGrid.ViewModels/ScreenGridViewModel.cs b/Src/ScreenGrid.ViewModels/ScreenGridViewModel.cs
@@ -30,7 +30,7 @@ public ScreenGridViewModel()
             this.RotateCounterClockwiseCommand = new RelayCommand((o) => { this.Rot = Rotator.RotateCounterClockwise(this.Rot); });
             this.FlipHorizontalCommand = new RelayCommand((o) => { this.FlipH = !this.FlipH; });
             this.FlipVerticalCommand = new RelayCommand((o) => { this.FlipV = !this.FlipV; });
-            this.SnapCommand = new RelayCommand((o) => { this.SnapToRenderView(); });
+            this.SnapCommand = new RelayCommand((o) => { this.SnapToImageBounds(); });
         }
 
         public ICommand RotateClockwiseCommand { get; private set; }
@@ -260,24 +260,10 @@ public string CaptionText
             }
         }
 
-        private IList<string> GetWindowClassNames()
-        {
-            var classNames = new List<string>();
-
-            classNames.Add(Models.AppsInterop.PhotoViewerWindow.MainWindowClassName);
-
-            var orw = Models.AppsInterop.OctaneRenderWindow.GetFromAllProcesses();
-            classNames.AddRange(orw.Select(w => w.ClassName));
-
-            classNames.Add("MozillaWindowClass"); // TODO: do not use window class names, check any applications with topmost windows
-
-            return classNames;
-        }
-
-        public void SnapToRenderView()
+        public void SnapToImageBounds()
         {
             // select foreground window from several processes of supported applications
-            var nativeWindow = Models.AppsInterop.NativeWindow.GetTopMostWindow(this.GetWindowClassNames());
+            var nativeWindow = Models.AppsInterop.NativeWindow.GetTopMostWindow();
 
             if (nativeWindow != null)
             {
@@ -298,26 +284,26 @@ public void SnapToRenderView()
                         var bitmap = nativeWindow.GetShot();
                         var flatImage = new Models.FlatImage(bitmap);
 
-                        Models.Geometry.Rectangle imageBoundings;
+                        Models.Geometry.Rectangle imageBounds;
                         if (Models.AppsInterop.OctaneRenderWindow.GetFromAllProcesses().Any(w => w.ClassName == nativeWindow.ClassName))
                         {
                             // TODO: remove this Octane Render specific code
-                            imageBoundings = Models.AppsInterop.OctaneRenderWindow.FindRenderedImageBorders(flatImage);
+                            imageBounds = Models.AppsInterop.OctaneRenderWindow.FindRenderedImageBorders(flatImage);
                         }
                         else
                         {
-                            imageBoundings = flatImage.FindBoundingsOfInnerImage();
+                            imageBounds = flatImage.FindBoundsOfInnerImage();
                         }
 
                         var nativeWindowLocation = new Models.Geometry.Point(nativeWindow.Location.X, nativeWindow.Location.Y);
-                        return new Tuple<Models.Geometry.Rectangle, Models.Geometry.Point>(imageBoundings, nativeWindowLocation);
+                        return new Tuple<Models.Geometry.Rectangle, Models.Geometry.Point>(imageBounds, nativeWindowLocation);
                     }).ContinueWith((t) =>
                     {
-                        var imageBoundings = t.Result.Item1;
+                        var imageBounds = t.Result.Item1;
                         var windowLocation = t.Result.Item2;
-                        if (!imageBoundings.IsEmpty)
+                        if (!imageBounds.IsEmpty)
                         {
-                            if ((imageBoundings.Width > 150) && (imageBoundings.Height > 50))
+                            if ((imageBounds.Width > 150) && (imageBounds.Height > 50))
                             {
                                 this.PositionWindow(t.Result.Item2, t.Result.Item1);
                             }
diff --git a/Src/ScreenGrid.Views/ScreenGridWindow.xaml.cs b/Src/ScreenGrid.Views/ScreenGridWindow.xaml.cs
@@ -41,7 +41,6 @@ public ScreenGridWindow()
         private void Window_Loaded(object sender, RoutedEventArgs e)
         {
             this.cntxMenu = CreateContextMenu();
-            this.vm.SnapToRenderView();
         }
 
         private void Window_MouseDown(object sender, MouseButtonEventArgs e)
diff --git a/Src/ScreenGrid.WinApiInterop/GetWindowCommand.cs b/Src/ScreenGrid.WinApiInterop/GetWindowCommand.cs
@@ -2,7 +2,7 @@
 {
     // http://pinvoke.net/default.aspx/user32/GetWindow.html
 
-    enum GetWindowCommand : uint
+    public enum GetWindowCommand : uint
     {
         GW_HWNDFIRST = 0,
         GW_HWNDLAST = 1,
diff --git a/Src/ScreenGrid.WinApiInterop/NativeMethods.cs b/Src/ScreenGrid.WinApiInterop/NativeMethods.cs
@@ -54,6 +54,19 @@ private static extern UInt64 BitBlt
         [DllImport("user32.dll")]
         public static extern int GetClassName(IntPtr hWnd, StringBuilder lpClassName, int nMaxCount);
 
+        [DllImport("user32.dll")]
+        public static extern IntPtr GetTopWindow(IntPtr hWnd);
+
+        [DllImport("user32.dll")]
+        public static extern IntPtr GetForegroundWindow();
+
+        [DllImport("user32.dll")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool IsWindowVisible(IntPtr hWnd);
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto, EntryPoint = "GetWindow", SetLastError = true)]
+        public static extern IntPtr GetNextWindow(IntPtr hwnd, [MarshalAs(UnmanagedType.U4)] int wFlag);
+
         [DllImport("user32.dll")]
         public static extern bool EnumWindows(EnumWindowsProc enumProc, IntPtr lParam);
 

Original file line number	Diff line number	Diff line change
`@@ -61,11 +61,11 @@ public void FindBordersTest()`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`[Test]`
`64`		`- public void FindBoundingsOfInnerImage()`
	`64`	`+ public void FindBoundsOfInnerImage()`
`65`	`65`	`{`
`66`	`66`	`var flatImage = LoadFlatImageFromResource("ScreenGrid.Models.Tests.Resources.ImageSimple.png");`
`67`	`67`
`68`		`- var result = flatImage.FindBoundingsOfInnerImage();`
	`68`	`+ var result = flatImage.FindBoundsOfInnerImage();`
`69`	`69`
`70`	`70`	`Assert.AreEqual(12, result.X);`
`71`	`71`	`Assert.AreEqual(10, result.Y);`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ public Bitmap GetShot()`
`89`	`89`	`return WinApiInterop.NativeMethods.GetWindowImage(this.hWnd, 0, 0, (rect.Right - rect.Left) + 1, (rect.Bottom - rect.Top) + 1); // TODO: +1 ?`
`90`	`90`	`}`
`91`	`91`
`92`		`- public static NativeWindow GetTopMostWindow(IEnumerable<string> classNames)`
	`92`	`+ public static NativeWindow GetTopMostWindow()`
`93`	`93`	`{`
`94`	`94`	`// Is there are win32 function to get a list off all top level windows`
`95`	`95`	`// with a given class name?`
`@@ -98,23 +98,21 @@ public static NativeWindow GetTopMostWindow(IEnumerable<string> classNames)`
`98`	`98`	`// about.`
`99`	`99`
`100`	`100`	`// https://code.msdn.microsoft.com/windowsapps/Enumerate-top-level-9aa9d7c1`
`101`		`-`
`102`		`- var results = new List<IntPtr>();`
`103`		`- //WinApiInterop.WinApiUtils.EnumWindows(new WinApiInterop.WinApiUtils.EnumWindowsProc(EnumTheWindows), IntPtr.Zero);`
`104`		`-`
`105`	`101`	`// http://stackoverflow.com/a/296014`
`106`	`102`
	`103`	`+ var results = new List<NativeWindow>();`
`107`	`104`	`WinApiInterop.NativeMethods.EnumWindows((hWnd, lParam) =>`
`108`	`105`	`{`
`109`		`- var win = new NativeWindow(hWnd);`
`110`		`-`
`111`		`- foreach (var className in classNames)`
	`106`	`+ var window = new NativeWindow(hWnd);`
	`107`	`+`
	`108`	`+ // Skip some`
	`109`	`+ if ((!window.IsMinimized) && (window.IsVisible))`
`112`	`110`	`{`
`113`		`- if ((String.Compare(win.ClassName, className, StringComparison.OrdinalIgnoreCase) == 0) &&`
`114`		`- (!win.IsMinimized) &&`
`115`		`- (win.IsVisible))`
	`111`	`+ var className = window.ClassName;`
	`112`	`+ // TODO: better checks for inappropriate windows`
	`113`	`+ if ((className != "Shell_TrayWnd") && (className != "Button") && (!className.Contains("ScreenGrid")))`
`116`	`114`	`{`
`117`		`- results.Add(hWnd);`
	`115`	`+ results.Add(window);`
`118`	`116`	`}`
`119`	`117`	`}`
`120`	`118`
`@@ -123,12 +121,17 @@ public static NativeWindow GetTopMostWindow(IEnumerable<string> classNames)`
`123`	`121`
`124`	`122`	`if (results.Count > 0)`
`125`	`123`	`{`
`126`		`- return new NativeWindow(results[0]);`
	`124`	`+ return results[0];`
`127`	`125`	`}`
`128`	`126`	`else`
`129`	`127`	`{`
`130`	`128`	`return null;`
`131`	`129`	`}`
`132`	`130`	`}`
	`131`	`+`
	`132`	`+ public override string ToString()`
	`133`	`+ {`
	`134`	`+ return this.ClassName;`
	`135`	`+ }`
`133`	`136`	`}`
`134`	`137`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ private IList<IntegerSegment> FindVerticalZeroSegments(int ix, int minimalSegmen`
`89`	`89`	`return IntegerSegmentUtils.FindZeroSegments(FlatImage.GetDerivative(this.GetVerticalStripe(ix)), minimalSegmentLength);`
`90`	`90`	`}`
`91`	`91`
`92`		`- public Models.Geometry.Rectangle FindBoundingsOfInnerImage()`
	`92`	`+ public Models.Geometry.Rectangle FindBoundsOfInnerImage()`
`93`	`93`	`{`
`94`	`94`	`// TODO: add tests for this method`
`95`	`95`	`const int minimalSegmentLength = 8;`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public ScreenGridViewModel()`
`30`	`30`	`this.RotateCounterClockwiseCommand = new RelayCommand((o) => { this.Rot = Rotator.RotateCounterClockwise(this.Rot); });`
`31`	`31`	`this.FlipHorizontalCommand = new RelayCommand((o) => { this.FlipH = !this.FlipH; });`
`32`	`32`	`this.FlipVerticalCommand = new RelayCommand((o) => { this.FlipV = !this.FlipV; });`
`33`		`- this.SnapCommand = new RelayCommand((o) => { this.SnapToRenderView(); });`
	`33`	`+ this.SnapCommand = new RelayCommand((o) => { this.SnapToImageBounds(); });`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`public ICommand RotateClockwiseCommand { get; private set; }`
`@@ -260,24 +260,10 @@ public string CaptionText`
`260`	`260`	`}`
`261`	`261`	`}`
`262`	`262`
`263`		`- private IList<string> GetWindowClassNames()`
`264`		`- {`
`265`		`- var classNames = new List<string>();`
`266`		`-`
`267`		`- classNames.Add(Models.AppsInterop.PhotoViewerWindow.MainWindowClassName);`
`268`		`-`
`269`		`- var orw = Models.AppsInterop.OctaneRenderWindow.GetFromAllProcesses();`
`270`		`- classNames.AddRange(orw.Select(w => w.ClassName));`
`271`		`-`
`272`		`- classNames.Add("MozillaWindowClass"); // TODO: do not use window class names, check any applications with topmost windows`
`273`		`-`
`274`		`- return classNames;`
`275`		`- }`
`276`		`-`
`277`		`- public void SnapToRenderView()`
	`263`	`+ public void SnapToImageBounds()`
`278`	`264`	`{`
`279`	`265`	`// select foreground window from several processes of supported applications`
`280`		`- var nativeWindow = Models.AppsInterop.NativeWindow.GetTopMostWindow(this.GetWindowClassNames());`
	`266`	`+ var nativeWindow = Models.AppsInterop.NativeWindow.GetTopMostWindow();`
`281`	`267`
`282`	`268`	`if (nativeWindow != null)`
`283`	`269`	`{`
`@@ -298,26 +284,26 @@ public void SnapToRenderView()`
`298`	`284`	`var bitmap = nativeWindow.GetShot();`
`299`	`285`	`var flatImage = new Models.FlatImage(bitmap);`
`300`	`286`
`301`		`- Models.Geometry.Rectangle imageBoundings;`
	`287`	`+ Models.Geometry.Rectangle imageBounds;`
`302`	`288`	`if (Models.AppsInterop.OctaneRenderWindow.GetFromAllProcesses().Any(w => w.ClassName == nativeWindow.ClassName))`
`303`	`289`	`{`
`304`	`290`	`// TODO: remove this Octane Render specific code`
`305`		`- imageBoundings = Models.AppsInterop.OctaneRenderWindow.FindRenderedImageBorders(flatImage);`
	`291`	`+ imageBounds = Models.AppsInterop.OctaneRenderWindow.FindRenderedImageBorders(flatImage);`
`306`	`292`	`}`
`307`	`293`	`else`
`308`	`294`	`{`
`309`		`- imageBoundings = flatImage.FindBoundingsOfInnerImage();`
	`295`	`+ imageBounds = flatImage.FindBoundsOfInnerImage();`
`310`	`296`	`}`
`311`	`297`
`312`	`298`	`var nativeWindowLocation = new Models.Geometry.Point(nativeWindow.Location.X, nativeWindow.Location.Y);`
`313`		`- return new Tuple<Models.Geometry.Rectangle, Models.Geometry.Point>(imageBoundings, nativeWindowLocation);`
	`299`	`+ return new Tuple<Models.Geometry.Rectangle, Models.Geometry.Point>(imageBounds, nativeWindowLocation);`
`314`	`300`	`}).ContinueWith((t) =>`
`315`	`301`	`{`
`316`		`- var imageBoundings = t.Result.Item1;`
	`302`	`+ var imageBounds = t.Result.Item1;`
`317`	`303`	`var windowLocation = t.Result.Item2;`
`318`		`- if (!imageBoundings.IsEmpty)`
	`304`	`+ if (!imageBounds.IsEmpty)`
`319`	`305`	`{`
`320`		`- if ((imageBoundings.Width > 150) && (imageBoundings.Height > 50))`
	`306`	`+ if ((imageBounds.Width > 150) && (imageBounds.Height > 50))`
`321`	`307`	`{`
`322`	`308`	`this.PositionWindow(t.Result.Item2, t.Result.Item1);`
`323`	`309`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,6 @@ public ScreenGridWindow()`
`41`	`41`	`private void Window_Loaded(object sender, RoutedEventArgs e)`
`42`	`42`	`{`
`43`	`43`	`this.cntxMenu = CreateContextMenu();`
`44`		`- this.vm.SnapToRenderView();`
`45`	`44`	`}`
`46`	`45`
`47`	`46`	`private void Window_MouseDown(object sender, MouseButtonEventArgs e)`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`	`{`
`3`	`3`	`// http://pinvoke.net/default.aspx/user32/GetWindow.html`
`4`	`4`
`5`		`- enum GetWindowCommand : uint`
	`5`	`+ public enum GetWindowCommand : uint`
`6`	`6`	`{`
`7`	`7`	`GW_HWNDFIRST = 0,`
`8`	`8`	`GW_HWNDLAST = 1,`