private static void CheckForFinishExitingFullscreen()
{
numChecksForFinishExiting++;
if (windowController == IntPtr.Zero || numChecksForFinishExiting > 500)
{
EditorApplication.update -= CheckForFinishExitingFullscreen;
}
else
{
try
{
var isStillExitingFullscreen = SystemDisplay.MainWindowIsExitingFullscreen();
if (!isStillExitingFullscreen)
{
EditorApplication.update -= CheckForFinishExitingFullscreen;
//Finished exiting fullscreen, so reset the window position.
var fullscreenState = GetWindowFullscreenState();
var fullscreenOnDisplay = EditorDisplay.ClosestToPoint(fullscreenState.FullscreenAtPosition);
fullscreenOnDisplay.Locked = false;
var prePos = fullscreenState.PreFullscreenPosition;
prePos.width = Mathf.Max(300, prePos.width);
prePos.height = Mathf.Max(300, prePos.height);
position = prePos;
fullscreenState.currentlyRestoringFromState = false;
FS.SaveFullscreenState();
}
}
catch (Exception e)
{
Debug.LogError(e);
EditorApplication.update -= CheckForFinishExitingFullscreen;
}
}
}
public static List <SystemDisplay> GetAllDisplays()
{
List <SystemDisplay> allDisplays = new List <SystemDisplay>();
uint[] activeDisplays = new uint[32];
uint displayCount = 0;
CGGetActiveDisplayList(32, activeDisplays, ref displayCount);
for (int i = 0; i < displayCount; i++)
{
var displayID = activeDisplays[i];
var display = new SystemDisplay();
display.AttachedToDesktop = true;
display.IsPrimary = CGDisplayIsMain(displayID);
display.HasMainWindow = display.IsPrimary;
display.PixelHeight = (int)CGDisplayPixelsHigh(displayID);
display.PixelWidth = (int)CGDisplayPixelsWide(displayID);
var dispBounds = CGDisplayBounds(displayID);
var position = CGPoint.ToVector2(dispBounds.origin);
var size = CGSize.ToVector2(dispBounds.size);
var bounds = new Rect(position.x, position.y, size.x, size.y);
display.Bounds = bounds;
display.PhysicalBounds = display.Bounds;
display.WorkArea = display.Bounds;
allDisplays.Add(display);
}
return(allDisplays);
}
///Get all the displays, and choose whether to include monitors not attached to the desktop
public static SystemDisplay[] GetAllDisplays(bool IncludeMonitorsNotAttachedToDesktop)
{
var allDisplays = NativeDisplay.GetAllDisplays();
if (!IncludeMonitorsNotAttachedToDesktop)
{
//Remove displays not attached to the desktop
allDisplays.RemoveAll(display => !display.AttachedToDesktop);
}
if (allDisplays == null || allDisplays.Count == 0)
{
/*Failed to find the displays, so add the primary Screen as a display*/
var display = new SystemDisplay();
display.Bounds = new Rect(0, 0, Screen.currentResolution.width, Screen.currentResolution.height);
display.PhysicalBounds = display.Bounds;
display.PixelWidth = (int)display.PhysicalBounds.width;
display.PixelHeight = (int)display.PhysicalBounds.height;
display.WorkArea = display.Bounds;
display.AttachedToDesktop = true;
display.IsPrimary = true;
allDisplays.Add(display);
}
return(allDisplays.ToArray());
}
/// Makes sure a window covers the taskbar when it is fullscreen
internal static bool MakeWindowCoverTaskBar(EditorWindow editorWindow, SystemDisplay display)
{
if (editorWindow == null)
{
return(false);
}
return(MakeWindowCoverTaskBar(editorWindow, null, null, display));
}
// draw scannode (may be null),
// curmats may be null
public void DrawSystem(StarScan.SystemNode systemnode, List <MaterialCommodityMicroResource> historicmats,
List <MaterialCommodityMicroResource> curmats, string opttext = null, string[] filter = null)
{
HideInfo();
SystemDisplay.BackColor = this.BackColor;
SystemDisplay.LabelColor = EDDTheme.Instance.LabelColor;
SystemDisplay.DrawSystem(imagebox, WidthAvailable, systemnode, historicmats, curmats, opttext, filter);
imagebox.Render(); // replaces image..
}
/// <summary>
/// Get an EditorDisplay from a SystemDisplay
/// </summary>
private static EditorDisplay FromSystemDisplay(SystemDisplay sys)
{
if (sys == null)
{
return(null);
}
EditorDisplay ed = new EditorDisplay(sys.Bounds);
ed.PrimaryDisplay = sys.IsPrimary;
return(ed);
}
public static bool ContainsPoint(this SystemDisplay display, Vector2 point, bool physicalPoint)
{
if (physicalPoint)
{
return(display.PhysicalBounds.Contains(point));
}
else
{
return(display.Bounds.Contains(point));
}
}
/// Makes sure a window covers the taskbar when it is fullscreen
internal static void MakeWindowCoverTaskBar(string windowTitle, SystemDisplay display)
{
IntPtr windowHandle = GetProcessWindow(null, windowTitle, true);
int existingExStyle = GetWindowLong(windowHandle, GWL_EXSTYLE);
SetWindowLong(windowHandle, GWL_EXSTYLE,
existingExStyle & (int)(WS_EX_DLGMODALFRAME | WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE));
SetWindowPos(windowHandle, IntPtr.Zero, (int)display.Bounds.x, (int)display.Bounds.y, (int)display.Bounds.width, (int)display.Bounds.height,
SWP.NOZORDER | SWP.FRAMECHANGED | SWP.NOACTIVATE);
}
public Shooter(SystemDisplay main, int level)
{
_main = main;
_ship = new ShooterShip(0, _width);
_levels = new List <ShooterLevel>();
_herdList = new List <ShooterHerd>();
//remove later
SystemMain.Drawing.DestroyTips();
SystemMain.Drawing.DrawInstruction(40, 560, " to try and kill SQUIDS!", SystemMain.TexturePackage["A"], 3);
StartGame(level);
}
//projectile list
public Shooter(SystemDisplay main)
{
_main = main;
_ship = new ShooterShip();
//_shipRect = new Rectangle(_ship.GetX(), _ship.GetY(), _ship.GetWidth(), _ship.GetHeight());
#region sample level - delete when xml works
_enemies = new List <ShooterEnemy>
{
new ShooterEnemy(0, 0, 10, Color.White),
//new ShooterEnemy(1, 0, 10, Color.Gainsboro),
//new ShooterEnemy(4, 0, 10, Color.Goldenrod)
};
#endregion
}
internal static bool WindowIsFullscreenOnDisplay(string windowTitle, SystemDisplay display)
{
IntPtr windowHandle = GetProcessWindow(null, windowTitle, true);
Rect winPhysBounds = GetWindowPhysicalBounds(windowHandle);
Rect displayPhysBounds = display.PhysicalBounds;
float padding = 1;
winPhysBounds.xMin -= padding;
winPhysBounds.xMax += padding;
winPhysBounds.yMin -= padding;
winPhysBounds.yMax += padding;
return(winPhysBounds.Contains(displayPhysBounds));
}
private static void Begin(string existingLog, StackFrame stack)
{
#if UNITY_EDITOR_OSX
SystemDisplay.EnableDebugging(Enabled);
#endif
debugLog = "";
numWarnings = 0;
numErrors = 0;
logBeginTime = DateTime.Now;
if (timerStartTimes != null)
{
timerStartTimes.Clear();
}
else
{
timerStartTimes = new Dictionary <string, DateTime>();
}
if (settings.debugModeEnabled && debugLogBegun == false)
{
debugLogBegun = true;
if (stack == null)
{
stack = new StackFrame(1, true);
}
if (String.IsNullOrEmpty(existingLog))
{
//Start debugging and add system information to the log
LogLine("Debugging Enabled - Editor Window Fullscreen - To disable debugging, uncheck it in the 'Fullscreen Window Settings' window.", stack);
Log("OS: " + OSVersion + ".");
Log(" Unity Version: " + Application.unityVersion + ".");
Log(" EWF Version: " + EditorFullscreenSettings.Version + "\n");
Log("-------------------------------------\n");
}
else
{
//Start debugging with existing log
LogLine("\nDebugging Resuming - Editor Window Fullscreen - Existing Log");
}
}
}
/// <summary> Make the EditorWindow into a fullscreen window, with the option to show the top tabs. Opens the fullscreen window on the screen at a specified position. </summary>
private static Rect MakeFullscreenWindow(this EditorWindow editorWindow, bool hideTopToolbar, Vector2 atPosition)
{
var winRect = EditorDisplay.ClosestToPoint(atPosition).Bounds;
if (hideTopToolbar == true)
{
/*Move the top tab off the screen*/
winRect.y -= FS.topTabFullHeight;
winRect.height += FS.topTabFullHeight;
}
editorWindow.SetBorderlessPosition(winRect, hideTopToolbar);
#if UNITY_STANDALONE_WIN
//Fix positioning bug when monitors have differing scale
var sysDisplays = SystemDisplay.GetAllDisplays();
var fullscreenDisp = sysDisplays.ClosestToPoint(atPosition);
var mainWindowDisp = sysDisplays.WithMainWindow();
if (fullscreenDisp != mainWindowDisp)
{
//Check if there is a scaling difference between the main window display and the fullscreen display.
float fullscreenDispScale = fullscreenDisp.PixelWidth / fullscreenDisp.Bounds.width;
float mainWindowDispScale = mainWindowDisp.PixelWidth / mainWindowDisp.Bounds.width;
if (fullscreenDispScale != mainWindowDispScale)
{
//There is a scaling difference, so adjust the winRect to account for the scaling. (Because the window is positioned based on the scaling of the main window display).
float relativeScale = fullscreenDispScale / mainWindowDispScale;
winRect.x = winRect.x * relativeScale;
winRect.y = winRect.y * relativeScale;
winRect.width = winRect.width * relativeScale;
winRect.height = winRect.height * relativeScale;
}
editorWindow.SetBorderlessPosition(winRect, hideTopToolbar);
//Call system SetWindowPosition to make sure the window covers the taskbar
SystemDisplay.MakeWindowCoverTaskBar(editorWindow.GetWindowTitle(), fullscreenDisp);
//Hide the top toolbar if necessary.
editorWindow.SetToolbarVisibilityAtPos(winRect, hideTopToolbar, false);
}
#endif
return(winRect);
}
/// <summary> Makes a window with the specified title fullscreen on a system display. (This method currently only supports Windows OS) </summary>
public static void MakeWindowCoverTaskBar(string windowTitle, SystemDisplay display)
{
MethodInfo makeWindowCoverTaskBar = null;
try
{
makeWindowCoverTaskBar = typeof(NativeDisplay).BaseType.GetMethod("MakeWindowCoverTaskBar", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new[] { typeof(string), typeof(SystemDisplay) }, null);
}
catch { }
//If the OS Native Display class has the method, call that, otherwise throw an exception.
if (makeWindowCoverTaskBar != null)
{
makeWindowCoverTaskBar.Invoke(null, new object[] { windowTitle, display });
}
else
{
throw new MissingMethodException("This method is not implemented for the current Operating System.");
}
}
public static bool ToggleFullscreen(bool showTopToolbar, Vector2 fullscreenAtPosition)
{
var fullscreenState = GetWindowFullscreenState();
#if UNITY_EDITOR_OSX
bool setFullscreen = !SystemDisplay.MainWindowIsFullscreen();
#else
var currentScreenBounds = EditorDisplay.ClosestToPoint(position.center).Bounds;
var newFullscreenBounds = EditorDisplay.ClosestToPoint(fullscreenAtPosition).Bounds;
bool setFullscreen = (!fullscreenState.IsFullscreen || currentScreenBounds != newFullscreenBounds);
#endif
if (EditorWindowExtensions.ExitFullscreenForOtherWindowsOnScreen(fullscreenState.EditorWin, fullscreenAtPosition))
{
setFullscreen = true;
SetFullscreen(setFullscreen, showTopToolbar, fullscreenAtPosition);
}
SetFullscreen(setFullscreen, showTopToolbar, fullscreenAtPosition);
return(setFullscreen);
}
public static SystemDisplay ClosestToPoint(this SystemDisplay[] displayList, Vector2 point, bool physicalPoint)
{
float closestDistance = 0;
SystemDisplay closestDisplay = null;
foreach (SystemDisplay display in displayList)
{
if (display.ContainsPoint(point, physicalPoint))
{
return(display);
}
var dist = physicalPoint ? display.PhysicalBounds.DistanceToPoint(point) : display.Bounds.DistanceToPoint(point);
if (dist < closestDistance || closestDisplay == null)
{
closestDistance = dist;
closestDisplay = display;
}
}
return(closestDisplay);
}
public static void SetFullscreen(bool fullscreen, bool showTopToolbar, Vector2 fullscreenAtPosition, bool disableUpdatePrePos)
{
var fullscreenState = GetWindowFullscreenState();
var fullscreenOnDisplay = EditorDisplay.ClosestToPoint(fullscreenAtPosition);
var screenBounds = fullscreenOnDisplay.Bounds;
#if UNITY_EDITOR_OSX
if (fullscreenOnDisplay.Locked)
{
FS.RunAfterDisplayNotLocked(fullscreenAtPosition, () => SetFullscreen(fullscreen, showTopToolbar, fullscreenAtPosition, disableUpdatePrePos));
return;
}
#endif
var originallyFocusedEditorWin = EditorWindow.focusedWindow;
var originallyFocusedEditorWinType = originallyFocusedEditorWin == null ? null : originallyFocusedEditorWin.GetType();
object mainWindow = null;
#if UNITY_EDITOR_OSX
bool wasFullscreen = SystemDisplay.MainWindowIsFullscreen(); //If toggling the top toolbar, don't update pre positions.
bool updatePrePos = fullscreen && !wasFullscreen && !disableUpdatePrePos;
windowController = IntPtr.Zero;
if (fullscreen)
{
fullscreenState.ScreenBounds = screenBounds;
fullscreenState.FullscreenAtPosition = fullscreenAtPosition;
}
if (updatePrePos)
{
fullscreenState.PreFullscreenPosition = position;
fullscreenState.PreFullscreenMinSize = minSize;
fullscreenState.PreFullscreenMaxSize = maxSize;
}
var prePos = fullscreenState.PreFullscreenPosition;
if (prePos.width < 100 || prePos.height < 100 || prePos.width < fullscreenState.PreFullscreenMinSize.x || prePos.height < fullscreenState.PreFullscreenMinSize.y)
{
prePos = new Rect(prePos.x, prePos.y, Mathf.Max(fullscreenState.PreFullscreenMinSize.x, 300), Mathf.Max(fullscreenState.PreFullscreenMinSize.y, 300)); //Make sure size is valid
}
if (fullscreen && !screenBounds.Contains(position.center))
{
if (wasFullscreen)
{
//Exit fullscreen because we are fullscreen on another screen
fullscreen = false;
}
else
{
//Move to the correct screen
SystemDisplay.SetMainWindowPosition((int)screenBounds.xMin, (int)screenBounds.yMin, (int)screenBounds.width, (int)screenBounds.height);
}
}
if (fullscreen != wasFullscreen)
{
windowController = SystemDisplay.ToggleFullscreenMainWindow((int)prePos.xMin, (int)prePos.yMin, (int)prePos.width, (int)prePos.height);
if (!fullscreen)
{
if (fullscreenState.ScreenBounds.Contains(prePos))
{
position = prePos; //Setting the position here first (even though still haven't finished exiting fullscreen) updates the docked window sizes so the shrinking animation is smoother.
}
else
{
var intermediatePos = fullscreenState.PreFullscreenPosition.CenterRectInBounds(fullscreenState.ScreenBounds);
position = intermediatePos; //Can't move screen yet because still fullscreen, so use an intermediate pos.
}
//Restore position once the fullscreen has finished exiting
if (windowController != IntPtr.Zero)
{
fullscreenOnDisplay.Locked = true;
EditorApplication.update += CheckForFinishExitingFullscreen;
numChecksForFinishExiting = 0;
}
}
else
{
fullscreenOnDisplay.Locked = true;
FS.RunAfter(() => { return(false); }, () =>
{
fullscreenOnDisplay.Locked = false;
fullscreenState.currentlyRestoringFromState = false;
FS.SaveFullscreenState();
}, 50, true);
}
}
fullscreenState.IsFullscreen = fullscreen;
FS.SaveFullscreenState();
#else
bool wasFullscreen = fullscreenState.IsFullscreen;
fullscreenState.ShowTopToolbar = showTopToolbar;
fullscreenState.originalContainerWindow = (ScriptableObject)FindOriginalContainerWindow();
fullscreenState.containerWindow = (ScriptableObject)FindContainerWindow();
mainWindow = FindMainWindow();
bool inOriginalContainer = fullscreenState.containerWindow == fullscreenState.originalContainerWindow;
#if UNITY_2018_2_OR_NEWER
var pixelsPerPoint = GetPixelsPerPointAtPosition(fullscreenAtPosition);
screenBounds.width /= pixelsPerPoint;
screenBounds.height /= pixelsPerPoint;
#endif
if (fullscreen)
{
fullscreenState.ScreenBounds = screenBounds;
fullscreenState.FullscreenAtPosition = fullscreenAtPosition;
if (!wasFullscreen)
{
var wasMaximized = maximized;
if (wasMaximized)
{
ToggleMaximize();
}
fullscreenState.PreFullscreenPosition = position;
fullscreenState.PreFullscreenMinSize = minSize;
fullscreenState.PreFullscreenMaxSize = maxSize;
fullscreenState.PreFullscreenMaximized = wasMaximized;
if (inOriginalContainer)
{
SystemDisplay.SaveMainWindowStyleInState(fullscreenState);
}
}
}
if (fullscreen && !showTopToolbar)
{
object fsContainerWindow;
if (inOriginalContainer)
{
fsContainerWindow = ScriptableObject.CreateInstance(FS.ContainerWindowType);
}
else
{
fsContainerWindow = fullscreenState.containerWindow;
}
//Put the main view into the fullscreen container window
containerMainView.SetValue(fsContainerWindow, mainWindow, null);
inOriginalContainer = false;
containerPosition.SetValue(fsContainerWindow, screenBounds, null);
if (containerShow.GetParameters().Length == 3)
{
containerShow.Invoke(fsContainerWindow, new object[] { 3, false, true });
}
else if (containerShow.GetParameters().Length == 4)
{
containerShow.Invoke(fsContainerWindow, new object[] { 3, false, true, true }); //4 parameters since Unity 2018
}
SetMinMaxSizes(screenBounds.size, screenBounds.size);
containerPosition.SetValue(fsContainerWindow, screenBounds, null);
MethodInfo displayAllViews = FS.ContainerWindowType.GetMethod("DisplayAllViews", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new System.Type[] { }, null);
displayAllViews.Invoke(fsContainerWindow, null);
fullscreenState.containerWindow = (ScriptableObject)fsContainerWindow;
fullscreenState.IsFullscreen = true;
}
else
{
if (fullscreenState.EditorWin != null)
{
fullscreenState.EditorWin.Close();
}
if (!inOriginalContainer)
{
//Reset main view back to original container view
containerMainViewField.SetValue(fullscreenState.originalContainerWindow, null);
containerMainView.SetValue(fullscreenState.originalContainerWindow, mainWindow, null);
try
{
containerMainViewField.SetValue(fullscreenState.containerWindow, null);
containerClose.Invoke(fullscreenState.containerWindow, null);
}
catch (System.Exception e)
{
if (EWFDebugging.Enabled)
{
Debug.LogException(e);
EWFDebugging.LogError(e.Message);
}
}
fullscreenState.containerWindow = fullscreenState.originalContainerWindow;
fullscreenState.IsFullscreen = false;
inOriginalContainer = true;
}
if (fullscreen)
{
//Set fullscreen with toolbar
var newPos = screenBounds;
newPos.yMin += topToolbarHeight;
position = newPos;
SetMinMaxSizes(newPos.size, newPos.size);
position = newPos;
if (position.x != newPos.x)
{
//Position didn't set correctly, so must be maximized
fullscreenState.PreFullscreenMaximized = true;
ToggleMaximize();
position = newPos;
}
fullscreenState.IsFullscreen = true;
}
}
if (!fullscreen && inOriginalContainer && wasFullscreen)
{
//Reset position
var prePos = fullscreenState.PreFullscreenPosition;
position = prePos;
fullscreenState.IsFullscreen = false;
position = fullscreenState.PreFullscreenPosition;
SetMinMaxSizes(fullscreenState.PreFullscreenMinSize, fullscreenState.PreFullscreenMaxSize);
position = fullscreenState.PreFullscreenPosition;
PropertyInfo pos = FS.ViewType.GetProperty("position", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
pos.SetValue(FindMainWindow(), fullscreenState.PreFullscreenPosition, null);
fullscreenState.IsFullscreen = false;
SystemDisplay.LoadMainWindowStyleInState(fullscreenState, true);
TriggerOnResizedAll();
Focus();
position = fullscreenState.PreFullscreenPosition; //Reset position
position = fullscreenState.PreFullscreenPosition;
if (fullscreenState.PreFullscreenMaximized != maximized)
{
ToggleMaximize();
}
}
fullscreenState.currentlyRestoringFromState = false;
FS.SaveFullscreenState();
#endif
//All platforms
FS.TriggerFullscreenEvent(mainWindow, FS.MainWindowType, fullscreenAtPosition, fullscreen);
if (EditorWindow.focusedWindow == null)
{
if (originallyFocusedEditorWin != null)
{
originallyFocusedEditorWin.Focus();
}
else if (originallyFocusedEditorWinType != null)
{
EditorWindow.FocusWindowIfItsOpen(originallyFocusedEditorWinType);
}
}
}
public static bool WindowIsFullscreenOnDisplay(EditorWindow editorWindow, string windowTitle, SystemDisplay display)
{
return(WindowsDisplay.WindowIsFullscreenOnDisplay(editorWindow, windowTitle, display));
}
public static List <SystemDisplay> GetAllDisplays()
{
List <SystemDisplay> allDisplays = new List <SystemDisplay>();
IntPtr hMainWindowMonitor = IntPtr.Zero;
IntPtr mainWindowHandle = IntPtr.Zero;
EWFDebugging.LogLine("Getting all displays.", 0, 4);
try
{
mainWindowHandle = GetProcessMainWindow();
if (mainWindowHandle != IntPtr.Zero)
{
var mainWindowMonitorInfoEx = MonitorInfoEx.CreateWithDefaults();
hMainWindowMonitor = MonitorFromWindow(mainWindowHandle, MONITOR_DEFAULTTONEAREST);
LogWin32Error("Error finding main window monitor");
if (hMainWindowMonitor != IntPtr.Zero)
{
GetMonitorInfo(hMainWindowMonitor, ref mainWindowMonitorInfoEx);
LogWin32Error("Error getting main window monitor info");
}
}
else
{
EWFDebugging.LogError("Could not find the process main window handle.");
}
}
catch (Exception e)
{
string err = "Error finding the main window monitor. " + e.ToString();
Debug.LogError(err);
EWFDebugging.LogError(err);
}
var deviceDisplayMonitorCount = new Dictionary <string, uint>();
EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero,
delegate(IntPtr hMonitor, IntPtr hdcMonitor, ref RectStruct lprcMonitor, IntPtr dwData)
{
try
{
//Get the monitor info
var monitorInfoEx = MonitorInfoEx.CreateWithDefaults();
GetMonitorInfo(hMonitor, ref monitorInfoEx);
LogWin32Error();
//Get the associated display device
bool mirroringDriver = false;
bool attachedToDesktop = false;
string deviceName = monitorInfoEx.DeviceName;
if (!deviceDisplayMonitorCount.ContainsKey(deviceName))
{
deviceDisplayMonitorCount.Add(deviceName, 0);
}
deviceDisplayMonitorCount[deviceName] += 1;
var displayDevice = Display_Device.CreateWithDefaults();
int displayMonitor = 0;
for (uint id = 0; EnumDisplayDevices(deviceName, id, ref displayDevice, 0); id++)
{
attachedToDesktop = ((displayDevice.StateFlags & DisplayDeviceStateFlags.AttachedToDesktop) == DisplayDeviceStateFlags.AttachedToDesktop);
if (attachedToDesktop)
{
displayMonitor++;
if (displayMonitor == deviceDisplayMonitorCount[deviceName])
{
mirroringDriver = ((displayDevice.StateFlags & DisplayDeviceStateFlags.MirroringDriver) == DisplayDeviceStateFlags.MirroringDriver);
break; //Found the display device which matches the monitor
}
}
displayDevice.Size = Marshal.SizeOf(displayDevice);
}
//Skip the monitor if it's a pseudo monitor
if (mirroringDriver)
{
return(true);
}
//Store the monitor info in a SystemDisplay object
var display = new SystemDisplay();
display.Name = displayDevice.DeviceString;
display.AttachedToDesktop = attachedToDesktop; //Should always be true within EnumDisplayMonitors
display.IsPrimary = monitorInfoEx.Flags == (uint)1;
display.HasMainWindow = (hMonitor == hMainWindowMonitor);
display.Bounds = RectFromRectStruct(lprcMonitor);
display.WorkArea = RectFromRectStruct(monitorInfoEx.WorkAreaBounds);
var devMode = new DEVMODE();
EnumDisplaySettings(monitorInfoEx.DeviceName, ENUM_CURRENT_SETTINGS, ref devMode);
display.PixelWidth = devMode.dmPelsWidth;
display.PixelHeight = devMode.dmPelsHeight;
//Add the SystemDisplay to allDisplays
allDisplays.Add(display);
}
catch (Exception e)
{
Debug.LogException(e);
EWFDebugging.LogError(e.ToString());
}
LogWin32Error();
return(true); //Continue the enumeration
}, IntPtr.Zero);
LogWin32Error();
//Calculate physical bounds
foreach (var display in allDisplays)
{
Rect physicalBounds = display.Bounds;
physicalBounds.width = display.PixelWidth;
physicalBounds.height = display.PixelHeight;
Vector2 displayTopLeft = new Vector2(display.Bounds.xMin, display.Bounds.yMin);
var displayTopLeftPhysical = GetPhysicalPoint(mainWindowHandle, displayTopLeft);
physicalBounds.x = displayTopLeftPhysical.x;
physicalBounds.y = displayTopLeftPhysical.y;
display.PhysicalBounds = physicalBounds;
}
return(allDisplays);
}
/// Makes a window with the specified title fullscreen on a system display.
public static void MakeWindowCoverTaskBar(string windowClass, string windowTitle, SystemDisplay display)
{
WindowsDisplay.MakeWindowCoverTaskBar(windowClass, windowTitle, display);
}
/// Makes sure a window covers the taskbar when it is fullscreen
internal static bool MakeWindowCoverTaskBar(string windowClass, string windowTitle, SystemDisplay display)
{
return(MakeWindowCoverTaskBar(null, windowClass, windowTitle, display));
}
/// Makes an editor window fullscreen on a system display.
public static void MakeWindowCoverTaskBar(EditorWindow editorWindow, SystemDisplay display)
{
WindowsDisplay.MakeWindowCoverTaskBar(editorWindow, display);
}
public NodeResponse Response(string partialpath, HttpListenerRequest request)
{
System.Diagnostics.Debug.WriteLine("Serve Scan Display " + partialpath);
//foreach (var k in request.QueryString.AllKeys) System.Diagnostics.Debug.WriteLine("Key {0} = {1}", k, request.QueryString[k]);
int entry = (request.QueryString["entry"] ?? "-1").InvariantParseInt(-1);
bool checkEDSM = (request.QueryString["EDSM"] ?? "false").InvariantParseBool(false);
Bitmap img = null;
JObject response = new JObject();
response["responsetype"] = "scandisplayobjects";
JArray objectlist = new JArray();
var hl = discoveryform.history;
if (hl.Count > 0)
{
if (entry < 0 || entry >= hl.Count)
{
entry = hl.Count - 1;
}
// seen instances of exceptions accessing icons in different threads. so push up to discovery form. need to investigate.
discoveryform.Invoke((MethodInvoker) delegate
{
StarScan.SystemNode sn = hl.StarScan.FindSystemSynchronous(hl.EntryOrder()[entry].System, checkEDSM);
if (sn != null)
{
int starsize = (request.QueryString["starsize"] ?? "48").InvariantParseInt(48);
int width = (request.QueryString["width"] ?? "800").InvariantParseInt(800);
SystemDisplay sd = new SystemDisplay();
sd.ShowMoons = (request.QueryString["showmoons"] ?? "true").InvariantParseBool(true);
sd.ShowOverlays = (request.QueryString["showbodyicons"] ?? "true").InvariantParseBool(true);
sd.ShowMaterials = (request.QueryString["showmaterials"] ?? "true").InvariantParseBool(true);
sd.ShowAllG = (request.QueryString["showgravity"] ?? "true").InvariantParseBool(true);
sd.ShowHabZone = (request.QueryString["showhabzone"] ?? "true").InvariantParseBool(true);
sd.ShowStarClasses = (request.QueryString["showstarclass"] ?? "true").InvariantParseBool(true);
sd.ShowPlanetClasses = (request.QueryString["showplanetclass"] ?? "true").InvariantParseBool(true);
sd.ShowDist = (request.QueryString["showdistance"] ?? "true").InvariantParseBool(true);
sd.ValueLimit = (request.QueryString["valuelimit"] ?? "50000").InvariantParseInt(50000);
sd.ShowEDSMBodies = checkEDSM;
sd.SetSize(starsize);
sd.Font = new Font("MS Sans Serif", 8.25f);
sd.LargerFont = new Font("MS Sans Serif", 10f);
sd.FontUnderlined = new Font("MS Sans Serif", 8.25f, FontStyle.Underline);
ExtendedControls.ExtPictureBox imagebox = new ExtendedControls.ExtPictureBox();
sd.DrawSystem(imagebox, width, sn, null, null);
//imagebox.AddTextAutoSize(new Point(10, 10), new Size(1000, 48), "Generated on " + DateTime.UtcNow.ToString(), new Font("MS Sans Serif", 8.25f), Color.Red, Color.Black, 0);
imagebox.Render();
foreach (var e in imagebox.Elements)
{
if (e.ToolTipText.HasChars())
{
// System.Diagnostics.Debug.WriteLine("{0} = {1}", e.Location, e.ToolTipText);
objectlist.Add(new JObject()
{
["left"] = e.Position.X, ["top"] = e.Position.Y, ["right"] = e.Location.Right, ["bottom"] = e.Location.Bottom, ["text"] = e.ToolTipText
});
}
}
img = imagebox.Image.Clone() as Bitmap;
imagebox.Dispose();
}
});
}
else
{
discoveryform.Invoke((MethodInvoker) delegate
{
img = BaseUtils.Icons.IconSet.GetIcon("Bodies.Unknown") as Bitmap;
});
}
response["objectlist"] = objectlist;
server.SendWebSockets(response, false); // refresh history
Bitmap bmpclone = img.Clone() as Bitmap;
var cnv = bmpclone.ConvertTo(System.Drawing.Imaging.ImageFormat.Png); // this converts to png and returns the raw PNG bytes..
WebHeaderCollection wc = new WebHeaderCollection(); // indicate don't cache this, this is a temp image
wc[HttpRequestHeader.CacheControl] = "no-store";
return(new NodeResponse(cnv, "image/png", wc));
}
/// Makes sure a window covers the taskbar when it is fullscreen
private static bool MakeWindowCoverTaskBar(EditorWindow editorWindow, string windowClass, string windowTitle, SystemDisplay display)
{
IntPtr windowHandle = IntPtr.Zero;
EWFDebugging.StartTimer("Making window cover taskbar");
EWFDebugging.LogLine("Making window cover taskbar. " + (editorWindow == null ? "WindowTitle: " + (windowTitle == null ? "null" : windowTitle) : "EditorWindow: '" + editorWindow.GetWindowTitle() + "' Window Type: '" + editorWindow.GetType() + "' with class: '" + (windowClass == null ? "null" : windowClass) + "'"));
if (editorWindow == null)
{
string fullscreenWindowClass = windowClass != null ? windowClass : "UnityPopupWndClass";
windowHandle = GetProcessWindow(fullscreenWindowClass, windowTitle, true);
if (windowHandle == IntPtr.Zero)
{
windowHandle = GetProcessWindow(null, windowTitle, true);
}
}
else
{
if (windowClass == null)
{
windowHandle = GetProcessWindow(editorWindow);
}
else
{
windowHandle = GetProcessWindow(windowClass, editorWindow);
}
}
if (windowHandle == IntPtr.Zero)
{
EWFDebugging.LogError("Couldn't find window handle.");
return(false);
}
IntPtr existingStyle = GetWindowLongPtr(windowHandle, GWL_STYLE);
IntPtr existingExStyle = GetWindowLongPtr(windowHandle, GWL_EXSTYLE);
if (editorWindow != null)
{
var state = EditorFullscreenState.FindWindowState(editorWindow);
if (state.OriginalStyle == 0)
{
state.OriginalStyle = (int)existingStyle;
}
if (state.OriginalExStyle == 0)
{
state.OriginalExStyle = (int)existingExStyle;
}
}
if (EWFDebugging.Enabled)
{
EWFDebugging.LogLine("before Style: " + WindowStyleToString(existingStyle));
EWFDebugging.LogLine("before ExStyle: " + WindowExStyleToString(existingExStyle));
}
SetWindowLongPtr(windowHandle, GWL_STYLE, (IntPtr)(WS_POPUP | WS_VISIBLE | ((uint)existingStyle & (WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_OVERLAPPED))));
LogWin32Error("Error setting window style");
SetWindowLongPtr(windowHandle, GWL_EXSTYLE, (IntPtr)((uint)existingExStyle & (WS_EX_LEFT | WS_EX_LTRREADING | WS_EX_RIGHTSCROLLBAR)));
LogWin32Error("Error setting window ex style");
SetWindowPos(windowHandle, IntPtr.Zero, (int)display.Bounds.x, (int)display.Bounds.y, (int)display.Bounds.width, (int)display.Bounds.height,
SWP.NOZORDER | SWP.FRAMECHANGED | SWP.NOACTIVATE);
LogWin32Error("Error setting window position");
if (EWFDebugging.Enabled)
{
existingStyle = GetWindowLongPtr(windowHandle, GWL_STYLE);
existingExStyle = GetWindowLongPtr(windowHandle, GWL_EXSTYLE);
EWFDebugging.LogLine("after Style: " + WindowStyleToString(existingStyle));
EWFDebugging.LogLine("after ExStyle: " + WindowExStyleToString(existingExStyle));
EWFDebugging.LogTime("Making window cover taskbar");
}
return(true);
}
/// <summary>
/// Obsolete. Use editorWindow.IsFullscreenOnDisplay(display) method.
/// </summary>
public static bool EditorWindowIsFullscreenOnDisplay(UnityEditor.EditorWindow editorWin, SystemDisplay display)
{
string windowTitle = editorWin.GetWindowTitle();
MethodInfo windowIsFullscreenOnDisplay = null;
try
{
windowIsFullscreenOnDisplay = typeof(NativeDisplay).BaseType.GetMethod("WindowIsFullscreenOnDisplay", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new[] { typeof(string), typeof(SystemDisplay) }, null);
} catch { }
bool winIsFullscreen = false;
//If the OS Native Display class has the method, call that, otherwise use a fallback.
if (windowIsFullscreenOnDisplay != null)
{
winIsFullscreen = (bool)windowIsFullscreenOnDisplay.Invoke(null, new object[] { windowTitle, display });
}
else
{
winIsFullscreen = editorWin.position.Contains(display.Bounds) && editorWin.position.width == display.Bounds.width;
}
return(winIsFullscreen);
}
internal static bool WindowIsFullscreenOnDisplay(EditorWindow editorWindow, string windowTitle, SystemDisplay display)
{
EWFDebugging.StartTimer("WindowIsFullscreenOnDisplay");
EWFDebugging.Log("Checking if window is fullscreen on display. " + (editorWindow == null ? "WindowTitle: " + (windowTitle == null ? "null" : windowTitle) : "EditorWindow: " + editorWindow.GetWindowTitle() + " Identifier: " + editorWindow.GetIdentifierTitle()) + "\n");
IntPtr windowHandle = GetProcessWindow(null, editorWindow);
LogWin32Error("Error getting window handle.");
if (windowHandle == IntPtr.Zero)
{
EWFDebugging.Log("Couldn't find window handle. Zero pointer.\n");
return(false);
}
Rect winPhysBounds = GetWindowPhysicalBounds(windowHandle);
Rect displayPhysBounds = display.PhysicalBounds;
float padding = 1;
winPhysBounds.xMin -= padding;
winPhysBounds.xMax += padding;
winPhysBounds.yMin -= padding;
winPhysBounds.yMax += padding;
EWFDebugging.LogTime("WindowIsFullscreenOnDisplay", false);
return(winPhysBounds.Contains(displayPhysBounds));
}
/// <summary>
/// Get all the displays which are attached to the desktop (As a List)
/// </summary>
public static List <EditorDisplay> GetAllDisplays()
{
EWFDebugging.StartTimer("GetAllDisplays");
List <EditorDisplay> allDisplays = new List <EditorDisplay>();
try
{
#if UNITY_EDITOR_OSX
//Get system displays
allDisplays = FromSystemDisplays(SystemDisplay.GetAllDisplays());
#else
allDisplays = FromSystemDisplays(SystemDisplay.GetAllDisplays());
//If couldn't find system displays, use backup method
if (allDisplays == null || allDisplays.Count < 1)
{
var desktopBounds = PrimaryDesktopResolution;
allDisplays = new List <EditorDisplay>();
//Find all the displays
var display = AddDisplayAtPoint(allDisplays, desktopBounds.center, true);
if (display != null)
{
AddContiguousDisplays(allDisplays, display);
}
}
#endif
}
catch (Exception e)
{
if (EWFDebugging.Enabled)
{
string err = "Failed to find all possible displays. " + e;
Debug.LogError(err);
EWFDebugging.LogError(err);
}
}
if (allDisplays.Count == 0)
{
/*Failed to find the displays, so add the primary Screen as a display*/
var display = new EditorDisplay(new Rect(0, 0, Screen.currentResolution.width, Screen.currentResolution.height));
allDisplays.Add(display);
}
//Sort screens by top-left to bottom-right
allDisplays.Sort(delegate(EditorDisplay a, EditorDisplay b)
{
bool aIsLess;
if (a.Bounds.y != b.Bounds.y)
{
aIsLess = a.Bounds.y < b.Bounds.y;
}
else
{
if (a.Bounds.x == b.Bounds.x)
{
return(0); //Equal
}
else
{
aIsLess = a.Bounds.x < b.Bounds.x;
}
}
return(aIsLess ? -1 : 1);
});
EWFDebugging.LogTime("GetAllDisplays", false);
EditorDisplay.allDisplays = allDisplays;
return(allDisplays);
}
/// Returns true if the display contains the specified logical point (logical point differs from physical point when there is display scaling)
public static bool ContainsPoint(this SystemDisplay display, Vector2 logicalPoint)
{
return(display.Bounds.Contains(logicalPoint));
}
