private void screenChanged(Screen newScreen)
{
currentScreen = newScreen as OsuScreen;
if (currentScreen == null)
{
Exit();
return;
}
//central game screen change logic.
if (!currentScreen.ShowOverlays)
{
settings.State = Visibility.Hidden;
Toolbar.State = Visibility.Hidden;
musicController.State = Visibility.Hidden;
chat.State = Visibility.Hidden;
direct.State = Visibility.Hidden;
social.State = Visibility.Hidden;
userProfile.State = Visibility.Hidden;
}
else
{
Toolbar.State = Visibility.Visible;
}
ScreenChanged?.Invoke(newScreen);
}
public void SetSelectedScreen(int screenNumber)
{
if (screenNumber == SelectedScreen)
{
return;
}
try
{
if (GetScreenCount() >= screenNumber + 1)
{
SelectedScreen = screenNumber;
}
else
{
SelectedScreen = 0;
}
var width = LibX11.XDisplayWidth(Display, SelectedScreen);
var height = LibX11.XDisplayHeight(Display, SelectedScreen);
CurrentScreenBounds = new Rectangle(0, 0, width, height);
CaptureFullscreen = true;
Init();
ScreenChanged?.Invoke(this, CurrentScreenBounds);
}
catch (Exception ex)
{
Logger.Write(ex);
}
}
private void RefreshCurrentScreenBounds()
{
CurrentScreenBounds = Screen.AllScreens[bitBltScreens[SelectedScreen]].Bounds;
CaptureFullscreen = true;
NeedsInit = true;
ScreenChanged?.Invoke(this, CurrentScreenBounds);
}
private void screenChanged(Screen newScreen)
{
//central game mode change logic.
if ((newScreen as OsuScreen)?.ShowOverlays != true)
{
Toolbar.State = Visibility.Hidden;
musicController.State = Visibility.Hidden;
chat.State = Visibility.Hidden;
}
else
{
Toolbar.State = Visibility.Visible;
}
if (newScreen is MainMenu)
{
Cursor.FadeIn(100);
}
ScreenChanged?.Invoke(newScreen);
if (newScreen == null)
{
Exit();
}
}
protected void Initialize()
{
/* _threadSafety = new ThreadSafetyEnforcer("Main Window Class");
* _invoker = new Invoker(_threadSafety); */
if (AvailableScreens == null)
{
throw new Exception("AvailableScreens not set!");
}
foreach (var screen in AvailableScreens)
{
screen.Value.Initialize();
}
if (!AvailableScreens.ContainsKey("MainMenu"))
{
throw new Exception("MainMenu not set!");
}
this.FormClosing += MainForm_FormClosing;
CurrentScreen = AvailableScreens["MainMenu"];
CurrentScreen.Load();
ScreenChanged?.Invoke(this, EventArgs.Empty);
this.Show();
}
private void screenChanged(Screen newScreen)
{
currentScreen = newScreen as OsuScreen;
if (currentScreen == null)
{
Exit();
return;
}
//central game screen change logic.
if (!currentScreen.ShowOverlays)
{
foreach (var container in overlayContainers(true))
{
container.State = Visibility.Hidden;
}
}
else
{
Toolbar.State = Visibility.Visible;
}
ScreenChanged?.Invoke(newScreen);
}
private void screenChanged(Screen newScreen)
{
currentScreen = newScreen as OsuScreen;
if (currentScreen == null)
{
Exit();
return;
}
//central game mode change logic.
if (!currentScreen.ShowOverlays)
{
options.State = Visibility.Hidden;
Toolbar.State = Visibility.Hidden;
musicController.State = Visibility.Hidden;
chat.State = Visibility.Hidden;
}
else
{
Toolbar.State = Visibility.Visible;
}
ScreenChanged?.Invoke(newScreen);
}
public void SetSelectedScreen(string displayName)
{
if (displayName == SelectedScreen)
{
return;
}
try
{
if (_x11Screens.ContainsKey(displayName))
{
SelectedScreen = displayName;
}
else
{
SelectedScreen = _x11Screens.Keys.First();
}
var width = LibX11.XDisplayWidth(Display, _x11Screens[SelectedScreen]);
var height = LibX11.XDisplayHeight(Display, _x11Screens[SelectedScreen]);
CurrentScreenBounds = new Rectangle(0, 0, width, height);
CaptureFullscreen = true;
ScreenChanged?.Invoke(this, CurrentScreenBounds);
}
catch (Exception ex)
{
Logger.Write(ex);
}
}
public void Init()
{
InitBitBlt();
InitDirectX();
ScreenChanged?.Invoke(this, CurrentScreenBounds);
}
void OnScreenChanget()
{
if (ScreenChanged != null)
{
ScreenChanged.Invoke(this, EventArgs.Empty);
}
}
public void Init()
{
CaptureFullscreen = true;
InitBitBlt();
InitDirectX();
ScreenChanged?.Invoke(this, CurrentScreenBounds);
}
public void Init()
{
CurrentFrame = new Bitmap(CurrentScreenBounds.Width, CurrentScreenBounds.Height, PixelFormat.Format32bppArgb);
PreviousFrame = new Bitmap(CurrentScreenBounds.Width, CurrentScreenBounds.Height, PixelFormat.Format32bppArgb);
InitBitBlt();
InitDirectX();
ScreenChanged?.Invoke(this, CurrentScreenBounds);
}
/// <summary>
/// Constucts and assigns the basic data
/// </summary>
/// <param name="graphicsDevice"></param>
/// <param name="colorMap"></param>
/// <param name="fonts"></param>
/// <param name="screenChanged"></param>
public SettingsScreen( GraphicsDevice graphicsDevice, ColorMap colorMap, List<SpriteFont> fonts, ScreenChanged screenChanged )
{
// subscribe to the delegate invocation list
_screenChanged += screenChanged;
// assign references to the local instance refs
_graphicsDevice = graphicsDevice;
_colorMap = colorMap;
_fonts = fonts;
}
/// <summary>
/// Creates the achievements screen and assigns the basic data
/// </summary>
/// <param name="graphicsDevice"></param>
/// <param name="colorMap"></param>
/// <param name="fonts"></param>
/// <param name="screenChanged"></param>
public TopScoresScreen( GraphicsDevice graphicsDevice, ColorMap colorMap, List<SpriteFont> fonts, ScreenChanged screenChanged )
{
// subscribe the delegate
_screenChanged += screenChanged;
// assign the refs to the local instances
_graphicsDevice = graphicsDevice;
_colorMap = colorMap;
_fonts = fonts;
}
public void Init()
{
Win32Interop.SwitchToInputDesktop();
CaptureFullscreen = true;
InitBitBlt();
InitDirectX();
ScreenChanged?.Invoke(this, CurrentScreenBounds);
}
public void SetNewState(Screen screen)
{
if (CurrentScreen == screen)
{
return;
}
PreviousScreen = CurrentScreen;
CurrentScreen = screen;
ScreenChanged?.Invoke(this, new ScreenChangedArgs(PreviousScreen, CurrentScreen));
}
public void Init()
{
Dispose();
factory = new Factory1();
//Get first adapter
adapter = factory.Adapters1.FirstOrDefault(x => x.Outputs.Length > 0);
//Get device from adapter
device = new SharpDX.Direct3D11.Device(adapter);
//Get front buffer of the adapter
if (adapter.GetOutputCount() < SelectedScreen + 1)
{
SelectedScreen = 0;
}
output = adapter.GetOutput(SelectedScreen);
output1 = output.QueryInterface <Output1>();
// Width/Height of desktop to capture
var bounds = output1.Description.DesktopBounds;
var newWidth = bounds.Right - bounds.Left;
var newHeight = bounds.Bottom - bounds.Top;
CurrentScreenBounds = new Rectangle(bounds.Left, bounds.Top, newWidth, newHeight);
if (newWidth != width || newHeight != height)
{
ScreenChanged?.Invoke(this, CurrentScreenBounds);
}
width = newWidth;
height = newHeight;
CurrentFrame = new Bitmap(width, height, PixelFormat.Format32bppArgb);
PreviousFrame = new Bitmap(width, height, PixelFormat.Format32bppArgb);
// Create Staging texture CPU-accessible
textureDesc = new Texture2DDescription
{
CpuAccessFlags = CpuAccessFlags.Read,
BindFlags = BindFlags.None,
Format = Format.B8G8R8A8_UNorm,
Width = width,
Height = height,
OptionFlags = ResourceOptionFlags.None,
MipLevels = 1,
ArraySize = 1,
SampleDescription = { Count = 1, Quality = 0 },
Usage = ResourceUsage.Staging
};
screenTexture = new Texture2D(device, textureDesc);
duplicatedOutput = output1.DuplicateOutput(device);
NeedsInit = false;
}
private void updateScreen()
{
Screen screen = Screen.FromHandle(Handle);
if ((this.screen == null) || !this.screen.Equals(screen))
{
this.screen = screen;
if (this.screen != null)
{
ScreenChanged?.Invoke(this, EventArgs.Empty);
}
}
}
/// <summary>
/// Instantiates the game screen and sets up the base values
/// </summary>
/// <param name="graphicsDevice"></param>
/// <param name="colorMap"></param>
/// <param name="fonts"></param>
/// <param name="screenChanged"></param>
public GameScreen( GraphicsDevice graphicsDevice, ColorMap colorMap, List<SpriteFont> fonts, ScreenChanged screenChanged )
{
// subscribe to the screen change delegate
_screenChanged += screenChanged;
// assign the local refs
_graphicsDevice = graphicsDevice;
_colorMap = colorMap;
_fonts = fonts;
// create the track
Track = new ColorPlateTrack( _graphicsDevice, colorMap, _fonts[ 0 ], Difficulty.Pro /*alter to populate from settings*/ );
}
/// <summary>
/// Creates the main screen and assigns the provided instances to local refs
/// </summary>
/// <param name="graphicsDevice"></param>
/// <param name="colorMap"></param>
/// <param name="fonts"></param>
/// <param name="method"></param>
public MainScreen( GraphicsDevice graphicsDevice, ColorMap colorMap, List<SpriteFont> fonts, ScreenChanged method )
{
// subscribe to the delegate invocation list
_screenChanged += method;
// assign refs to the local instances
_graphicsDevice = graphicsDevice;
_fonts = fonts;
_colorMap = colorMap;
// create a new track for the main screen with the top difficulty
_track = new ColorPlateTrack( graphicsDevice, colorMap, _fonts[ 0 ], Difficulty.Asian );
}
/// <summary>
/// Initialize the window
/// </summary>
public AdminWindow()
{
DataContext = this;
InitializeComponent();
kinect = Kinect.getInstance();
kinect.BitMapReady += Kinect_BitMapArrived;
kinect.SensorStatusChanged += Kinect_SensorStatusChanged;
kinect.BodyPositionsChanged += Kinect_BodyPositionsChanged;
// Monitor selection
var i = 0;
foreach (var screen in System.Windows.Forms.Screen.AllScreens)
{
MenuItem item = new MenuItem();
item.Header = String.Format("Display {0} ({1}x{2})", ++i, screen.WorkingArea.Width, screen.WorkingArea.Height);
item.Tag = screen;
item.Click += (s, e) => {
foreach (MenuItem mi in windowMenu.Items)
{
mi.IsChecked = false;
}
((MenuItem)s).IsChecked = true;
SetScreen((System.Windows.Forms.Screen)((MenuItem)s).Tag);
};
// Set the default to the first non-primary display
if (PrimaryMonitor == null)
{
if (!DefaultToPrimaryScreen && !screen.Primary || DefaultToPrimaryScreen && screen.Primary)
{
PrimaryMonitor = screen;
}
}
item.IsChecked = (screen == PrimaryMonitor);
windowMenu.Items.Add(item);
}
// Insure we get a window
if (PrimaryMonitor == null)
{
PrimaryMonitor = System.Windows.Forms.Screen.PrimaryScreen;
}
// Realign
ScreenChanged?.Invoke();
}
/// <summary>
/// Use this when you made changes to the virtual console
/// </summary>
public void Flush()
{
if (mObjectToLockFlush == null)
{
mObjectToLockFlush = new object();
}
lock (mObjectToLockFlush)
{
DrawUIElements();
string ThreadSafeShit = VirtualConsole;
CurrentStateOfTheScreen = new ScreenChangedArgs(ThreadSafeShit, mBodyString);
ScreenChanged?.Invoke(this, CurrentStateOfTheScreen);
Clear();
}
}
public void ChangeToScreen(bool alternate)
{
if (alternate)
{
currentBuffer = altScreenBuffer;
foreach (var line in currentBuffer.Lines)
{
line.DeleteCharacters(0, line.Length);
}
}
else
{
currentBuffer = screenBuffer;
}
ScreenChanged?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Change to the screen name listed. The screenName should be an item in the AvailableScreens.
/// </summary>
public void ChangeToScreen(string screenName)
{
//The InvokeMethod will run it right away if this is the correct thread.
InvokeMethod((object nothing) =>
{
if (!AvailableScreens.ContainsKey(screenName))
{
throw new Exception(string.Format("{0} does not exist!", screenName));
}
CurrentScreen.Unload();
CurrentScreen = AvailableScreens[screenName];
CurrentScreen.Load();
ScreenChanged?.Invoke(this, EventArgs.Empty);
}, null);
}
public void SetSelectedScreen(int screenNumber)
{
if (screenNumber == SelectedScreen)
{
return;
}
if (GetScreenCount() >= screenNumber + 1)
{
SelectedScreen = screenNumber;
}
else
{
SelectedScreen = 0;
}
CurrentScreenBounds = Screen.AllScreens[SelectedScreen].Bounds;
CaptureFullscreen = true;
Init();
ScreenChanged?.Invoke(this, CurrentScreenBounds);
}
/// <summary>
/// Change to the screen name listed. The screenName should be an item in the AvailableScreens.
/// </summary>
public void ChangeToScreen(string screenName)
{
//The lambda expression keeps the name in scope
//so no worried there, i hope...
//The InvokeMethod will run it right away if this is the correct thread.
System.Action <object> id = (object nothing) =>
{
if (!AvailableScreens.ContainsKey(screenName))
{
throw new Exception(string.Format("{0} does not exist!", screenName));
}
if (ScreenLoaded())
{
CurrentScreen.Unload();
}
CurrentScreen = AvailableScreens[screenName];
CurrentScreen.Load();
ScreenChanged?.Invoke(this, EventArgs.Empty);
};
InvokeMethod(id, null);
}
public virtual void Display()
{
if (userControl == null)
{
throw new InvalidOperationException("No screen to display");
}
userControl.Location = freeSpacePoint;
if (!window.Controls.Contains(userControl))
{
window.Controls.Add(userControl);
}
else
{
userControl.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right;
userControl.Show();
}
ScreenChanged?.Invoke(this);
}
public void ApplyResolutionSettings(bool fullScreen = false)
{
if (fullScreen)
{
Screen = new Point(GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width, GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height);
graphics.PreferredBackBufferWidth = screen.X;
graphics.PreferredBackBufferHeight = screen.Y;
Window.Position = Point.Zero;
}
else
{
Screen = PreferedWindowSize;
graphics.PreferredBackBufferWidth = preferredWindowSize.X;
graphics.PreferredBackBufferHeight = preferredWindowSize.Y;
Point windowPosition = new Point();
windowPosition.X = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Width / 2 - preferredWindowSize.X / 2;
windowPosition.Y = GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Height / 2 - preferredWindowSize.Y / 2;
Window.Position = windowPosition;
}
Window.IsBorderless = fullScreen;
Viewport viewport = new Viewport();
viewport.Width = Screen.X;
viewport.Height = Screen.Y;
GraphicsDevice.Viewport = viewport;
graphics.ApplyChanges();
ScreenChanged?.Invoke(this, null);
}
protected virtual void OnScreenChanged(ScreenChangedEventArgs e)
{
ScreenChanged?.Invoke(this, e);
}
protected void OnScreenChanged(int startY, int endY)
{
ScreenChanged?.Invoke(this, new ScreenChangedEventArgs(startY, endY));
}
private void RaiseScreenChanged(NavigationItems screen)
{
ScreenChanged?.Invoke(this, new ScreenChangedEventArgs(screen));
}
/// <summary>
/// Change the active screen
/// </summary>
/// <param name="s"></param>
private void SetScreen(System.Windows.Forms.Screen s)
{
PrimaryMonitor = s;
ScreenChanged?.Invoke();
}
//called when a screen event needs to be generated (e.g. change screen layout)
protected virtual void OnScreen(EventData eventData)
{
ScreenChanged?.Invoke(eventData);
}
