DarthAffe/Artemis
1
0
Fork 0
mirror of https://github.com/Artemis-RGB/Artemis synced 2025-12-13 05:48:35 +00:00
Code Issues Releases Wiki Activity

Revert "Unified line endings"

Browse Source 
This reverts commit bca680f1357556b2f499e37c6c69df90571f9b38.
This commit is contained in:
SpoinkyNL 2016-03-27 15:07:19 +02:00
parent 958c98dad5
commit 303133fcef
91 changed files with 6296 additions and 6296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

118
Artemis/Artemis/App.xaml.cs
View File

@ -1,60 +1,60 @@
using System; using System;
using System.Windows; using System.Windows;
using System.Windows.Threading; using System.Windows.Threading;
using Artemis.Utilities; using Artemis.Utilities;
using WpfExceptionViewer; using WpfExceptionViewer;
namespace Artemis namespace Artemis
{ {
/// <summary> /// <summary>
/// Interaction logic for App.xaml /// Interaction logic for App.xaml
/// </summary> /// </summary>
public partial class App : Application public partial class App : Application
{ {
public App() public App()
{ {
if (!GeneralHelpers.IsRunAsAdministrator()) if (!GeneralHelpers.IsRunAsAdministrator())
GeneralHelpers.RunAsAdministrator(); GeneralHelpers.RunAsAdministrator();
InitializeComponent(); InitializeComponent();
} }
public bool DoHandle { get; set; } public bool DoHandle { get; set; }
private void Application_Startup(object sender, StartupEventArgs e) private void Application_Startup(object sender, StartupEventArgs e)
{ {
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException; AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
} }
private void Application_DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e) private void Application_DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
{ {
if (DoHandle) if (DoHandle)
{ {
GetArtemisExceptionViewer(e.Exception).ShowDialog(); GetArtemisExceptionViewer(e.Exception).ShowDialog();
e.Handled = true; e.Handled = true;
} }
else else
{ {
GetArtemisExceptionViewer(e.Exception).ShowDialog(); GetArtemisExceptionViewer(e.Exception).ShowDialog();
e.Handled = false; e.Handled = false;
} }
} }
private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e) private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{ {
var ex = e.ExceptionObject as Exception; var ex = e.ExceptionObject as Exception;
GetArtemisExceptionViewer(ex).ShowDialog(); GetArtemisExceptionViewer(ex).ShowDialog();
} }
private static ExceptionViewer GetArtemisExceptionViewer(Exception e) private static ExceptionViewer GetArtemisExceptionViewer(Exception e)
{ {
return new ExceptionViewer("An unexpected error occurred in Artemis.", e) return new ExceptionViewer("An unexpected error occurred in Artemis.", e)
{ {
Title = "Artemis - Exception :c", Title = "Artemis - Exception :c",
Height = 400, Height = 400,
Width = 800 Width = 800
}; };
} }
} }
} }

100
Artemis/Artemis/ArtemisBootstrapper.cs
View File

@ -1,51 +1,51 @@
using System.Diagnostics; using System.Diagnostics;
using System.Linq; using System.Linq;
using System.Windows; using System.Windows;
using System.Windows.Forms; using System.Windows.Forms;
using Artemis.Utilities; using Artemis.Utilities;
using Artemis.Utilities.LogitechDll; using Artemis.Utilities.LogitechDll;
using Artemis.ViewModels; using Artemis.ViewModels;
using Autofac; using Autofac;
using Caliburn.Micro; using Caliburn.Micro;
using Caliburn.Micro.Autofac; using Caliburn.Micro.Autofac;
using Application = System.Windows.Application; using Application = System.Windows.Application;
using MessageBox = System.Windows.Forms.MessageBox; using MessageBox = System.Windows.Forms.MessageBox;
namespace Artemis namespace Artemis
{ {
public class ArtemisBootstrapper : AutofacBootstrapper<SystemTrayViewModel> public class ArtemisBootstrapper : AutofacBootstrapper<SystemTrayViewModel>
{ {
public ArtemisBootstrapper() public ArtemisBootstrapper()
{ {
CheckDuplicateInstances(); CheckDuplicateInstances();
Initialize(); Initialize();
} }
protected override void ConfigureContainer(ContainerBuilder builder) protected override void ConfigureContainer(ContainerBuilder builder)
{ {
base.ConfigureContainer(builder); base.ConfigureContainer(builder);
// create a window manager instance to be used by everyone asking for one (including Caliburn.Micro) // create a window manager instance to be used by everyone asking for one (including Caliburn.Micro)
builder.RegisterInstance<IWindowManager>(new WindowManager()); builder.RegisterInstance<IWindowManager>(new WindowManager());
builder.RegisterType<SystemTrayViewModel>(); builder.RegisterType<SystemTrayViewModel>();
builder.RegisterType<ShellViewModel>(); builder.RegisterType<ShellViewModel>();
} }
protected override void OnStartup(object sender, StartupEventArgs e) protected override void OnStartup(object sender, StartupEventArgs e)
{ {
DisplayRootViewFor<SystemTrayViewModel>(); DisplayRootViewFor<SystemTrayViewModel>();
} }
private void CheckDuplicateInstances() private void CheckDuplicateInstances()
{ {
var processes = Process.GetProcesses(); var processes = Process.GetProcesses();
if (processes.Count(p => p.ProcessName == "Artemis") < 2) if (processes.Count(p => p.ProcessName == "Artemis") < 2)
return; return;
MessageBox.Show("An instance of Artemis is already running (check your system tray).", MessageBox.Show("An instance of Artemis is already running (check your system tray).",
"Artemis (╯°□°）╯︵ ┻━┻", MessageBoxButtons.OK, MessageBoxIcon.Warning); "Artemis (╯°□°）╯︵ ┻━┻", MessageBoxButtons.OK, MessageBoxIcon.Warning);
Application.Current.Shutdown(); Application.Current.Shutdown();
} }
} }
} }

22
Artemis/Artemis/Events/ActiveEffectChanged.cs
View File

@ -1,12 +1,12 @@
namespace Artemis.Events namespace Artemis.Events
{ {
public class ActiveEffectChanged public class ActiveEffectChanged
{ {
public ActiveEffectChanged(string activeEffect) public ActiveEffectChanged(string activeEffect)
{ {
ActiveEffect = activeEffect; ActiveEffect = activeEffect;
} }
public string ActiveEffect { get; set; } public string ActiveEffect { get; set; }
} }
} }

36
Artemis/Artemis/Events/ChangeBitmap.cs
View File

@ -1,19 +1,19 @@
using System.Drawing; using System.Drawing;
namespace Artemis.Events namespace Artemis.Events
{ {
public class ChangeBitmap public class ChangeBitmap
{ {
public ChangeBitmap(Bitmap bitmap) public ChangeBitmap(Bitmap bitmap)
{ {
Bitmap = bitmap; Bitmap = bitmap;
} }
public Bitmap Bitmap { get; private set; } public Bitmap Bitmap { get; private set; }
public void ChangeTextMessage(Bitmap bitmap) public void ChangeTextMessage(Bitmap bitmap)
{ {
Bitmap = bitmap; Bitmap = bitmap;
} }
} }
} }

22
Artemis/Artemis/Events/ToggleEnabled.cs
View File

@ -1,12 +1,12 @@
namespace Artemis.Events namespace Artemis.Events
{ {
public class ToggleEnabled public class ToggleEnabled
{ {
public ToggleEnabled(bool enabled) public ToggleEnabled(bool enabled)
{ {
Enabled = enabled; Enabled = enabled;
} }
public bool Enabled { get; set; } public bool Enabled { get; set; }
} }
} }

62
Artemis/Artemis/KeyboardProviders/KeyboardProvider.cs
View File

@ -1,32 +1,32 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Drawing; using System.Drawing;
namespace Artemis.KeyboardProviders namespace Artemis.KeyboardProviders
{ {
public abstract class KeyboardProvider public abstract class KeyboardProvider
{ {
public string Name { get; set; } public string Name { get; set; }
public int Height { get; set; } public int Height { get; set; }
public int Width { get; set; } public int Width { get; set; }
public string CantEnableText { get; set; } public string CantEnableText { get; set; }
public List<KeyboardRegion> KeyboardRegions { get; set; } public List<KeyboardRegion> KeyboardRegions { get; set; }
public abstract bool CanEnable(); public abstract bool CanEnable();
public abstract void Enable(); public abstract void Enable();
public abstract void Disable(); public abstract void Disable();
public abstract void DrawBitmap(Bitmap bitmap); public abstract void DrawBitmap(Bitmap bitmap);
/// <summary> /// <summary>
/// Returns a bitmap matching the keyboard's dimensions /// Returns a bitmap matching the keyboard's dimensions
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
public Bitmap KeyboardBitmap() => new Bitmap(Width, Height); public Bitmap KeyboardBitmap() => new Bitmap(Width, Height);
/// <summary> /// <summary>
/// Returns a bitmap matching the keyboard's dimensions using the provided scale /// Returns a bitmap matching the keyboard's dimensions using the provided scale
/// </summary> /// </summary>
/// <returns></returns> /// <returns></returns>
public Bitmap KeyboardBitmap(int scale) => new Bitmap(Width*scale, Height*scale); public Bitmap KeyboardBitmap(int scale) => new Bitmap(Width*scale, Height*scale);
} }
} }

38
Artemis/Artemis/KeyboardProviders/KeyboardRegion.cs
View File

@ -1,20 +1,20 @@
using System.Drawing; using System.Drawing;
namespace Artemis.KeyboardProviders namespace Artemis.KeyboardProviders
{ {
public class KeyboardRegion public class KeyboardRegion
{ {
public KeyboardRegion(string regionName, Point topLeft, Point bottomRight) public KeyboardRegion(string regionName, Point topLeft, Point bottomRight)
{ {
RegionName = regionName; RegionName = regionName;
TopLeft = topLeft; TopLeft = topLeft;
BottomRight = bottomRight; BottomRight = bottomRight;
} }
public string RegionName { get; set; } public string RegionName { get; set; }
public Point TopLeft { get; set; } public Point TopLeft { get; set; }
public Point BottomRight { get; set; } public Point BottomRight { get; set; }
public Rectangle GetRectangle() => new Rectangle(TopLeft.X, TopLeft.Y, BottomRight.X - TopLeft.X, BottomRight.Y - TopLeft.Y); public Rectangle GetRectangle() => new Rectangle(TopLeft.X, TopLeft.Y, BottomRight.X - TopLeft.X, BottomRight.Y - TopLeft.Y);
} }
} }

272
Artemis/Artemis/KeyboardProviders/Logitech/Utilities/KeyMap.cs
View File

@ -1,137 +1,137 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Windows.Forms; using System.Windows.Forms;
using Artemis.Utilities.Keyboard; using Artemis.Utilities.Keyboard;
namespace Artemis.KeyboardProviders.Logitech.Utilities namespace Artemis.KeyboardProviders.Logitech.Utilities
{ {
public static class KeyMap public static class KeyMap
{ {
static KeyMap() static KeyMap()
{ {
// There are several keyboard layouts // There are several keyboard layouts
// TODO: Implemented more layouts and an option to select them // TODO: Implemented more layouts and an option to select them
UsEnglishOrionKeys = new List<Key> UsEnglishOrionKeys = new List<Key>
{ {
// Row 1 // Row 1
new Key(Keys.Escape, 0, 0), new Key(Keys.Escape, 0, 0),
new Key(Keys.F1, 1, 0), new Key(Keys.F1, 1, 0),
new Key(Keys.F2, 2, 0), new Key(Keys.F2, 2, 0),
new Key(Keys.F3, 3, 0), new Key(Keys.F3, 3, 0),
new Key(Keys.F4, 4, 0), new Key(Keys.F4, 4, 0),
new Key(Keys.F5, 5, 0), new Key(Keys.F5, 5, 0),
new Key(Keys.F6, 6, 0), new Key(Keys.F6, 6, 0),
new Key(Keys.F7, 7, 0), new Key(Keys.F7, 7, 0),
new Key(Keys.F8, 8, 0), new Key(Keys.F8, 8, 0),
new Key(Keys.F9, 9, 0), new Key(Keys.F9, 9, 0),
new Key(Keys.F10, 10, 0), new Key(Keys.F10, 10, 0),
new Key(Keys.F11, 11, 0), new Key(Keys.F11, 11, 0),
new Key(Keys.F12, 12, 0), new Key(Keys.F12, 12, 0),
new Key(Keys.PrintScreen, 13, 0), new Key(Keys.PrintScreen, 13, 0),
new Key(Keys.Scroll, 14, 0), new Key(Keys.Scroll, 14, 0),
new Key(Keys.Pause, 15, 0), new Key(Keys.Pause, 15, 0),
// Row 2 // Row 2
new Key(Keys.Oemtilde, 0, 1), new Key(Keys.Oemtilde, 0, 1),
new Key(Keys.D1, 1, 1), new Key(Keys.D1, 1, 1),
new Key(Keys.D2, 2, 1), new Key(Keys.D2, 2, 1),
new Key(Keys.D3, 3, 1), new Key(Keys.D3, 3, 1),
new Key(Keys.D4, 4, 1), new Key(Keys.D4, 4, 1),
new Key(Keys.D5, 5, 1), new Key(Keys.D5, 5, 1),
new Key(Keys.D6, 6, 1), new Key(Keys.D6, 6, 1),
new Key(Keys.D7, 7, 1), new Key(Keys.D7, 7, 1),
new Key(Keys.D8, 8, 1), new Key(Keys.D8, 8, 1),
new Key(Keys.D9, 9, 1), new Key(Keys.D9, 9, 1),
new Key(Keys.D0, 10, 1), new Key(Keys.D0, 10, 1),
new Key(Keys.OemMinus, 11, 1), new Key(Keys.OemMinus, 11, 1),
new Key(Keys.Oemplus, 12, 1), new Key(Keys.Oemplus, 12, 1),
new Key(Keys.Back, 13, 1), new Key(Keys.Back, 13, 1),
new Key(Keys.Insert, 14, 1), new Key(Keys.Insert, 14, 1),
new Key(Keys.Home, 15, 1), new Key(Keys.Home, 15, 1),
new Key(Keys.PageUp, 16, 1), new Key(Keys.PageUp, 16, 1),
new Key(Keys.NumLock, 17, 1), new Key(Keys.NumLock, 17, 1),
new Key(Keys.Divide, 18, 1), new Key(Keys.Divide, 18, 1),
new Key(Keys.Multiply, 19, 1), new Key(Keys.Multiply, 19, 1),
new Key(Keys.Subtract, 20, 1), new Key(Keys.Subtract, 20, 1),
// Row 3 // Row 3
new Key(Keys.Tab, 0, 2), new Key(Keys.Tab, 0, 2),
new Key(Keys.Q, 1, 2), new Key(Keys.Q, 1, 2),
new Key(Keys.W, 2, 2), new Key(Keys.W, 2, 2),
new Key(Keys.E, 3, 2), new Key(Keys.E, 3, 2),
new Key(Keys.R, 4, 2), new Key(Keys.R, 4, 2),
new Key(Keys.T, 5, 2), new Key(Keys.T, 5, 2),
new Key(Keys.Y, 6, 2), new Key(Keys.Y, 6, 2),
new Key(Keys.U, 7, 2), new Key(Keys.U, 7, 2),
new Key(Keys.I, 8, 2), new Key(Keys.I, 8, 2),
new Key(Keys.O, 9, 2), new Key(Keys.O, 9, 2),
new Key(Keys.P, 10, 2), new Key(Keys.P, 10, 2),
new Key(Keys.OemOpenBrackets, 11, 2), new Key(Keys.OemOpenBrackets, 11, 2),
new Key(Keys.Oem6, 12, 2), new Key(Keys.Oem6, 12, 2),
new Key(Keys.Delete, 14, 2), new Key(Keys.Delete, 14, 2),
new Key(Keys.End, 15, 2), new Key(Keys.End, 15, 2),
new Key(Keys.Next, 16, 2), new Key(Keys.Next, 16, 2),
new Key(Keys.NumPad7, 17, 2), new Key(Keys.NumPad7, 17, 2),
new Key(Keys.NumPad8, 18, 2), new Key(Keys.NumPad8, 18, 2),
new Key(Keys.NumPad9, 19, 2), new Key(Keys.NumPad9, 19, 2),
new Key(Keys.Add, 20, 2), new Key(Keys.Add, 20, 2),
// Row 4 // Row 4
new Key(Keys.Capital, 0, 3), new Key(Keys.Capital, 0, 3),
new Key(Keys.A, 1, 3), new Key(Keys.A, 1, 3),
new Key(Keys.S, 2, 3), new Key(Keys.S, 2, 3),
new Key(Keys.D, 3, 3), new Key(Keys.D, 3, 3),
new Key(Keys.F, 4, 3), new Key(Keys.F, 4, 3),
new Key(Keys.G, 5, 3), new Key(Keys.G, 5, 3),
new Key(Keys.H, 6, 3), new Key(Keys.H, 6, 3),
new Key(Keys.J, 7, 3), new Key(Keys.J, 7, 3),
new Key(Keys.K, 8, 3), new Key(Keys.K, 8, 3),
new Key(Keys.L, 9, 3), new Key(Keys.L, 9, 3),
new Key(Keys.Oem1, 10, 3), new Key(Keys.Oem1, 10, 3),
new Key(Keys.Oem7, 11, 3), new Key(Keys.Oem7, 11, 3),
new Key(Keys.Oem5, 12, 3), new Key(Keys.Oem5, 12, 3),
new Key(Keys.Return, 13, 3), new Key(Keys.Return, 13, 3),
new Key(Keys.NumPad4, 17, 3), new Key(Keys.NumPad4, 17, 3),
new Key(Keys.NumPad5, 18, 3), new Key(Keys.NumPad5, 18, 3),
new Key(Keys.NumPad6, 19, 3), new Key(Keys.NumPad6, 19, 3),
// Row 5 // Row 5
new Key(Keys.LShiftKey, 1, 4), new Key(Keys.LShiftKey, 1, 4),
new Key(Keys.OemBackslash, 2, 4), new Key(Keys.OemBackslash, 2, 4),
new Key(Keys.Z, 2, 4), new Key(Keys.Z, 2, 4),
new Key(Keys.X, 3, 4), new Key(Keys.X, 3, 4),
new Key(Keys.C, 4, 4), new Key(Keys.C, 4, 4),
new Key(Keys.V, 5, 4), new Key(Keys.V, 5, 4),
new Key(Keys.B, 6, 4), new Key(Keys.B, 6, 4),
new Key(Keys.N, 7, 4), new Key(Keys.N, 7, 4),
new Key(Keys.M, 8, 4), new Key(Keys.M, 8, 4),
new Key(Keys.Oemcomma, 9, 4), new Key(Keys.Oemcomma, 9, 4),
new Key(Keys.OemPeriod, 10, 4), new Key(Keys.OemPeriod, 10, 4),
new Key(Keys.OemQuestion, 11, 4), new Key(Keys.OemQuestion, 11, 4),
new Key(Keys.RShiftKey, 13, 4), new Key(Keys.RShiftKey, 13, 4),
new Key(Keys.Up, 15, 4), new Key(Keys.Up, 15, 4),
new Key(Keys.NumPad1, 17, 4), new Key(Keys.NumPad1, 17, 4),
new Key(Keys.NumPad2, 18, 4), new Key(Keys.NumPad2, 18, 4),
new Key(Keys.NumPad3, 19, 4), new Key(Keys.NumPad3, 19, 4),
// Both returns return "Return" (Yes...) // Both returns return "Return" (Yes...)
// new OrionKey(System.Windows.Forms.Keys.Return, 20, 4), // new OrionKey(System.Windows.Forms.Keys.Return, 20, 4),
// Row 6 // Row 6
new Key(Keys.LControlKey, 0, 5), new Key(Keys.LControlKey, 0, 5),
new Key(Keys.LWin, 1, 5), new Key(Keys.LWin, 1, 5),
new Key(Keys.LMenu, 2, 5), new Key(Keys.LMenu, 2, 5),
new Key(Keys.Space, 5, 5), new Key(Keys.Space, 5, 5),
new Key(Keys.RMenu, 11, 5), new Key(Keys.RMenu, 11, 5),
new Key(Keys.RWin, 12, 5), new Key(Keys.RWin, 12, 5),
new Key(Keys.Apps, 13, 5), new Key(Keys.Apps, 13, 5),
new Key(Keys.RControlKey, 14, 5), new Key(Keys.RControlKey, 14, 5),
new Key(Keys.Left, 15, 5), new Key(Keys.Left, 15, 5),
new Key(Keys.Down, 16, 5), new Key(Keys.Down, 16, 5),
new Key(Keys.Right, 17, 5), new Key(Keys.Right, 17, 5),
new Key(Keys.NumPad0, 18, 5), new Key(Keys.NumPad0, 18, 5),
new Key(Keys.Decimal, 19, 5) new Key(Keys.Decimal, 19, 5)
}; };
} }
public static List<Key> UsEnglishOrionKeys { get; set; } public static List<Key> UsEnglishOrionKeys { get; set; }
} }
} }

220
Artemis/Artemis/KeyboardProviders/Logitech/Utilities/KeyboardNames.cs
View File

@ -1,111 +1,111 @@
namespace Artemis.KeyboardProviders.Logitech.Utilities namespace Artemis.KeyboardProviders.Logitech.Utilities
{ {
public enum KeyboardNames public enum KeyboardNames
{ {
ESC = 0x01, ESC = 0x01,
F1 = 0x3b, F1 = 0x3b,
F2 = 0x3c, F2 = 0x3c,
F3 = 0x3d, F3 = 0x3d,
F4 = 0x3e, F4 = 0x3e,
F5 = 0x3f, F5 = 0x3f,
F6 = 0x40, F6 = 0x40,
F7 = 0x41, F7 = 0x41,
F8 = 0x42, F8 = 0x42,
F9 = 0x43, F9 = 0x43,
F10 = 0x44, F10 = 0x44,
F11 = 0x57, F11 = 0x57,
F12 = 0x58, F12 = 0x58,
PRINT_SCREEN = 0x137, PRINT_SCREEN = 0x137,
SCROLL_LOCK = 0x46, SCROLL_LOCK = 0x46,
PAUSE_BREAK = 0x45, PAUSE_BREAK = 0x45,
TILDE = 0x29, TILDE = 0x29,
ONE = 0x02, ONE = 0x02,
TWO = 0x03, TWO = 0x03,
THREE = 0x04, THREE = 0x04,
FOUR = 0x05, FOUR = 0x05,
FIVE = 0x06, FIVE = 0x06,
SIX = 0x07, SIX = 0x07,
SEVEN = 0x08, SEVEN = 0x08,
EIGHT = 0x09, EIGHT = 0x09,
NINE = 0x0A, NINE = 0x0A,
ZERO = 0x0B, ZERO = 0x0B,
MINUS = 0x0C, MINUS = 0x0C,
EQUALS = 0x0D, EQUALS = 0x0D,
BACKSPACE = 0x0E, BACKSPACE = 0x0E,
INSERT = 0x152, INSERT = 0x152,
HOME = 0x147, HOME = 0x147,
PAGE_UP = 0x149, PAGE_UP = 0x149,
NUM_LOCK = 0x145, NUM_LOCK = 0x145,
NUM_SLASH = 0x135, NUM_SLASH = 0x135,
NUM_ASTERISK = 0x37, NUM_ASTERISK = 0x37,
NUM_MINUS = 0x4A, NUM_MINUS = 0x4A,
TAB = 0x0F, TAB = 0x0F,
Q = 0x10, Q = 0x10,
W = 0x11, W = 0x11,
E = 0x12, E = 0x12,
R = 0x13, R = 0x13,
T = 0x14, T = 0x14,
Y = 0x15, Y = 0x15,
U = 0x16, U = 0x16,
I = 0x17, I = 0x17,
O = 0x18, O = 0x18,
P = 0x19, P = 0x19,
OPEN_BRACKET = 0x1A, OPEN_BRACKET = 0x1A,
CLOSE_BRACKET = 0x1B, CLOSE_BRACKET = 0x1B,
BACKSLASH = 0x2B, BACKSLASH = 0x2B,
KEYBOARD_DELETE = 0x153, KEYBOARD_DELETE = 0x153,
END = 0x14F, END = 0x14F,
PAGE_DOWN = 0x151, PAGE_DOWN = 0x151,
NUM_SEVEN = 0x47, NUM_SEVEN = 0x47,
NUM_EIGHT = 0x48, NUM_EIGHT = 0x48,
NUM_NINE = 0x49, NUM_NINE = 0x49,
NUM_PLUS = 0x4E, NUM_PLUS = 0x4E,
CAPS_LOCK = 0x3A, CAPS_LOCK = 0x3A,
A = 0x1E, A = 0x1E,
S = 0x1F, S = 0x1F,
D = 0x20, D = 0x20,
F = 0x21, F = 0x21,
G = 0x22, G = 0x22,
H = 0x23, H = 0x23,
J = 0x24, J = 0x24,
K = 0x25, K = 0x25,
L = 0x26, L = 0x26,
SEMICOLON = 0x27, SEMICOLON = 0x27,
APOSTROPHE = 0x28, APOSTROPHE = 0x28,
ENTER = 0x1C, ENTER = 0x1C,
NUM_FOUR = 0x4B, NUM_FOUR = 0x4B,
NUM_FIVE = 0x4C, NUM_FIVE = 0x4C,
NUM_SIX = 0x4D, NUM_SIX = 0x4D,
LEFT_SHIFT = 0x2A, LEFT_SHIFT = 0x2A,
Z = 0x2C, Z = 0x2C,
X = 0x2D, X = 0x2D,
C = 0x2E, C = 0x2E,
V = 0x2F, V = 0x2F,
B = 0x30, B = 0x30,
N = 0x31, N = 0x31,
M = 0x32, M = 0x32,
COMMA = 0x33, COMMA = 0x33,
PERIOD = 0x34, PERIOD = 0x34,
FORWARD_SLASH = 0x35, FORWARD_SLASH = 0x35,
RIGHT_SHIFT = 0x36, RIGHT_SHIFT = 0x36,
ARROW_UP = 0x148, ARROW_UP = 0x148,
NUM_ONE = 0x4F, NUM_ONE = 0x4F,
NUM_TWO = 0x50, NUM_TWO = 0x50,
NUM_THREE = 0x51, NUM_THREE = 0x51,
NUM_ENTER = 0x11C, NUM_ENTER = 0x11C,
LEFT_CONTROL = 0x1D, LEFT_CONTROL = 0x1D,
LEFT_WINDOWS = 0x15B, LEFT_WINDOWS = 0x15B,
LEFT_ALT = 0x38, LEFT_ALT = 0x38,
SPACE = 0x39, SPACE = 0x39,
RIGHT_ALT = 0x138, RIGHT_ALT = 0x138,
RIGHT_WINDOWS = 0x15C, RIGHT_WINDOWS = 0x15C,
APPLICATION_SELECT = 0x15D, APPLICATION_SELECT = 0x15D,
RIGHT_CONTROL = 0x11D, RIGHT_CONTROL = 0x11D,
ARROW_LEFT = 0x14B, ARROW_LEFT = 0x14B,
ARROW_DOWN = 0x150, ARROW_DOWN = 0x150,
ARROW_RIGHT = 0x14D, ARROW_RIGHT = 0x14D,
NUM_ZERO = 0x52, NUM_ZERO = 0x52,
NUM_PERIOD = 0x53, NUM_PERIOD = 0x53,
TEST = 0x1 TEST = 0x1
} }
} }

188
Artemis/Artemis/KeyboardProviders/Logitech/Utilities/LogitechGSDK.cs
View File

@ -1,95 +1,95 @@
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
// ReSharper disable InconsistentNaming // ReSharper disable InconsistentNaming
namespace Artemis.KeyboardProviders.Logitech.Utilities namespace Artemis.KeyboardProviders.Logitech.Utilities
{ {
public class LogitechGSDK public class LogitechGSDK
{ {
//LED SDK //LED SDK
private const int LOGI_DEVICETYPE_MONOCHROME_ORD = 0; private const int LOGI_DEVICETYPE_MONOCHROME_ORD = 0;
private const int LOGI_DEVICETYPE_RGB_ORD = 1; private const int LOGI_DEVICETYPE_RGB_ORD = 1;
private const int LOGI_DEVICETYPE_PERKEY_RGB_ORD = 2; private const int LOGI_DEVICETYPE_PERKEY_RGB_ORD = 2;
public const int LOGI_DEVICETYPE_MONOCHROME = 1 << LOGI_DEVICETYPE_MONOCHROME_ORD; public const int LOGI_DEVICETYPE_MONOCHROME = 1 << LOGI_DEVICETYPE_MONOCHROME_ORD;
public const int LOGI_DEVICETYPE_RGB = 1 << LOGI_DEVICETYPE_RGB_ORD; public const int LOGI_DEVICETYPE_RGB = 1 << LOGI_DEVICETYPE_RGB_ORD;
public const int LOGI_DEVICETYPE_PERKEY_RGB = 1 << LOGI_DEVICETYPE_PERKEY_RGB_ORD; public const int LOGI_DEVICETYPE_PERKEY_RGB = 1 << LOGI_DEVICETYPE_PERKEY_RGB_ORD;
public const int LOGI_LED_BITMAP_WIDTH = 21; public const int LOGI_LED_BITMAP_WIDTH = 21;
public const int LOGI_LED_BITMAP_HEIGHT = 6; public const int LOGI_LED_BITMAP_HEIGHT = 6;
public const int LOGI_LED_BITMAP_BYTES_PER_KEY = 4; public const int LOGI_LED_BITMAP_BYTES_PER_KEY = 4;
public const int LOGI_LED_BITMAP_SIZE = public const int LOGI_LED_BITMAP_SIZE =
LOGI_LED_BITMAP_WIDTH*LOGI_LED_BITMAP_HEIGHT*LOGI_LED_BITMAP_BYTES_PER_KEY; LOGI_LED_BITMAP_WIDTH*LOGI_LED_BITMAP_HEIGHT*LOGI_LED_BITMAP_BYTES_PER_KEY;
public const int LOGI_LED_DURATION_INFINITE = 0; public const int LOGI_LED_DURATION_INFINITE = 0;
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedInit(); public static extern bool LogiLedInit();
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedSetTargetDevice(int targetDevice); public static extern bool LogiLedSetTargetDevice(int targetDevice);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedGetSdkVersion(ref int majorNum, ref int minorNum, ref int buildNum); public static extern bool LogiLedGetSdkVersion(ref int majorNum, ref int minorNum, ref int buildNum);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedSaveCurrentLighting(); public static extern bool LogiLedSaveCurrentLighting();
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedSetLighting(int redPercentage, int greenPercentage, int bluePercentage); public static extern bool LogiLedSetLighting(int redPercentage, int greenPercentage, int bluePercentage);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedRestoreLighting(); public static extern bool LogiLedRestoreLighting();
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedFlashLighting(int redPercentage, int greenPercentage, int bluePercentage, public static extern bool LogiLedFlashLighting(int redPercentage, int greenPercentage, int bluePercentage,
int milliSecondsDuration, int milliSecondsInterval); int milliSecondsDuration, int milliSecondsInterval);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedPulseLighting(int redPercentage, int greenPercentage, int bluePercentage, public static extern bool LogiLedPulseLighting(int redPercentage, int greenPercentage, int bluePercentage,
int milliSecondsDuration, int milliSecondsInterval); int milliSecondsDuration, int milliSecondsInterval);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedStopEffects(); public static extern bool LogiLedStopEffects();
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedSetLightingFromBitmap(byte[] bitmap); public static extern bool LogiLedSetLightingFromBitmap(byte[] bitmap);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedSetLightingForKeyWithScanCode(int keyCode, int redPercentage, public static extern bool LogiLedSetLightingForKeyWithScanCode(int keyCode, int redPercentage,
int greenPercentage, int bluePercentage); int greenPercentage, int bluePercentage);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedSetLightingForKeyWithHidCode(int keyCode, int redPercentage, public static extern bool LogiLedSetLightingForKeyWithHidCode(int keyCode, int redPercentage,
int greenPercentage, int bluePercentage); int greenPercentage, int bluePercentage);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedSetLightingForKeyWithQuartzCode(int keyCode, int redPercentage, public static extern bool LogiLedSetLightingForKeyWithQuartzCode(int keyCode, int redPercentage,
int greenPercentage, int bluePercentage); int greenPercentage, int bluePercentage);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedSetLightingForKeyWithKeyName(int keyCode, int redPercentage, public static extern bool LogiLedSetLightingForKeyWithKeyName(int keyCode, int redPercentage,
int greenPercentage, int bluePercentage); int greenPercentage, int bluePercentage);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedSaveLightingForKey(KeyboardNames keyName); public static extern bool LogiLedSaveLightingForKey(KeyboardNames keyName);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedRestoreLightingForKey(KeyboardNames keyName); public static extern bool LogiLedRestoreLightingForKey(KeyboardNames keyName);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedFlashSingleKey(KeyboardNames keyName, int redPercentage, int greenPercentage, public static extern bool LogiLedFlashSingleKey(KeyboardNames keyName, int redPercentage, int greenPercentage,
int bluePercentage, int msDuration, int msInterval); int bluePercentage, int msDuration, int msInterval);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedPulseSingleKey(KeyboardNames keyName, int startRedPercentage, public static extern bool LogiLedPulseSingleKey(KeyboardNames keyName, int startRedPercentage,
int startGreenPercentage, int startBluePercentage, int finishRedPercentage, int finishGreenPercentage, int startGreenPercentage, int startBluePercentage, int finishRedPercentage, int finishGreenPercentage,
int finishBluePercentage, int msDuration, bool isInfinite); int finishBluePercentage, int msDuration, bool isInfinite);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LogiLedStopEffectsOnKey(KeyboardNames keyName); public static extern bool LogiLedStopEffectsOnKey(KeyboardNames keyName);
[DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)] [DllImport("LogitechLedEnginesWrapper ", CallingConvention = CallingConvention.Cdecl)]
public static extern void LogiLedShutdown(); public static extern void LogiLedShutdown();
} }
} }

444
Artemis/Artemis/KeyboardProviders/Logitech/Utilities/OrionUtilities.cs
View File

@ -1,230 +1,230 @@
using System.Drawing; using System.Drawing;
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using System.Drawing.Imaging; using System.Drawing.Imaging;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
namespace Artemis.KeyboardProviders.Logitech.Utilities namespace Artemis.KeyboardProviders.Logitech.Utilities
{ {
public static class OrionUtilities public static class OrionUtilities
{ {
public static KeyMapping[] Keymappings = public static KeyMapping[] Keymappings =
{ {
// First row // First row
new KeyMapping(0, 0), new KeyMapping(0, 0),
new KeyMapping(1, 1), new KeyMapping(1, 1),
new KeyMapping(2, 1), new KeyMapping(2, 1),
new KeyMapping(3, 2), new KeyMapping(3, 2),
new KeyMapping(4, 3), new KeyMapping(4, 3),
new KeyMapping(5, 4), new KeyMapping(5, 4),
new KeyMapping(6, 5), new KeyMapping(6, 5),
new KeyMapping(7, 6), new KeyMapping(7, 6),
new KeyMapping(8, 7), new KeyMapping(8, 7),
new KeyMapping(9, 8), new KeyMapping(9, 8),
new KeyMapping(10, 9), new KeyMapping(10, 9),
new KeyMapping(11, 9), new KeyMapping(11, 9),
new KeyMapping(12, 10), new KeyMapping(12, 10),
new KeyMapping(13, 11), new KeyMapping(13, 11),
new KeyMapping(13, 12), new KeyMapping(13, 12),
new KeyMapping(14, 13), new KeyMapping(14, 13),
new KeyMapping(15, 14), new KeyMapping(15, 14),
new KeyMapping(16, 15), new KeyMapping(16, 15),
new KeyMapping(17, 16), new KeyMapping(17, 16),
new KeyMapping(18, 17), new KeyMapping(18, 17),
new KeyMapping(19, 18), new KeyMapping(19, 18),
// Second row // Second row
new KeyMapping(21, 21), new KeyMapping(21, 21),
new KeyMapping(22, 22), new KeyMapping(22, 22),
new KeyMapping(23, 23), new KeyMapping(23, 23),
new KeyMapping(24, 24), new KeyMapping(24, 24),
new KeyMapping(25, 25), new KeyMapping(25, 25),
new KeyMapping(26, 26), new KeyMapping(26, 26),
new KeyMapping(27, 27), new KeyMapping(27, 27),
new KeyMapping(28, 28), new KeyMapping(28, 28),
new KeyMapping(29, 29), new KeyMapping(29, 29),
new KeyMapping(30, 30), new KeyMapping(30, 30),
new KeyMapping(31, 31), new KeyMapping(31, 31),
new KeyMapping(32, 32), new KeyMapping(32, 32),
new KeyMapping(33, 33), new KeyMapping(33, 33),
new KeyMapping(34, 34), new KeyMapping(34, 34),
new KeyMapping(35, 35), new KeyMapping(35, 35),
new KeyMapping(36, 36), new KeyMapping(36, 36),
new KeyMapping(37, 37), new KeyMapping(37, 37),
new KeyMapping(38, 38), new KeyMapping(38, 38),
new KeyMapping(39, 39), new KeyMapping(39, 39),
new KeyMapping(40, 40), new KeyMapping(40, 40),
new KeyMapping(41, 41), new KeyMapping(41, 41),
// Third row // Third row
new KeyMapping(42, 42), new KeyMapping(42, 42),
new KeyMapping(43, 43), new KeyMapping(43, 43),
new KeyMapping(44, 44), new KeyMapping(44, 44),
new KeyMapping(45, 45), new KeyMapping(45, 45),
new KeyMapping(46, 46), new KeyMapping(46, 46),
new KeyMapping(47, 46), new KeyMapping(47, 46),
new KeyMapping(48, 47), new KeyMapping(48, 47),
new KeyMapping(49, 48), new KeyMapping(49, 48),
new KeyMapping(50, 49), new KeyMapping(50, 49),
new KeyMapping(51, 50), new KeyMapping(51, 50),
new KeyMapping(52, 51), new KeyMapping(52, 51),
new KeyMapping(53, 52), new KeyMapping(53, 52),
new KeyMapping(54, 53), new KeyMapping(54, 53),
new KeyMapping(54, 54), new KeyMapping(54, 54),
new KeyMapping(55, 55), new KeyMapping(55, 55),
new KeyMapping(56, 56), new KeyMapping(56, 56),
new KeyMapping(57, 57), new KeyMapping(57, 57),
new KeyMapping(58, 58), new KeyMapping(58, 58),
new KeyMapping(59, 59), new KeyMapping(59, 59),
new KeyMapping(60, 60), new KeyMapping(60, 60),
new KeyMapping(61, 61), new KeyMapping(61, 61),
new KeyMapping(62, 62), new KeyMapping(62, 62),
// Fourth row // Fourth row
new KeyMapping(63, 63), new KeyMapping(63, 63),
new KeyMapping(64, 64), new KeyMapping(64, 64),
new KeyMapping(65, 65), new KeyMapping(65, 65),
new KeyMapping(66, 65), new KeyMapping(66, 65),
new KeyMapping(67, 66), new KeyMapping(67, 66),
new KeyMapping(68, 67), new KeyMapping(68, 67),
new KeyMapping(69, 68), new KeyMapping(69, 68),
new KeyMapping(70, 69), new KeyMapping(70, 69),
new KeyMapping(71, 70), new KeyMapping(71, 70),
new KeyMapping(72, 71), new KeyMapping(72, 71),
new KeyMapping(73, 72), new KeyMapping(73, 72),
new KeyMapping(74, 73), new KeyMapping(74, 73),
new KeyMapping(75, 74), new KeyMapping(75, 74),
new KeyMapping(76, 75), new KeyMapping(76, 75),
new KeyMapping(76, 76), new KeyMapping(76, 76),
new KeyMapping(78, 77), new KeyMapping(78, 77),
new KeyMapping(79, 78), new KeyMapping(79, 78),
new KeyMapping(79, 79), new KeyMapping(79, 79),
new KeyMapping(80, 80), new KeyMapping(80, 80),
new KeyMapping(81, 81), new KeyMapping(81, 81),
new KeyMapping(82, 82), new KeyMapping(82, 82),
// Fifth row // Fifth row
new KeyMapping(84, 84), new KeyMapping(84, 84),
new KeyMapping(85, 85), new KeyMapping(85, 85),
new KeyMapping(86, 86), new KeyMapping(86, 86),
new KeyMapping(87, 87), new KeyMapping(87, 87),
new KeyMapping(88, 88), new KeyMapping(88, 88),
new KeyMapping(89, 89), new KeyMapping(89, 89),
new KeyMapping(90, 90), new KeyMapping(90, 90),
new KeyMapping(91, 91), new KeyMapping(91, 91),
new KeyMapping(92, 92), new KeyMapping(92, 92),
new KeyMapping(93, 93), new KeyMapping(93, 93),
new KeyMapping(94, 94), new KeyMapping(94, 94),
new KeyMapping(95, 95), new KeyMapping(95, 95),
new KeyMapping(96, 96), new KeyMapping(96, 96),
new KeyMapping(97, 97), new KeyMapping(97, 97),
new KeyMapping(98, 98), new KeyMapping(98, 98),
new KeyMapping(99, 99), new KeyMapping(99, 99),
new KeyMapping(100, 100), new KeyMapping(100, 100),
new KeyMapping(101, 101), new KeyMapping(101, 101),
new KeyMapping(102, 102), new KeyMapping(102, 102),
new KeyMapping(103, 103), new KeyMapping(103, 103),
new KeyMapping(104, 104), new KeyMapping(104, 104),
// Sixth row // Sixth row
new KeyMapping(105, 105), new KeyMapping(105, 105),
new KeyMapping(106, 106), new KeyMapping(106, 106),
new KeyMapping(107, 107), new KeyMapping(107, 107),
new KeyMapping(108, 107), new KeyMapping(108, 107),
new KeyMapping(109, 109), new KeyMapping(109, 109),
new KeyMapping(110, 110), new KeyMapping(110, 110),
new KeyMapping(111, 110), new KeyMapping(111, 110),
new KeyMapping(112, 111), new KeyMapping(112, 111),
new KeyMapping(113, 112), new KeyMapping(113, 112),
new KeyMapping(114, 113), new KeyMapping(114, 113),
new KeyMapping(115, 114), new KeyMapping(115, 114),
new KeyMapping(116, 115), new KeyMapping(116, 115),
new KeyMapping(115, 116), // ALTGR new KeyMapping(115, 116), // ALTGR
new KeyMapping(116, 117), new KeyMapping(116, 117),
new KeyMapping(117, 118), new KeyMapping(117, 118),
new KeyMapping(118, 119), new KeyMapping(118, 119),
new KeyMapping(119, 120), new KeyMapping(119, 120),
new KeyMapping(120, 121), new KeyMapping(120, 121),
new KeyMapping(121, 122), new KeyMapping(121, 122),
new KeyMapping(122, 123), new KeyMapping(122, 123),
new KeyMapping(124, 124), new KeyMapping(124, 124),
}; };
public static byte[] BitmapToByteArray(Bitmap b, bool remap = true) public static byte[] BitmapToByteArray(Bitmap b, bool remap = true)
{ {
if (b.Width > 21 || b.Height > 6) if (b.Width > 21 || b.Height > 6)
b = ResizeImage(b, 21, 6); b = ResizeImage(b, 21, 6);
var rect = new Rectangle(0, 0, b.Width, b.Height); var rect = new Rectangle(0, 0, b.Width, b.Height);
var bitmapData = b.LockBits(rect, ImageLockMode.ReadWrite, b.PixelFormat); var bitmapData = b.LockBits(rect, ImageLockMode.ReadWrite, b.PixelFormat);
var depth = Image.GetPixelFormatSize(b.PixelFormat); var depth = Image.GetPixelFormatSize(b.PixelFormat);
var step = depth/8; var step = depth/8;
var pixels = new byte[21*6*step]; var pixels = new byte[21*6*step];
var iptr = bitmapData.Scan0; var iptr = bitmapData.Scan0;
// Copy data from pointer to array // Copy data from pointer to array
Marshal.Copy(iptr, pixels, 0, pixels.Length); Marshal.Copy(iptr, pixels, 0, pixels.Length);
if (!remap) if (!remap)
return pixels; return pixels;
var remapped = new byte[pixels.Length]; var remapped = new byte[pixels.Length];
// Every key is 4 bytes // Every key is 4 bytes
for (var i = 0; i <= pixels.Length /4; i++) for (var i = 0; i <= pixels.Length /4; i++)
{ {
var firstSByte = Keymappings[i].Source * 4; var firstSByte = Keymappings[i].Source * 4;
var firstTByte = Keymappings[i].Target * 4; var firstTByte = Keymappings[i].Target * 4;
for (var j = 0; j < 4; j++) for (var j = 0; j < 4; j++)
remapped[firstTByte + j] = pixels[firstSByte + j]; remapped[firstTByte + j] = pixels[firstSByte + j];
} }
return remapped; return remapped;
} }
/// <summary> /// <summary>
/// Resize the image to the specified width and height. /// Resize the image to the specified width and height.
/// </summary> /// </summary>
/// <param name="image">The image to resize.</param> /// <param name="image">The image to resize.</param>
/// <param name="width">The width to resize to.</param> /// <param name="width">The width to resize to.</param>
/// <param name="height">The height to resize to.</param> /// <param name="height">The height to resize to.</param>
/// <returns>The resized image.</returns> /// <returns>The resized image.</returns>
public static Bitmap ResizeImage(Image image, int width, int height) public static Bitmap ResizeImage(Image image, int width, int height)
{ {
var destRect = new Rectangle(0, 0, width, height); var destRect = new Rectangle(0, 0, width, height);
var destImage = new Bitmap(width, height); var destImage = new Bitmap(width, height);
destImage.SetResolution(image.HorizontalResolution, image.VerticalResolution); destImage.SetResolution(image.HorizontalResolution, image.VerticalResolution);
using (var graphics = Graphics.FromImage(destImage)) using (var graphics = Graphics.FromImage(destImage))
{ {
graphics.CompositingMode = CompositingMode.SourceCopy; graphics.CompositingMode = CompositingMode.SourceCopy;
graphics.CompositingQuality = CompositingQuality.HighQuality; graphics.CompositingQuality = CompositingQuality.HighQuality;
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic; graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphics.SmoothingMode = SmoothingMode.HighQuality; graphics.SmoothingMode = SmoothingMode.HighQuality;
graphics.PixelOffsetMode = PixelOffsetMode.HighQuality; graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
using (var wrapMode = new ImageAttributes()) using (var wrapMode = new ImageAttributes())
{ {
wrapMode.SetWrapMode(WrapMode.TileFlipXY); wrapMode.SetWrapMode(WrapMode.TileFlipXY);
graphics.DrawImage(image, destRect, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, wrapMode); graphics.DrawImage(image, destRect, 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, wrapMode);
} }
} }
return destImage; return destImage;
} }
public struct KeyMapping public struct KeyMapping
{ {
public KeyMapping(int source, int target) public KeyMapping(int source, int target)
{ {
Source = source; Source = source;
Target = target; Target = target;
} }
public int Source { get; set; } public int Source { get; set; }
public int Target { get; set; } public int Target { get; set; }
} }
} }
} }

38
Artemis/Artemis/KeyboardProviders/ProviderHelper.cs
View File

@ -1,20 +1,20 @@
using System.Collections.Generic; using System.Collections.Generic;
using Artemis.KeyboardProviders.Corsair; using Artemis.KeyboardProviders.Corsair;
using Artemis.KeyboardProviders.Logitech; using Artemis.KeyboardProviders.Logitech;
using Artemis.KeyboardProviders.Razer; using Artemis.KeyboardProviders.Razer;
namespace Artemis.KeyboardProviders namespace Artemis.KeyboardProviders
{ {
public static class ProviderHelper public static class ProviderHelper
{ {
public static List<KeyboardProvider> GetKeyboardProviders() public static List<KeyboardProvider> GetKeyboardProviders()
{ {
return new List<KeyboardProvider> return new List<KeyboardProvider>
{ {
new CorsairRGB(), new CorsairRGB(),
new Orion(), new Orion(),
new BlackWidow() new BlackWidow()
}; };
} }
} }
} }

102
Artemis/Artemis/KeyboardProviders/Razer/BlackWidow.cs
View File

@ -1,55 +1,55 @@
using System; using System;
using System.Drawing; using System.Drawing;
using Artemis.KeyboardProviders.Razer.Utilities; using Artemis.KeyboardProviders.Razer.Utilities;
using Corale.Colore.Core; using Corale.Colore.Core;
using Corale.Colore.Razer.Keyboard; using Corale.Colore.Razer.Keyboard;
using ColoreColor = Corale.Colore.Core.Color; using ColoreColor = Corale.Colore.Core.Color;
using KeyboardCustom = Corale.Colore.Razer.Keyboard.Effects.Custom; using KeyboardCustom = Corale.Colore.Razer.Keyboard.Effects.Custom;
namespace Artemis.KeyboardProviders.Razer namespace Artemis.KeyboardProviders.Razer
{ {
public class BlackWidow : KeyboardProvider public class BlackWidow : KeyboardProvider
{ {
public BlackWidow() public BlackWidow()
{ {
Name = "Razer BlackWidow Chroma"; Name = "Razer BlackWidow Chroma";
CantEnableText = "Couldn't connect to your Razer BlackWidow Chroma.\n " + CantEnableText = "Couldn't connect to your Razer BlackWidow Chroma.\n " +
"Please check your cables and try updating Razer Synapse.\n\n " + "Please check your cables and try updating Razer Synapse.\n\n " +
"If needed, you can select a different keyboard in Artemis under settings."; "If needed, you can select a different keyboard in Artemis under settings.";
} }
public override bool CanEnable() public override bool CanEnable()
{ {
if (!Chroma.IsSdkAvailable()) if (!Chroma.IsSdkAvailable())
return false; return false;
// Some people have Synapse installed, but not a Chroma keyboard, deal with this // Some people have Synapse installed, but not a Chroma keyboard, deal with this
var blackWidowFound = Chroma.Instance.Query(Corale.Colore.Razer.Devices.Blackwidow).Connected; var blackWidowFound = Chroma.Instance.Query(Corale.Colore.Razer.Devices.Blackwidow).Connected;
var blackWidowTeFound = Chroma.Instance.Query(Corale.Colore.Razer.Devices.BlackwidowTe).Connected; var blackWidowTeFound = Chroma.Instance.Query(Corale.Colore.Razer.Devices.BlackwidowTe).Connected;
return (blackWidowFound || blackWidowTeFound); return (blackWidowFound || blackWidowTeFound);
} }
public override void Enable() public override void Enable()
{ {
Chroma.Instance.Initialize(); Chroma.Instance.Initialize();
Height = Constants.MaxRows; Height = Constants.MaxRows;
Width = Constants.MaxColumns; Width = Constants.MaxColumns;
KeyboardRegions.Add(new KeyboardRegion("TopRow", new Point(0, 0), new Point(19, 0))); KeyboardRegions.Add(new KeyboardRegion("TopRow", new Point(0, 0), new Point(19, 0)));
KeyboardRegions.Add(new KeyboardRegion("NumPad", new Point(20, 1), new Point(23, 6))); KeyboardRegions.Add(new KeyboardRegion("NumPad", new Point(20, 1), new Point(23, 6)));
KeyboardRegions.Add(new KeyboardRegion("QWER", new Point(2, 2), new Point(5, 2))); KeyboardRegions.Add(new KeyboardRegion("QWER", new Point(2, 2), new Point(5, 2)));
} }
public override void Disable() public override void Disable()
{ {
Chroma.Instance.Uninitialize(); Chroma.Instance.Uninitialize();
} }
public override void DrawBitmap(Bitmap bitmap) public override void DrawBitmap(Bitmap bitmap)
{ {
var razerArray = RazerUtilities.BitmapColorArray(bitmap, Height, Width); var razerArray = RazerUtilities.BitmapColorArray(bitmap, Height, Width);
Chroma.Instance.Keyboard.SetCustom(razerArray); Chroma.Instance.Keyboard.SetCustom(razerArray);
} }
} }
} }

46
Artemis/Artemis/KeyboardProviders/Razer/Utilities/RazerUtilities.cs
View File

@ -1,24 +1,24 @@
using System.Drawing; using System.Drawing;
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using System.Drawing.Imaging; using System.Drawing.Imaging;
using Artemis.Utilities; using Artemis.Utilities;
using Corale.Colore.Razer.Keyboard.Effects; using Corale.Colore.Razer.Keyboard.Effects;
namespace Artemis.KeyboardProviders.Razer.Utilities namespace Artemis.KeyboardProviders.Razer.Utilities
{ {
public static class RazerUtilities public static class RazerUtilities
{ {
public static Custom BitmapColorArray(Bitmap b, int height, int width) public static Custom BitmapColorArray(Bitmap b, int height, int width)
{ {
var keyboardGrid = Custom.Create(); var keyboardGrid = Custom.Create();
if (b.Width > width || b.Height > height) if (b.Width > width || b.Height > height)
b = ImageUtilities.ResizeImage(b, width, height); b = ImageUtilities.ResizeImage(b, width, height);
for (var y = 0; y < b.Height; y++) for (var y = 0; y < b.Height; y++)
for (var x = 0; x < b.Width; x++) for (var x = 0; x < b.Width; x++)
keyboardGrid[y, x] = b.GetPixel(x, y); keyboardGrid[y, x] = b.GetPixel(x, y);
return keyboardGrid; return keyboardGrid;
} }
} }
} }

38
Artemis/Artemis/Models/EffectSettings.cs
View File

@ -1,20 +1,20 @@
namespace Artemis.Models namespace Artemis.Models
{ {
public abstract class EffectSettings public abstract class EffectSettings
{ {
/// <summary> /// <summary>
/// Loads the settings from the settings file /// Loads the settings from the settings file
/// </summary> /// </summary>
public abstract void Load(); public abstract void Load();
/// <summary> /// <summary>
/// Saves the settings to the settings file /// Saves the settings to the settings file
/// </summary> /// </summary>
public abstract void Save(); public abstract void Save();
/// <summary> /// <summary>
/// Returns the settings to their default value /// Returns the settings to their default value
/// </summary> /// </summary>
public abstract void ToDefault(); public abstract void ToDefault();
} }
} }

26
Artemis/Artemis/Models/GameModel.cs
View File

@ -1,14 +1,14 @@
using Artemis.Managers; using Artemis.Managers;
namespace Artemis.Models namespace Artemis.Models
{ {
public abstract class GameModel : EffectModel public abstract class GameModel : EffectModel
{ {
public bool Enabled; public bool Enabled;
public string ProcessName; public string ProcessName;
protected GameModel(MainManager mainManager) : base(mainManager) protected GameModel(MainManager mainManager) : base(mainManager)
{ {
} }
} }
} }

90
Artemis/Artemis/Models/OverlayModel.cs
View File

@ -1,46 +1,46 @@
using System.Drawing; using System.Drawing;
using Artemis.Managers; using Artemis.Managers;
namespace Artemis.Models namespace Artemis.Models
{ {
public abstract class OverlayModel : EffectModel public abstract class OverlayModel : EffectModel
{ {
private bool _enabled; private bool _enabled;
public string ProcessName; public string ProcessName;
protected OverlayModel(MainManager mainManager) : base(mainManager) protected OverlayModel(MainManager mainManager) : base(mainManager)
{ {
} }
public bool Enabled public bool Enabled
{ {
get { return _enabled; } get { return _enabled; }
set set
{ {
if (_enabled == value) if (_enabled == value)
return; return;
if (value) if (value)
Enable(); Enable();
else else
Dispose(); Dispose();
_enabled = value; _enabled = value;
} }
} }
public void SetEnabled(bool enabled) public void SetEnabled(bool enabled)
{ {
if (Enabled == enabled) if (Enabled == enabled)
return; return;
if (enabled) if (enabled)
Enable(); Enable();
else else
Dispose(); Dispose();
Enabled = enabled; Enabled = enabled;
} }
public abstract Bitmap GenerateBitmap(Bitmap bitmap); public abstract Bitmap GenerateBitmap(Bitmap bitmap);
} }
} }

72
Artemis/Artemis/Modules/Effects/AmbientLightning/AmbientLightningEffectSettings.cs
View File

@ -1,37 +1,37 @@
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using Artemis.Models; using Artemis.Models;
namespace Artemis.Modules.Effects.AmbientLightning namespace Artemis.Modules.Effects.AmbientLightning
{ {
internal class AmbientLightningEffectSettings : EffectSettings internal class AmbientLightningEffectSettings : EffectSettings
{ {
public AmbientLightningEffectSettings() public AmbientLightningEffectSettings()
{ {
Load(); Load();
} }
public int Width { get; set; } public int Width { get; set; }
public int Height { get; set; } public int Height { get; set; }
public bool Rotate { get; set; } public bool Rotate { get; set; }
public int Scale { get; set; } public int Scale { get; set; }
public LinearGradientMode Type { get; set; } public LinearGradientMode Type { get; set; }
public sealed override void Load() public sealed override void Load()
{ {
ToDefault(); ToDefault();
} }
public sealed override void Save() public sealed override void Save()
{ {
} }
public sealed override void ToDefault() public sealed override void ToDefault()
{ {
Width = 84; Width = 84;
Height = 24; Height = 24;
Scale = 4; Scale = 4;
Type = LinearGradientMode.Horizontal; Type = LinearGradientMode.Horizontal;
Rotate = true; Rotate = true;
} }
} }
} }

62
Artemis/Artemis/Modules/Effects/AmbientLightning/AmbientLightningEffectViewModel.cs
View File

@ -1,32 +1,32 @@
using Artemis.Events; using Artemis.Events;
using Artemis.Managers; using Artemis.Managers;
using Artemis.ViewModels.Abstract; using Artemis.ViewModels.Abstract;
using Caliburn.Micro; using Caliburn.Micro;
namespace Artemis.Modules.Effects.AmbientLightning namespace Artemis.Modules.Effects.AmbientLightning
{ {
internal class AmbientLightningEffectViewModel : EffectViewModel, IHandle<ActiveEffectChanged> internal class AmbientLightningEffectViewModel : EffectViewModel, IHandle<ActiveEffectChanged>
{ {
public AmbientLightningEffectViewModel(MainManager mainManager) public AmbientLightningEffectViewModel(MainManager mainManager)
{ {
// Subscribe to main model // Subscribe to main model
MainManager = mainManager; MainManager = mainManager;
MainManager.Events.Subscribe(this); MainManager.Events.Subscribe(this);
// Settings are loaded from file by class // Settings are loaded from file by class
EffectSettings = new AmbientLightningEffectSettings(); EffectSettings = new AmbientLightningEffectSettings();
// Create effect model and add it to MainManager // Create effect model and add it to MainManager
EffectModel = new AmbientLightningEffectModel(mainManager, (AmbientLightningEffectSettings) EffectSettings); EffectModel = new AmbientLightningEffectModel(mainManager, (AmbientLightningEffectSettings) EffectSettings);
MainManager.EffectManager.EffectModels.Add(EffectModel); MainManager.EffectManager.EffectModels.Add(EffectModel);
} }
public static string Name => "Ambient Lightning"; public static string Name => "Ambient Lightning";
public void Handle(ActiveEffectChanged message) public void Handle(ActiveEffectChanged message)
{ {
NotifyOfPropertyChange(() => EffectEnabled); NotifyOfPropertyChange(() => EffectEnabled);
} }
} }
} }

220
Artemis/Artemis/Modules/Effects/AudioVisualizer/AudioVisualization.Designer.cs generated
View File

@ -1,110 +1,110 @@
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// <auto-generated> // <auto-generated>
// This code was generated by a tool. // This code was generated by a tool.
// Runtime Version:4.0.30319.42000 // Runtime Version:4.0.30319.42000
// //
// Changes to this file may cause incorrect behavior and will be lost if // Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated. // the code is regenerated.
// </auto-generated> // </auto-generated>
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
namespace Artemis.Modules.Effects.AudioVisualizer { namespace Artemis.Modules.Effects.AudioVisualizer {
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "14.0.0.0")] [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "14.0.0.0")]
internal sealed partial class AudioVisualization : global::System.Configuration.ApplicationSettingsBase { internal sealed partial class AudioVisualization : global::System.Configuration.ApplicationSettingsBase {
private static AudioVisualization defaultInstance = ((AudioVisualization)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new AudioVisualization()))); private static AudioVisualization defaultInstance = ((AudioVisualization)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new AudioVisualization())));
public static AudioVisualization Default { public static AudioVisualization Default {
get { get {
return defaultInstance; return defaultInstance;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("4")] [global::System.Configuration.DefaultSettingValueAttribute("4")]
public int Sensitivity { public int Sensitivity {
get { get {
return ((int)(this["Sensitivity"])); return ((int)(this["Sensitivity"]));
} }
set { set {
this["Sensitivity"] = value; this["Sensitivity"] = value;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("21")] [global::System.Configuration.DefaultSettingValueAttribute("21")]
public int Bars { public int Bars {
get { get {
return ((int)(this["Bars"])); return ((int)(this["Bars"]));
} }
set { set {
this["Bars"] = value; this["Bars"] = value;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("True")] [global::System.Configuration.DefaultSettingValueAttribute("True")]
public bool FromBottom { public bool FromBottom {
get { get {
return ((bool)(this["FromBottom"])); return ((bool)(this["FromBottom"]));
} }
set { set {
this["FromBottom"] = value; this["FromBottom"] = value;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("3")] [global::System.Configuration.DefaultSettingValueAttribute("3")]
public int FadeSpeed { public int FadeSpeed {
get { get {
return ((int)(this["FadeSpeed"])); return ((int)(this["FadeSpeed"]));
} }
set { set {
this["FadeSpeed"] = value; this["FadeSpeed"] = value;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("#FFF90000")] [global::System.Configuration.DefaultSettingValueAttribute("#FFF90000")]
public global::System.Windows.Media.Color TopColor { public global::System.Windows.Media.Color TopColor {
get { get {
return ((global::System.Windows.Media.Color)(this["TopColor"])); return ((global::System.Windows.Media.Color)(this["TopColor"]));
} }
set { set {
this["TopColor"] = value; this["TopColor"] = value;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("#FFFF761E")] [global::System.Configuration.DefaultSettingValueAttribute("#FFFF761E")]
public global::System.Windows.Media.Color MiddleColor { public global::System.Windows.Media.Color MiddleColor {
get { get {
return ((global::System.Windows.Media.Color)(this["MiddleColor"])); return ((global::System.Windows.Media.Color)(this["MiddleColor"]));
} }
set { set {
this["MiddleColor"] = value; this["MiddleColor"] = value;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("#FF00DF00")] [global::System.Configuration.DefaultSettingValueAttribute("#FF00DF00")]
public global::System.Windows.Media.Color BottomColor { public global::System.Windows.Media.Color BottomColor {
get { get {
return ((global::System.Windows.Media.Color)(this["BottomColor"])); return ((global::System.Windows.Media.Color)(this["BottomColor"]));
} }
set { set {
this["BottomColor"] = value; this["BottomColor"] = value;
} }
} }
} }
} }

404
Artemis/Artemis/Modules/Effects/AudioVisualizer/AudioVisualizerModel.cs
View File

@ -1,203 +1,203 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Drawing; using System.Drawing;
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using System.Linq; using System.Linq;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Models; using Artemis.Models;
using Artemis.Modules.Effects.AudioVisualizer.Utilities; using Artemis.Modules.Effects.AudioVisualizer.Utilities;
using Artemis.Utilities; using Artemis.Utilities;
using Artemis.Utilities.Keyboard; using Artemis.Utilities.Keyboard;
using NAudio.CoreAudioApi; using NAudio.CoreAudioApi;
using NAudio.Wave; using NAudio.Wave;
namespace Artemis.Modules.Effects.AudioVisualizer namespace Artemis.Modules.Effects.AudioVisualizer
{ {
public class AudioVisualizerModel : EffectModel public class AudioVisualizerModel : EffectModel
{ {
private const int FftLength = 2048; private const int FftLength = 2048;
private readonly SampleAggregator _sampleAggregator = new SampleAggregator(FftLength); private readonly SampleAggregator _sampleAggregator = new SampleAggregator(FftLength);
private bool _fromBottom; private bool _fromBottom;
private bool _generating; private bool _generating;
private int _sensitivity; private int _sensitivity;
private IWaveIn _waveIn; private IWaveIn _waveIn;
public AudioVisualizerModel(MainManager mainManager, AudioVisualizerSettings settings) : base(mainManager) public AudioVisualizerModel(MainManager mainManager, AudioVisualizerSettings settings) : base(mainManager)
{ {
Settings = settings; Settings = settings;
Name = "Audiovisualizer"; Name = "Audiovisualizer";
DeviceIds = new List<string>(); DeviceIds = new List<string>();
SpectrumData = new List<byte>(); SpectrumData = new List<byte>();
Scale = 4; Scale = 4;
Initialized = false; Initialized = false;
} }
public int Lines { get; set; } public int Lines { get; set; }
public int Scale { get; set; } public int Scale { get; set; }
public AudioVisualizerSettings Settings { get; set; } public AudioVisualizerSettings Settings { get; set; }
public List<byte> SpectrumData { get; set; } public List<byte> SpectrumData { get; set; }
public List<KeyboardRectangle> SoundRectangles { get; set; } public List<KeyboardRectangle> SoundRectangles { get; set; }
public List<string> DeviceIds { get; set; } public List<string> DeviceIds { get; set; }
public string SelectedDeviceId { get; set; } public string SelectedDeviceId { get; set; }
public override void Dispose() public override void Dispose()
{ {
Initialized = false; Initialized = false;
_sampleAggregator.PerformFFT = false; _sampleAggregator.PerformFFT = false;
_sampleAggregator.FftCalculated -= FftCalculated; _sampleAggregator.FftCalculated -= FftCalculated;
_waveIn.StopRecording(); _waveIn.StopRecording();
_waveIn.DataAvailable -= OnDataAvailable; _waveIn.DataAvailable -= OnDataAvailable;
_waveIn = null; _waveIn = null;
} }
public override void Enable() public override void Enable()
{ {
Initialized = false; Initialized = false;
Lines = MainManager.KeyboardManager.ActiveKeyboard.Width; Lines = MainManager.KeyboardManager.ActiveKeyboard.Width;
// TODO: Device selection // TODO: Device selection
SelectedDeviceId = new MMDeviceEnumerator() SelectedDeviceId = new MMDeviceEnumerator()
.EnumerateAudioEndPoints(DataFlow.All, DeviceState.Active) .EnumerateAudioEndPoints(DataFlow.All, DeviceState.Active)
.FirstOrDefault()?.ID; .FirstOrDefault()?.ID;
// Apply settings // Apply settings
SoundRectangles = new List<KeyboardRectangle>(); SoundRectangles = new List<KeyboardRectangle>();
for (var i = 0; i < Lines; i++) for (var i = 0; i < Lines; i++)
{ {
SoundRectangles.Add(new KeyboardRectangle( SoundRectangles.Add(new KeyboardRectangle(
MainManager.KeyboardManager.ActiveKeyboard, MainManager.KeyboardManager.ActiveKeyboard,
0, 0, new List<Color> 0, 0, new List<Color>
{ {
ColorHelpers.ToDrawingColor(Settings.TopColor), ColorHelpers.ToDrawingColor(Settings.TopColor),
ColorHelpers.ToDrawingColor(Settings.MiddleColor), ColorHelpers.ToDrawingColor(Settings.MiddleColor),
ColorHelpers.ToDrawingColor(Settings.BottomColor) ColorHelpers.ToDrawingColor(Settings.BottomColor)
}, },
LinearGradientMode.Vertical) {ContainedBrush = false, Height = 0}); LinearGradientMode.Vertical) {ContainedBrush = false, Height = 0});
} }
_sensitivity = Settings.Sensitivity; _sensitivity = Settings.Sensitivity;
_fromBottom = Settings.FromBottom; _fromBottom = Settings.FromBottom;
_sampleAggregator.FftCalculated += FftCalculated; _sampleAggregator.FftCalculated += FftCalculated;
_sampleAggregator.PerformFFT = true; _sampleAggregator.PerformFFT = true;
// Start listening for sound data // Start listening for sound data
_waveIn = new WasapiLoopbackCapture(); _waveIn = new WasapiLoopbackCapture();
_waveIn.DataAvailable += OnDataAvailable; _waveIn.DataAvailable += OnDataAvailable;
_waveIn.StartRecording(); _waveIn.StartRecording();
Initialized = true; Initialized = true;
} }
public override void Update() public override void Update()
{ {
// TODO: Use lock instead of a bool // TODO: Use lock instead of a bool
// Start filling the model // Start filling the model
_generating = true; _generating = true;
if (SelectedDeviceId == null) if (SelectedDeviceId == null)
return; return;
var device = new MMDeviceEnumerator() var device = new MMDeviceEnumerator()
.EnumerateAudioEndPoints(DataFlow.All, DeviceState.Active) .EnumerateAudioEndPoints(DataFlow.All, DeviceState.Active)
.FirstOrDefault(d => d.ID == SelectedDeviceId); .FirstOrDefault(d => d.ID == SelectedDeviceId);
if (device == null || SpectrumData == null) if (device == null || SpectrumData == null)
return; return;
if (!SpectrumData.Any()) if (!SpectrumData.Any())
return; return;
// Parse spectrum data // Parse spectrum data
for (var i = 0; i < Lines; i++) for (var i = 0; i < Lines; i++)
{ {
int height; int height;
if (SpectrumData.Count - 1 < i || SpectrumData[i] == 0) if (SpectrumData.Count - 1 < i || SpectrumData[i] == 0)
height = 0; height = 0;
else else
height = (int) Math.Round(SpectrumData[i]/2.55); height = (int) Math.Round(SpectrumData[i]/2.55);
// Apply Sensitivity setting // Apply Sensitivity setting
height = height*_sensitivity; height = height*_sensitivity;
var keyboardHeight = var keyboardHeight =
(int) Math.Round(MainManager.KeyboardManager.ActiveKeyboard.Height/100.00*height*Scale); (int) Math.Round(MainManager.KeyboardManager.ActiveKeyboard.Height/100.00*height*Scale);
if (keyboardHeight > SoundRectangles[i].Height) if (keyboardHeight > SoundRectangles[i].Height)
SoundRectangles[i].Height = keyboardHeight; SoundRectangles[i].Height = keyboardHeight;
else else
SoundRectangles[i].Height = SoundRectangles[i].Height - Settings.FadeSpeed; SoundRectangles[i].Height = SoundRectangles[i].Height - Settings.FadeSpeed;
// Apply Bars setting // Apply Bars setting
SoundRectangles[i].X = i*Scale; SoundRectangles[i].X = i*Scale;
SoundRectangles[i].Width = Scale; SoundRectangles[i].Width = Scale;
if (_fromBottom) if (_fromBottom)
SoundRectangles[i].Y = MainManager.KeyboardManager.ActiveKeyboard.Height*Scale - SoundRectangles[i].Y = MainManager.KeyboardManager.ActiveKeyboard.Height*Scale -
SoundRectangles[i].Height; SoundRectangles[i].Height;
} }
_generating = false; _generating = false;
} }
public override Bitmap GenerateBitmap() public override Bitmap GenerateBitmap()
{ {
if (SpectrumData == null || SoundRectangles == null) if (SpectrumData == null || SoundRectangles == null)
return null; return null;
// Lock the _spectrumData array while busy with it // Lock the _spectrumData array while busy with it
_generating = true; _generating = true;
var bitmap = MainManager.KeyboardManager.ActiveKeyboard.KeyboardBitmap(Scale); var bitmap = MainManager.KeyboardManager.ActiveKeyboard.KeyboardBitmap(Scale);
using (var g = Graphics.FromImage(bitmap)) using (var g = Graphics.FromImage(bitmap))
{ {
foreach (var soundRectangle in SoundRectangles) foreach (var soundRectangle in SoundRectangles)
soundRectangle.Draw(g); soundRectangle.Draw(g);
} }
_generating = false; _generating = false;
return bitmap; return bitmap;
} }
private void OnDataAvailable(object sender, WaveInEventArgs e) private void OnDataAvailable(object sender, WaveInEventArgs e)
{ {
var buffer = e.Buffer; var buffer = e.Buffer;
var bytesRecorded = e.BytesRecorded; var bytesRecorded = e.BytesRecorded;
var bufferIncrement = _waveIn.WaveFormat.BlockAlign; var bufferIncrement = _waveIn.WaveFormat.BlockAlign;
for (var index = 0; index < bytesRecorded; index += bufferIncrement) for (var index = 0; index < bytesRecorded; index += bufferIncrement)
{ {
var sample32 = BitConverter.ToSingle(buffer, index); var sample32 = BitConverter.ToSingle(buffer, index);
_sampleAggregator.Add(sample32); _sampleAggregator.Add(sample32);
} }
} }
private void FftCalculated(object sender, FftEventArgs e) private void FftCalculated(object sender, FftEventArgs e)
{ {
if (_generating) if (_generating)
return; return;
int x; int x;
var b0 = 0; var b0 = 0;
SpectrumData.Clear(); SpectrumData.Clear();
for (x = 0; x < Lines; x++) for (x = 0; x < Lines; x++)
{ {
float peak = 0; float peak = 0;
var b1 = (int) Math.Pow(2, x*10.0/(Lines - 1)); var b1 = (int) Math.Pow(2, x*10.0/(Lines - 1));
if (b1 > 2047) if (b1 > 2047)
b1 = 2047; b1 = 2047;
if (b1 <= b0) if (b1 <= b0)
b1 = b0 + 1; b1 = b0 + 1;
for (; b0 < b1; b0++) for (; b0 < b1; b0++)
{ {
if (peak < e.Result[1 + b0].X) if (peak < e.Result[1 + b0].X)
peak = e.Result[1 + b0].X; peak = e.Result[1 + b0].X;
} }
var y = (int) (Math.Sqrt(peak)*3*255 - 4); var y = (int) (Math.Sqrt(peak)*3*255 - 4);
if (y > 255) if (y > 255)
y = 255; y = 255;
if (y < 0) if (y < 0)
y = 0; y = 0;
SpectrumData.Add((byte) y); SpectrumData.Add((byte) y);
} }
} }
} }
} }

110
Artemis/Artemis/Modules/Effects/AudioVisualizer/AudioVisualizerSettings.cs
View File

@ -1,56 +1,56 @@
using System.Windows.Media; using System.Windows.Media;
using Artemis.Models; using Artemis.Models;
namespace Artemis.Modules.Effects.AudioVisualizer namespace Artemis.Modules.Effects.AudioVisualizer
{ {
public class AudioVisualizerSettings : EffectSettings public class AudioVisualizerSettings : EffectSettings
{ {
public AudioVisualizerSettings() public AudioVisualizerSettings()
{ {
Load(); Load();
} }
public int Sensitivity { get; set; } public int Sensitivity { get; set; }
public int Bars { get; set; } public int Bars { get; set; }
public bool FromBottom { get; set; } public bool FromBottom { get; set; }
public int FadeSpeed { get; set; } public int FadeSpeed { get; set; }
public Color TopColor { get; set; } public Color TopColor { get; set; }
public Color MiddleColor { get; set; } public Color MiddleColor { get; set; }
public Color BottomColor { get; set; } public Color BottomColor { get; set; }
public sealed override void Load() public sealed override void Load()
{ {
Sensitivity = AudioVisualization.Default.Sensitivity; Sensitivity = AudioVisualization.Default.Sensitivity;
Bars = AudioVisualization.Default.Bars; Bars = AudioVisualization.Default.Bars;
FromBottom = AudioVisualization.Default.FromBottom; FromBottom = AudioVisualization.Default.FromBottom;
FadeSpeed = AudioVisualization.Default.FadeSpeed; FadeSpeed = AudioVisualization.Default.FadeSpeed;
TopColor = AudioVisualization.Default.TopColor; TopColor = AudioVisualization.Default.TopColor;
MiddleColor = AudioVisualization.Default.MiddleColor; MiddleColor = AudioVisualization.Default.MiddleColor;
BottomColor = AudioVisualization.Default.BottomColor; BottomColor = AudioVisualization.Default.BottomColor;
} }
public sealed override void Save() public sealed override void Save()
{ {
AudioVisualization.Default.Sensitivity = Sensitivity; AudioVisualization.Default.Sensitivity = Sensitivity;
AudioVisualization.Default.Bars = Bars; AudioVisualization.Default.Bars = Bars;
AudioVisualization.Default.FromBottom = FromBottom; AudioVisualization.Default.FromBottom = FromBottom;
AudioVisualization.Default.FadeSpeed = FadeSpeed; AudioVisualization.Default.FadeSpeed = FadeSpeed;
AudioVisualization.Default.TopColor = TopColor; AudioVisualization.Default.TopColor = TopColor;
AudioVisualization.Default.MiddleColor = MiddleColor; AudioVisualization.Default.MiddleColor = MiddleColor;
AudioVisualization.Default.BottomColor = BottomColor; AudioVisualization.Default.BottomColor = BottomColor;
AudioVisualization.Default.Save(); AudioVisualization.Default.Save();
} }
public sealed override void ToDefault() public sealed override void ToDefault()
{ {
Sensitivity = 4; Sensitivity = 4;
Bars = 21; Bars = 21;
FromBottom = true; FromBottom = true;
FadeSpeed = 3; FadeSpeed = 3;
TopColor = Color.FromArgb(255, 249, 0, 0); TopColor = Color.FromArgb(255, 249, 0, 0);
MiddleColor = Color.FromArgb(255, 255, 118, 30); MiddleColor = Color.FromArgb(255, 255, 118, 30);
BottomColor = Color.FromArgb(255, 0, 223, 0); BottomColor = Color.FromArgb(255, 0, 223, 0);
} }
} }
} }

28
Artemis/Artemis/Modules/Effects/AudioVisualizer/AudioVisualizerView.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Modules.Effects.AudioVisualizer namespace Artemis.Modules.Effects.AudioVisualizer
{ {
/// <summary> /// <summary>
/// Interaction logic for AudioVisualizerView.xaml /// Interaction logic for AudioVisualizerView.xaml
/// </summary> /// </summary>
public partial class AudioVisualizerView : UserControl public partial class AudioVisualizerView : UserControl
{ {
public AudioVisualizerView() public AudioVisualizerView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

60
Artemis/Artemis/Modules/Effects/AudioVisualizer/AudioVisualizerViewModel.cs
View File

@ -1,31 +1,31 @@
using Artemis.Events; using Artemis.Events;
using Artemis.Managers; using Artemis.Managers;
using Artemis.ViewModels.Abstract; using Artemis.ViewModels.Abstract;
using Caliburn.Micro; using Caliburn.Micro;
namespace Artemis.Modules.Effects.AudioVisualizer namespace Artemis.Modules.Effects.AudioVisualizer
{ {
public class AudioVisualizerViewModel : EffectViewModel, IHandle<ActiveEffectChanged> public class AudioVisualizerViewModel : EffectViewModel, IHandle<ActiveEffectChanged>
{ {
public AudioVisualizerViewModel(MainManager mainManager) public AudioVisualizerViewModel(MainManager mainManager)
{ {
// Subscribe to main model // Subscribe to main model
MainManager = mainManager; MainManager = mainManager;
MainManager.Events.Subscribe(this); MainManager.Events.Subscribe(this);
// Settings are loaded from file by class // Settings are loaded from file by class
EffectSettings = new AudioVisualizerSettings(); EffectSettings = new AudioVisualizerSettings();
// Create effect model and add it to MainManager // Create effect model and add it to MainManager
EffectModel = new AudioVisualizerModel(mainManager, (AudioVisualizerSettings) EffectSettings); EffectModel = new AudioVisualizerModel(mainManager, (AudioVisualizerSettings) EffectSettings);
MainManager.EffectManager.EffectModels.Add(EffectModel); MainManager.EffectManager.EffectModels.Add(EffectModel);
} }
public static string Name => "Audio Visualizer"; public static string Name => "Audio Visualizer";
public void Handle(ActiveEffectChanged message) public void Handle(ActiveEffectChanged message)
{ {
NotifyOfPropertyChange(() => EffectEnabled); NotifyOfPropertyChange(() => EffectEnabled);
} }
} }
} }

24
Artemis/Artemis/Modules/Effects/AudioVisualizer/Utilities/FftEventArgs.cs
View File

@ -2,16 +2,16 @@ using System;
using System.Diagnostics; using System.Diagnostics;
using NAudio.Dsp; using NAudio.Dsp;
namespace Artemis.Modules.Effects.AudioVisualizer.Utilities namespace Artemis.Modules.Effects.AudioVisualizer.Utilities
{ {
public class FftEventArgs : EventArgs public class FftEventArgs : EventArgs
{ {
[DebuggerStepThrough] [DebuggerStepThrough]
public FftEventArgs(Complex[] result) public FftEventArgs(Complex[] result)
{ {
Result = result; Result = result;
} }
public Complex[] Result { get; private set; } public Complex[] Result { get; private set; }
} }
} }

102
Artemis/Artemis/Modules/Effects/AudioVisualizer/Utilities/SampleAggregator.cs
View File

@ -1,55 +1,55 @@
using System; using System;
using NAudio.Dsp; using NAudio.Dsp;
namespace Artemis.Modules.Effects.AudioVisualizer.Utilities namespace Artemis.Modules.Effects.AudioVisualizer.Utilities
{ // The Complex and FFT are here! { // The Complex and FFT are here!
public class SampleAggregator public class SampleAggregator
{ {
private readonly FftEventArgs fftArgs; private readonly FftEventArgs fftArgs;
// This Complex is NAudio's own! // This Complex is NAudio's own!
private readonly Complex[] fftBuffer; private readonly Complex[] fftBuffer;
private readonly int fftLength; private readonly int fftLength;
private readonly int m; private readonly int m;
private int fftPos; private int fftPos;
public SampleAggregator(int fftLength) public SampleAggregator(int fftLength)
{ {
if (!IsPowerOfTwo(fftLength)) if (!IsPowerOfTwo(fftLength))
{ {
throw new ArgumentException("FFT Length must be a power of two"); throw new ArgumentException("FFT Length must be a power of two");
} }
m = (int) Math.Log(fftLength, 2.0); m = (int) Math.Log(fftLength, 2.0);
this.fftLength = fftLength; this.fftLength = fftLength;
fftBuffer = new Complex[fftLength]; fftBuffer = new Complex[fftLength];
fftArgs = new FftEventArgs(fftBuffer); fftArgs = new FftEventArgs(fftBuffer);
} }
public bool PerformFFT { get; set; } public bool PerformFFT { get; set; }
// FFT // FFT
public event EventHandler<FftEventArgs> FftCalculated; public event EventHandler<FftEventArgs> FftCalculated;
private bool IsPowerOfTwo(int x) private bool IsPowerOfTwo(int x)
{ {
return (x & (x - 1)) == 0; return (x & (x - 1)) == 0;
} }
public void Add(float value) public void Add(float value)
{ {
if (PerformFFT && FftCalculated != null) if (PerformFFT && FftCalculated != null)
{ {
// Remember the window function! There are many others as well. // Remember the window function! There are many others as well.
fftBuffer[fftPos].X = (float) (value*FastFourierTransform.HammingWindow(fftPos, fftLength)); fftBuffer[fftPos].X = (float) (value*FastFourierTransform.HammingWindow(fftPos, fftLength));
fftBuffer[fftPos].Y = 0; // This is always zero with audio. fftBuffer[fftPos].Y = 0; // This is always zero with audio.
fftPos++; fftPos++;
if (fftPos >= fftLength) if (fftPos >= fftLength)
{ {
fftPos = 0; fftPos = 0;
FastFourierTransform.FFT(true, m, fftBuffer); FastFourierTransform.FFT(true, m, fftBuffer);
FftCalculated(this, fftArgs); FftCalculated(this, fftArgs);
} }
} }
} }
} }
} }

140
Artemis/Artemis/Modules/Effects/Debug/DebugEffectModel.cs
View File

@ -1,71 +1,71 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Drawing; using System.Drawing;
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Models; using Artemis.Models;
using Artemis.Utilities.Keyboard; using Artemis.Utilities.Keyboard;
namespace Artemis.Modules.Effects.Debug namespace Artemis.Modules.Effects.Debug
{ {
internal class DebugEffectModel : EffectModel internal class DebugEffectModel : EffectModel
{ {
public DebugEffectModel(MainManager mainManager, DebugEffectSettings settings) : base(mainManager) public DebugEffectModel(MainManager mainManager, DebugEffectSettings settings) : base(mainManager)
{ {
Name = "Debug Effect"; Name = "Debug Effect";
Settings = settings; Settings = settings;
Scale = 4; Scale = 4;
Initialized = false; Initialized = false;
} }
public int Scale { get; set; } public int Scale { get; set; }
public DebugEffectSettings Settings { get; set; } public DebugEffectSettings Settings { get; set; }
public KeyboardRectangle KeyboardRectangle { get; set; } public KeyboardRectangle KeyboardRectangle { get; set; }
public override void Dispose() public override void Dispose()
{ {
Initialized = false; Initialized = false;
} }
public override void Enable() public override void Enable()
{ {
Initialized = false; Initialized = false;
KeyboardRectangle = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0, 0, new List<Color> KeyboardRectangle = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0, 0, new List<Color>
{ {
Color.Red, Color.Red,
Color.OrangeRed, Color.OrangeRed,
Color.Yellow, Color.Yellow,
Color.Green, Color.Green,
Color.Blue, Color.Blue,
Color.Purple, Color.Purple,
Color.DeepPink Color.DeepPink
}, LinearGradientMode.Horizontal); }, LinearGradientMode.Horizontal);
Initialized = true; Initialized = true;
} }
public override void Update() public override void Update()
{ {
KeyboardRectangle.Height = Settings.Height; KeyboardRectangle.Height = Settings.Height;
KeyboardRectangle.Width = Settings.Width; KeyboardRectangle.Width = Settings.Width;
KeyboardRectangle.GradientMode = Settings.Type; KeyboardRectangle.GradientMode = Settings.Type;
KeyboardRectangle.Rotate = Settings.Rotate; KeyboardRectangle.Rotate = Settings.Rotate;
KeyboardRectangle.Scale = Settings.Scale; KeyboardRectangle.Scale = Settings.Scale;
Scale = Settings.Scale; Scale = Settings.Scale;
} }
public override Bitmap GenerateBitmap() public override Bitmap GenerateBitmap()
{ {
var bitmap = new Bitmap(21*Scale, 6*Scale); var bitmap = new Bitmap(21*Scale, 6*Scale);
using (var g = Graphics.FromImage(bitmap)) using (var g = Graphics.FromImage(bitmap))
{ {
g.Clear(Color.Transparent); g.Clear(Color.Transparent);
KeyboardRectangle.Draw(g); KeyboardRectangle.Draw(g);
} }
return bitmap; return bitmap;
} }
} }
} }

72
Artemis/Artemis/Modules/Effects/Debug/DebugEffectSettings.cs
View File

@ -1,37 +1,37 @@
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using Artemis.Models; using Artemis.Models;
namespace Artemis.Modules.Effects.Debug namespace Artemis.Modules.Effects.Debug
{ {
internal class DebugEffectSettings : EffectSettings internal class DebugEffectSettings : EffectSettings
{ {
public DebugEffectSettings() public DebugEffectSettings()
{ {
Load(); Load();
} }
public int Width { get; set; } public int Width { get; set; }
public int Height { get; set; } public int Height { get; set; }
public bool Rotate { get; set; } public bool Rotate { get; set; }
public int Scale { get; set; } public int Scale { get; set; }
public LinearGradientMode Type { get; set; } public LinearGradientMode Type { get; set; }
public sealed override void Load() public sealed override void Load()
{ {
ToDefault(); ToDefault();
} }
public sealed override void Save() public sealed override void Save()
{ {
} }
public sealed override void ToDefault() public sealed override void ToDefault()
{ {
Width = 84; Width = 84;
Height = 24; Height = 24;
Scale = 4; Scale = 4;
Type = LinearGradientMode.Horizontal; Type = LinearGradientMode.Horizontal;
Rotate = true; Rotate = true;
} }
} }
} }

28
Artemis/Artemis/Modules/Effects/Debug/DebugEffectView.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Modules.Effects.Debug namespace Artemis.Modules.Effects.Debug
{ {
/// <summary> /// <summary>
/// Interaction logic for DebugEffectView.xaml /// Interaction logic for DebugEffectView.xaml
/// </summary> /// </summary>
public partial class DebugEffectView : UserControl public partial class DebugEffectView : UserControl
{ {
public DebugEffectView() public DebugEffectView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

168
Artemis/Artemis/Modules/Effects/Debug/DebugEffectViewModel.cs
View File

@ -1,85 +1,85 @@
using System; using System;
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using System.Drawing.Imaging; using System.Drawing.Imaging;
using System.IO; using System.IO;
using System.Windows.Media; using System.Windows.Media;
using System.Windows.Media.Imaging; using System.Windows.Media.Imaging;
using Artemis.Events; using Artemis.Events;
using Artemis.Managers; using Artemis.Managers;
using Artemis.ViewModels.Abstract; using Artemis.ViewModels.Abstract;
using Caliburn.Micro; using Caliburn.Micro;
namespace Artemis.Modules.Effects.Debug namespace Artemis.Modules.Effects.Debug
{ {
internal class DebugEffectViewModel : EffectViewModel, IHandle<ChangeBitmap>, IHandle<ActiveEffectChanged> internal class DebugEffectViewModel : EffectViewModel, IHandle<ChangeBitmap>, IHandle<ActiveEffectChanged>
{ {
private ImageSource _imageSource; private ImageSource _imageSource;
private string _selectedRectangleType; private string _selectedRectangleType;
public DebugEffectViewModel(MainManager mainManager) public DebugEffectViewModel(MainManager mainManager)
{ {
// Subscribe to main model // Subscribe to main model
MainManager = mainManager; MainManager = mainManager;
MainManager.Events.Subscribe(this); MainManager.Events.Subscribe(this);
// Settings are loaded from file by class // Settings are loaded from file by class
EffectSettings = new DebugEffectSettings(); EffectSettings = new DebugEffectSettings();
// Create effect model and add it to MainManager // Create effect model and add it to MainManager
EffectModel = new DebugEffectModel(mainManager, (DebugEffectSettings) EffectSettings); EffectModel = new DebugEffectModel(mainManager, (DebugEffectSettings) EffectSettings);
MainManager.EffectManager.EffectModels.Add(EffectModel); MainManager.EffectManager.EffectModels.Add(EffectModel);
} }
public static string Name => "Debug Effect"; public static string Name => "Debug Effect";
public BindableCollection<string> RectangleTypes public BindableCollection<string> RectangleTypes
=> new BindableCollection<string>(Enum.GetNames(typeof (LinearGradientMode))); => new BindableCollection<string>(Enum.GetNames(typeof (LinearGradientMode)));
public string SelectedRectangleType public string SelectedRectangleType
{ {
get { return _selectedRectangleType; } get { return _selectedRectangleType; }
set set
{ {
if (value == _selectedRectangleType) return; if (value == _selectedRectangleType) return;
_selectedRectangleType = value; _selectedRectangleType = value;
NotifyOfPropertyChange(() => SelectedRectangleType); NotifyOfPropertyChange(() => SelectedRectangleType);
((DebugEffectSettings) EffectSettings).Type = ((DebugEffectSettings) EffectSettings).Type =
(LinearGradientMode) Enum.Parse(typeof (LinearGradientMode), value); (LinearGradientMode) Enum.Parse(typeof (LinearGradientMode), value);
} }
} }
public ImageSource ImageSource public ImageSource ImageSource
{ {
get { return _imageSource; } get { return _imageSource; }
set set
{ {
_imageSource = value; _imageSource = value;
NotifyOfPropertyChange(() => ImageSource); NotifyOfPropertyChange(() => ImageSource);
} }
} }
public void Handle(ActiveEffectChanged message) public void Handle(ActiveEffectChanged message)
{ {
NotifyOfPropertyChange(() => EffectEnabled); NotifyOfPropertyChange(() => EffectEnabled);
} }
public void Handle(ChangeBitmap message) public void Handle(ChangeBitmap message)
{ {
using (var memory = new MemoryStream()) using (var memory = new MemoryStream())
{ {
message.Bitmap.Save(memory, ImageFormat.Png); message.Bitmap.Save(memory, ImageFormat.Png);
memory.Position = 0; memory.Position = 0;
var bitmapImage = new BitmapImage(); var bitmapImage = new BitmapImage();
bitmapImage.BeginInit(); bitmapImage.BeginInit();
bitmapImage.StreamSource = memory; bitmapImage.StreamSource = memory;
bitmapImage.CacheOption = BitmapCacheOption.OnLoad; bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
bitmapImage.EndInit(); bitmapImage.EndInit();
ImageSource = bitmapImage; ImageSource = bitmapImage;
} }
} }
} }
} }

78
Artemis/Artemis/Modules/Effects/TypeHole/TypeHoleModel.cs
View File

@ -1,40 +1,40 @@
using System.Drawing; using System.Drawing;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Models; using Artemis.Models;
namespace Artemis.Modules.Effects.TypeHole namespace Artemis.Modules.Effects.TypeHole
{ {
public class TypeHoleModel : EffectModel public class TypeHoleModel : EffectModel
{ {
public TypeHoleModel(MainManager mainManager) : base(mainManager) public TypeHoleModel(MainManager mainManager) : base(mainManager)
{ {
Name = "TypeHole"; Name = "TypeHole";
Initialized = false; Initialized = false;
} }
public override void Dispose() public override void Dispose()
{ {
Initialized = false; Initialized = false;
// Disable logic // Disable logic
} }
public override void Enable() public override void Enable()
{ {
Initialized = false; Initialized = false;
// Enable logic // Enable logic
Initialized = true; Initialized = true;
} }
public override void Update() public override void Update()
{ {
} }
public override Bitmap GenerateBitmap() public override Bitmap GenerateBitmap()
{ {
return null; return null;
} }
} }
} }

28
Artemis/Artemis/Modules/Effects/TypeHole/TypeHoleView.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Modules.Effects.TypeHole namespace Artemis.Modules.Effects.TypeHole
{ {
/// <summary> /// <summary>
/// Interaction logic for TypeHoleView.xaml /// Interaction logic for TypeHoleView.xaml
/// </summary> /// </summary>
public partial class TypeHoleView : UserControl public partial class TypeHoleView : UserControl
{ {
public TypeHoleView() public TypeHoleView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

54
Artemis/Artemis/Modules/Effects/TypeHole/TypeHoleViewModel.cs
View File

@ -1,28 +1,28 @@
using Artemis.Events; using Artemis.Events;
using Artemis.Managers; using Artemis.Managers;
using Artemis.ViewModels.Abstract; using Artemis.ViewModels.Abstract;
using Caliburn.Micro; using Caliburn.Micro;
namespace Artemis.Modules.Effects.TypeHole namespace Artemis.Modules.Effects.TypeHole
{ {
public class TypeHoleViewModel : EffectViewModel, IHandle<ActiveEffectChanged> public class TypeHoleViewModel : EffectViewModel, IHandle<ActiveEffectChanged>
{ {
public TypeHoleViewModel(MainManager mainManager) public TypeHoleViewModel(MainManager mainManager)
{ {
// Subscribe to main model // Subscribe to main model
MainManager = mainManager; MainManager = mainManager;
MainManager.Events.Subscribe(this); MainManager.Events.Subscribe(this);
// Create effect model and add it to MainManager // Create effect model and add it to MainManager
EffectModel = new TypeHoleModel(mainManager); EffectModel = new TypeHoleModel(mainManager);
MainManager.EffectManager.EffectModels.Add(EffectModel); MainManager.EffectManager.EffectModels.Add(EffectModel);
} }
public static string Name => "Type Holes (NYI)"; public static string Name => "Type Holes (NYI)";
public void Handle(ActiveEffectChanged message) public void Handle(ActiveEffectChanged message)
{ {
NotifyOfPropertyChange(() => EffectEnabled); NotifyOfPropertyChange(() => EffectEnabled);
} }
} }
} }

196
Artemis/Artemis/Modules/Effects/TypeWave/TypeWave.Designer.cs generated
View File

@ -1,98 +1,98 @@
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// <auto-generated> // <auto-generated>
// This code was generated by a tool. // This code was generated by a tool.
// Runtime Version:4.0.30319.42000 // Runtime Version:4.0.30319.42000
// //
// Changes to this file may cause incorrect behavior and will be lost if // Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated. // the code is regenerated.
// </auto-generated> // </auto-generated>
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
namespace Artemis.Settings { namespace Artemis.Settings {
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "14.0.0.0")] [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "14.0.0.0")]
internal sealed partial class TypeWave : global::System.Configuration.ApplicationSettingsBase { internal sealed partial class TypeWave : global::System.Configuration.ApplicationSettingsBase {
private static TypeWave defaultInstance = ((TypeWave)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new TypeWave()))); private static TypeWave defaultInstance = ((TypeWave)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new TypeWave())));
public static TypeWave Default { public static TypeWave Default {
get { get {
return defaultInstance; return defaultInstance;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("True")] [global::System.Configuration.DefaultSettingValueAttribute("True")]
public bool IsRandomColors { public bool IsRandomColors {
get { get {
return ((bool)(this["IsRandomColors"])); return ((bool)(this["IsRandomColors"]));
} }
set { set {
this["IsRandomColors"] = value; this["IsRandomColors"] = value;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("#FFFF0000")] [global::System.Configuration.DefaultSettingValueAttribute("#FFFF0000")]
public global::System.Windows.Media.Color WaveColor { public global::System.Windows.Media.Color WaveColor {
get { get {
return ((global::System.Windows.Media.Color)(this["WaveColor"])); return ((global::System.Windows.Media.Color)(this["WaveColor"]));
} }
set { set {
this["WaveColor"] = value; this["WaveColor"] = value;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("True")] [global::System.Configuration.DefaultSettingValueAttribute("True")]
public bool IsShiftColors { public bool IsShiftColors {
get { get {
return ((bool)(this["IsShiftColors"])); return ((bool)(this["IsShiftColors"]));
} }
set { set {
this["IsShiftColors"] = value; this["IsShiftColors"] = value;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("20")] [global::System.Configuration.DefaultSettingValueAttribute("20")]
public int ShiftColorSpeed { public int ShiftColorSpeed {
get { get {
return ((int)(this["ShiftColorSpeed"])); return ((int)(this["ShiftColorSpeed"]));
} }
set { set {
this["ShiftColorSpeed"] = value; this["ShiftColorSpeed"] = value;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("500")] [global::System.Configuration.DefaultSettingValueAttribute("500")]
public int TimeToLive { public int TimeToLive {
get { get {
return ((int)(this["TimeToLive"])); return ((int)(this["TimeToLive"]));
} }
set { set {
this["TimeToLive"] = value; this["TimeToLive"] = value;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("4")] [global::System.Configuration.DefaultSettingValueAttribute("4")]
public int SpreadSpeed { public int SpreadSpeed {
get { get {
return ((int)(this["SpreadSpeed"])); return ((int)(this["SpreadSpeed"]));
} }
set { set {
this["SpreadSpeed"] = value; this["SpreadSpeed"] = value;
} }
} }
} }
} }

302
Artemis/Artemis/Modules/Effects/TypeWave/TypeWaveModel.cs
View File

@ -1,152 +1,152 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Drawing; using System.Drawing;
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using System.Linq; using System.Linq;
using System.Windows.Forms; using System.Windows.Forms;
using Artemis.KeyboardProviders.Corsair; using Artemis.KeyboardProviders.Corsair;
using Artemis.KeyboardProviders.Logitech.Utilities; using Artemis.KeyboardProviders.Logitech.Utilities;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Models; using Artemis.Models;
using Artemis.Utilities; using Artemis.Utilities;
namespace Artemis.Modules.Effects.TypeWave namespace Artemis.Modules.Effects.TypeWave
{ {
public class TypeWaveModel : EffectModel public class TypeWaveModel : EffectModel
{ {
private readonly List<Wave> _waves; private readonly List<Wave> _waves;
private Color _randomColor; private Color _randomColor;
public TypeWaveModel(MainManager mainManager, TypeWaveSettings settings) : base(mainManager) public TypeWaveModel(MainManager mainManager, TypeWaveSettings settings) : base(mainManager)
{ {
Name = "TypeWave"; Name = "TypeWave";
_waves = new List<Wave>(); _waves = new List<Wave>();
_randomColor = Color.Red; _randomColor = Color.Red;
Settings = settings; Settings = settings;
Initialized = false; Initialized = false;
Scale = 4; Scale = 4;
} }
public int Scale { get; set; } public int Scale { get; set; }
public TypeWaveSettings Settings { get; set; } public TypeWaveSettings Settings { get; set; }
public override void Dispose() public override void Dispose()
{ {
Initialized = false; Initialized = false;
MainManager.KeyboardHook.KeyDownCallback -= KeyboardHookOnKeyDownCallback; MainManager.KeyboardHook.KeyDownCallback -= KeyboardHookOnKeyDownCallback;
} }
private void KeyboardHookOnKeyDownCallback(KeyEventArgs e) private void KeyboardHookOnKeyDownCallback(KeyEventArgs e)
{ {
// More than 25 waves is pointless // More than 25 waves is pointless
if (_waves.Count >= 25) if (_waves.Count >= 25)
return; return;
var keyMatch = KeyMap.UsEnglishOrionKeys.FirstOrDefault(k => k.KeyCode == e.KeyCode); var keyMatch = KeyMap.UsEnglishOrionKeys.FirstOrDefault(k => k.KeyCode == e.KeyCode);
if (keyMatch == null) if (keyMatch == null)
return; return;
_waves.Add(Settings.IsRandomColors _waves.Add(Settings.IsRandomColors
? new Wave(new Point(keyMatch.PosX * Scale, keyMatch.PosY * Scale), 0, _randomColor) ? new Wave(new Point(keyMatch.PosX * Scale, keyMatch.PosY * Scale), 0, _randomColor)
: new Wave(new Point(keyMatch.PosX * Scale, keyMatch.PosY * Scale), 0, : new Wave(new Point(keyMatch.PosX * Scale, keyMatch.PosY * Scale), 0,
ColorHelpers.ToDrawingColor(Settings.WaveColor))); ColorHelpers.ToDrawingColor(Settings.WaveColor)));
} }
public override void Enable() public override void Enable()
{ {
Initialized = false; Initialized = false;
// Listener won't start unless the effect is active // Listener won't start unless the effect is active
MainManager.KeyboardHook.KeyDownCallback += KeyboardHookOnKeyDownCallback; MainManager.KeyboardHook.KeyDownCallback += KeyboardHookOnKeyDownCallback;
Initialized = true; Initialized = true;
} }
public override void Update() public override void Update()
{ {
if (Settings.IsRandomColors) if (Settings.IsRandomColors)
_randomColor = ColorHelpers.ShiftColor(_randomColor, 25); _randomColor = ColorHelpers.ShiftColor(_randomColor, 25);
for (var i = 0; i < _waves.Count; i++) for (var i = 0; i < _waves.Count; i++)
{ {
// TODO: Get from settings // TODO: Get from settings
var fps = 25; var fps = 25;
_waves[i].Size += Settings.SpreadSpeed * Scale; _waves[i].Size += Settings.SpreadSpeed * Scale;
if (Settings.IsShiftColors) if (Settings.IsShiftColors)
_waves[i].Color = ColorHelpers.ShiftColor(_waves[i].Color, Settings.ShiftColorSpeed); _waves[i].Color = ColorHelpers.ShiftColor(_waves[i].Color, Settings.ShiftColorSpeed);
var decreaseAmount = 255/(Settings.TimeToLive/fps); var decreaseAmount = 255/(Settings.TimeToLive/fps);
_waves[i].Color = Color.FromArgb( _waves[i].Color = Color.FromArgb(
_waves[i].Color.A - decreaseAmount, _waves[i].Color.R, _waves[i].Color.A - decreaseAmount, _waves[i].Color.R,
_waves[i].Color.G, _waves[i].Color.G,
_waves[i].Color.B); _waves[i].Color.B);
if (_waves[i].Color.A >= decreaseAmount) if (_waves[i].Color.A >= decreaseAmount)
continue; continue;
_waves.RemoveAt(i); _waves.RemoveAt(i);
i--; i--;
} }
} }
public override Bitmap GenerateBitmap() public override Bitmap GenerateBitmap()
{ {
if (_waves.Count == 0) if (_waves.Count == 0)
return null; return null;
var bitmap = MainManager.KeyboardManager.ActiveKeyboard.KeyboardBitmap(Scale); var bitmap = MainManager.KeyboardManager.ActiveKeyboard.KeyboardBitmap(Scale);
using (var g = Graphics.FromImage(bitmap)) using (var g = Graphics.FromImage(bitmap))
{ {
g.Clear(Color.Transparent); g.Clear(Color.Transparent);
g.SmoothingMode = SmoothingMode.HighQuality; g.SmoothingMode = SmoothingMode.HighQuality;
// Don't want a for-each, collection is changed in different thread // Don't want a for-each, collection is changed in different thread
// ReSharper disable once ForCanBeConvertedToForeach // ReSharper disable once ForCanBeConvertedToForeach
for (var i = 0; i < _waves.Count; i++) for (var i = 0; i < _waves.Count; i++)
{ {
if (_waves[i].Size == 0) if (_waves[i].Size == 0)
continue; continue;
var path = new GraphicsPath(); var path = new GraphicsPath();
path.AddEllipse(_waves[i].Point.X - _waves[i].Size/2, _waves[i].Point.Y - _waves[i].Size/2, path.AddEllipse(_waves[i].Point.X - _waves[i].Size/2, _waves[i].Point.Y - _waves[i].Size/2,
_waves[i].Size, _waves[i].Size); _waves[i].Size, _waves[i].Size);
Color fillColor; Color fillColor;
if (MainManager.KeyboardManager.ActiveKeyboard is CorsairRGB) if (MainManager.KeyboardManager.ActiveKeyboard is CorsairRGB)
fillColor = Color.Black; fillColor = Color.Black;
else else
fillColor = Color.Transparent; fillColor = Color.Transparent;
var pthGrBrush = new PathGradientBrush(path) var pthGrBrush = new PathGradientBrush(path)
{ {
SurroundColors = new[] {_waves[i].Color}, SurroundColors = new[] {_waves[i].Color},
CenterColor = fillColor CenterColor = fillColor
}; };
g.FillPath(pthGrBrush, path); g.FillPath(pthGrBrush, path);
pthGrBrush.FocusScales = new PointF(0.3f, 0.8f); pthGrBrush.FocusScales = new PointF(0.3f, 0.8f);
g.FillPath(pthGrBrush, path); g.FillPath(pthGrBrush, path);
g.DrawEllipse(new Pen(pthGrBrush, 1), _waves[i].Point.X - _waves[i].Size/2, g.DrawEllipse(new Pen(pthGrBrush, 1), _waves[i].Point.X - _waves[i].Size/2,
_waves[i].Point.Y - _waves[i].Size/2, _waves[i].Size, _waves[i].Size); _waves[i].Point.Y - _waves[i].Size/2, _waves[i].Size, _waves[i].Size);
} }
} }
return bitmap; return bitmap;
} }
} }
public class Wave public class Wave
{ {
public Wave(Point point, int size, Color color) public Wave(Point point, int size, Color color)
{ {
Point = point; Point = point;
Size = size; Size = size;
Color = color; Color = color;
} }
public Point Point { get; set; } public Point Point { get; set; }
public int Size { get; set; } public int Size { get; set; }
public Color Color { get; set; } public Color Color { get; set; }
} }
} }

102
Artemis/Artemis/Modules/Effects/TypeWave/TypeWaveSettings.cs
View File

@ -1,52 +1,52 @@
using System.Windows.Media; using System.Windows.Media;
using Artemis.Models; using Artemis.Models;
namespace Artemis.Modules.Effects.TypeWave namespace Artemis.Modules.Effects.TypeWave
{ {
public class TypeWaveSettings : EffectSettings public class TypeWaveSettings : EffectSettings
{ {
public TypeWaveSettings() public TypeWaveSettings()
{ {
Load(); Load();
} }
public bool IsRandomColors { get; set; } public bool IsRandomColors { get; set; }
public Color WaveColor { get; set; } public Color WaveColor { get; set; }
public bool IsShiftColors { get; set; } public bool IsShiftColors { get; set; }
public int ShiftColorSpeed { get; set; } public int ShiftColorSpeed { get; set; }
public int TimeToLive { get; set; } public int TimeToLive { get; set; }
public int SpreadSpeed { get; set; } public int SpreadSpeed { get; set; }
public sealed override void Load() public sealed override void Load()
{ {
IsRandomColors = Settings.TypeWave.Default.IsRandomColors; IsRandomColors = Settings.TypeWave.Default.IsRandomColors;
WaveColor = Settings.TypeWave.Default.WaveColor; WaveColor = Settings.TypeWave.Default.WaveColor;
IsShiftColors = Settings.TypeWave.Default.IsShiftColors; IsShiftColors = Settings.TypeWave.Default.IsShiftColors;
ShiftColorSpeed = Settings.TypeWave.Default.ShiftColorSpeed; ShiftColorSpeed = Settings.TypeWave.Default.ShiftColorSpeed;
TimeToLive = Settings.TypeWave.Default.TimeToLive; TimeToLive = Settings.TypeWave.Default.TimeToLive;
SpreadSpeed = Settings.TypeWave.Default.SpreadSpeed; SpreadSpeed = Settings.TypeWave.Default.SpreadSpeed;
} }
public sealed override void Save() public sealed override void Save()
{ {
Settings.TypeWave.Default.IsRandomColors = IsRandomColors; Settings.TypeWave.Default.IsRandomColors = IsRandomColors;
Settings.TypeWave.Default.WaveColor = WaveColor; Settings.TypeWave.Default.WaveColor = WaveColor;
Settings.TypeWave.Default.IsShiftColors = IsShiftColors; Settings.TypeWave.Default.IsShiftColors = IsShiftColors;
Settings.TypeWave.Default.ShiftColorSpeed = ShiftColorSpeed; Settings.TypeWave.Default.ShiftColorSpeed = ShiftColorSpeed;
Settings.TypeWave.Default.TimeToLive = TimeToLive; Settings.TypeWave.Default.TimeToLive = TimeToLive;
Settings.TypeWave.Default.SpreadSpeed = SpreadSpeed; Settings.TypeWave.Default.SpreadSpeed = SpreadSpeed;
Settings.TypeWave.Default.Save(); Settings.TypeWave.Default.Save();
} }
public sealed override void ToDefault() public sealed override void ToDefault()
{ {
IsRandomColors = true; IsRandomColors = true;
WaveColor = Color.FromArgb(255, 255, 0, 0); WaveColor = Color.FromArgb(255, 255, 0, 0);
IsShiftColors = true; IsShiftColors = true;
ShiftColorSpeed = 20; ShiftColorSpeed = 20;
TimeToLive = 500; TimeToLive = 500;
SpreadSpeed = 4; SpreadSpeed = 4;
} }
} }
} }

28
Artemis/Artemis/Modules/Effects/TypeWave/TypeWaveView.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Modules.Effects.TypeWave namespace Artemis.Modules.Effects.TypeWave
{ {
/// <summary> /// <summary>
/// Interaction logic for TypeWaveView.xaml /// Interaction logic for TypeWaveView.xaml
/// </summary> /// </summary>
public partial class TypeWaveView : UserControl public partial class TypeWaveView : UserControl
{ {
public TypeWaveView() public TypeWaveView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

60
Artemis/Artemis/Modules/Effects/TypeWave/TypeWaveViewModel.cs
View File

@ -1,31 +1,31 @@
using Artemis.Events; using Artemis.Events;
using Artemis.Managers; using Artemis.Managers;
using Artemis.ViewModels.Abstract; using Artemis.ViewModels.Abstract;
using Caliburn.Micro; using Caliburn.Micro;
namespace Artemis.Modules.Effects.TypeWave namespace Artemis.Modules.Effects.TypeWave
{ {
public class TypeWaveViewModel : EffectViewModel, IHandle<ActiveEffectChanged> public class TypeWaveViewModel : EffectViewModel, IHandle<ActiveEffectChanged>
{ {
public TypeWaveViewModel(MainManager mainManager) public TypeWaveViewModel(MainManager mainManager)
{ {
// Subscribe to main model // Subscribe to main model
MainManager = mainManager; MainManager = mainManager;
MainManager.Events.Subscribe(this); MainManager.Events.Subscribe(this);
// Settings are loaded from file by class // Settings are loaded from file by class
EffectSettings = new TypeWaveSettings(); EffectSettings = new TypeWaveSettings();
// Create effect model and add it to MainManager // Create effect model and add it to MainManager
EffectModel = new TypeWaveModel(mainManager, (TypeWaveSettings) EffectSettings); EffectModel = new TypeWaveModel(mainManager, (TypeWaveSettings) EffectSettings);
MainManager.EffectManager.EffectModels.Add(EffectModel); MainManager.EffectManager.EffectModels.Add(EffectModel);
} }
public static string Name => "Type Waves"; public static string Name => "Type Waves";
public void Handle(ActiveEffectChanged message) public void Handle(ActiveEffectChanged message)
{ {
NotifyOfPropertyChange(() => EffectEnabled); NotifyOfPropertyChange(() => EffectEnabled);
} }
} }
} }

416
Artemis/Artemis/Modules/Games/CounterStrike/CounterStrikeModel.cs
View File

@ -1,209 +1,209 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Drawing; using System.Drawing;
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using System.Linq; using System.Linq;
using Artemis.KeyboardProviders; using Artemis.KeyboardProviders;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Models; using Artemis.Models;
using Artemis.Utilities; using Artemis.Utilities;
using Artemis.Utilities.GameState; using Artemis.Utilities.GameState;
using Artemis.Utilities.Keyboard; using Artemis.Utilities.Keyboard;
using Newtonsoft.Json; using Newtonsoft.Json;
using Newtonsoft.Json.Linq; using Newtonsoft.Json.Linq;
namespace Artemis.Modules.Games.CounterStrike namespace Artemis.Modules.Games.CounterStrike
{ {
public class CounterStrikeModel : GameModel public class CounterStrikeModel : GameModel
{ {
private KeyboardRegion _topRow; private KeyboardRegion _topRow;
public CounterStrikeModel(MainManager mainManager, CounterStrikeSettings settings) : base(mainManager) public CounterStrikeModel(MainManager mainManager, CounterStrikeSettings settings) : base(mainManager)
{ {
Settings = settings; Settings = settings;
Name = "CounterStrike"; Name = "CounterStrike";
ProcessName = "csgo"; ProcessName = "csgo";
Scale = 4; Scale = 4;
Enabled = Settings.Enabled; Enabled = Settings.Enabled;
Initialized = false; Initialized = false;
} }
public CounterStrikeSettings Settings { get; set; } public CounterStrikeSettings Settings { get; set; }
public KeyboardRectangle EventRect { get; set; } public KeyboardRectangle EventRect { get; set; }
public KeyboardRectangle TeamRect { get; set; } public KeyboardRectangle TeamRect { get; set; }
public KeyboardRectangle AmmoRect { get; set; } public KeyboardRectangle AmmoRect { get; set; }
public JObject CsJson { get; set; } public JObject CsJson { get; set; }
public bool DrawingSmoke { get; set; } public bool DrawingSmoke { get; set; }
public bool DrawingFlash { get; set; } public bool DrawingFlash { get; set; }
public int Scale { get; set; } public int Scale { get; set; }
public override void Dispose() public override void Dispose()
{ {
Initialized = false; Initialized = false;
MainManager.GameStateWebServer.GameDataReceived -= HandleGameData; MainManager.GameStateWebServer.GameDataReceived -= HandleGameData;
} }
public override void Enable() public override void Enable()
{ {
Initialized = false; Initialized = false;
// Some keyboards have a different baseline, Corsair F-keys start at row 1 // Some keyboards have a different baseline, Corsair F-keys start at row 1
_topRow = MainManager.KeyboardManager.ActiveKeyboard.KeyboardRegions.First(r => r.RegionName == "TopRow"); _topRow = MainManager.KeyboardManager.ActiveKeyboard.KeyboardRegions.First(r => r.RegionName == "TopRow");
AmmoRect = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0, _topRow.TopLeft.X, AmmoRect = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0, _topRow.TopLeft.X,
new List<Color>(), new List<Color>(),
LinearGradientMode.Horizontal) {Height = Scale, ContainedBrush = false}; LinearGradientMode.Horizontal) {Height = Scale, ContainedBrush = false};
TeamRect = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0, _topRow.TopLeft.X + 1, TeamRect = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0, _topRow.TopLeft.X + 1,
new List<Color>(), new List<Color>(),
LinearGradientMode.Horizontal) LinearGradientMode.Horizontal)
{ {
Height = MainManager.KeyboardManager.ActiveKeyboard.Height*Scale - Scale Height = MainManager.KeyboardManager.ActiveKeyboard.Height*Scale - Scale
}; };
EventRect = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0, _topRow.TopLeft.X + 1, EventRect = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0, _topRow.TopLeft.X + 1,
new List<Color>(), new List<Color>(),
LinearGradientMode.Horizontal) LinearGradientMode.Horizontal)
{ {
Height = MainManager.KeyboardManager.ActiveKeyboard.Height*Scale - Scale Height = MainManager.KeyboardManager.ActiveKeyboard.Height*Scale - Scale
}; };
MainManager.GameStateWebServer.GameDataReceived += HandleGameData; MainManager.GameStateWebServer.GameDataReceived += HandleGameData;
Initialized = true; Initialized = true;
} }
public override void Update() public override void Update()
{ {
if (CsJson == null) if (CsJson == null)
return; return;
if (Settings.AmmoEnabled) if (Settings.AmmoEnabled)
UpdateAmmo(); UpdateAmmo();
if (Settings.TeamColorEnabled) if (Settings.TeamColorEnabled)
UpdateTeam(); UpdateTeam();
if (Settings.LowHpEnabled) if (Settings.LowHpEnabled)
UpdateHealth(); UpdateHealth();
if (Settings.FlashEnabled) if (Settings.FlashEnabled)
UpdateFlash(); UpdateFlash();
if (Settings.SmokeEnabled) if (Settings.SmokeEnabled)
UpdateSmoke(); UpdateSmoke();
} }
private void UpdateHealth() private void UpdateHealth()
{ {
if (CsJson["player"]?["state"]?["health"] == null) if (CsJson["player"]?["state"]?["health"] == null)
return; return;
var health = CsJson["player"]["state"]["health"].Value<int>(); var health = CsJson["player"]["state"]["health"].Value<int>();
if (health > 25 || health < 1) if (health > 25 || health < 1)
return; return;
TeamRect.Colors = new List<Color> {Color.Red, Color.OrangeRed, Color.Red, Color.OrangeRed}; TeamRect.Colors = new List<Color> {Color.Red, Color.OrangeRed, Color.Red, Color.OrangeRed};
} }
private void UpdateSmoke() private void UpdateSmoke()
{ {
if (CsJson["player"]?["state"]?["smoked"] == null) if (CsJson["player"]?["state"]?["smoked"] == null)
return; return;
var smoked = CsJson["player"]["state"]["smoked"].Value<int>(); var smoked = CsJson["player"]["state"]["smoked"].Value<int>();
if (smoked == 0 && !DrawingSmoke) if (smoked == 0 && !DrawingSmoke)
return; return;
EventRect.Colors = new List<Color> {Color.FromArgb(smoked, 255, 255, 255)}; EventRect.Colors = new List<Color> {Color.FromArgb(smoked, 255, 255, 255)};
DrawingSmoke = smoked != 0; DrawingSmoke = smoked != 0;
} }
private void UpdateFlash() private void UpdateFlash()
{ {
if (CsJson["player"]?["state"]?["flashed"] == null) if (CsJson["player"]?["state"]?["flashed"] == null)
return; return;
var flashed = CsJson["player"]["state"]["flashed"].Value<int>(); var flashed = CsJson["player"]["state"]["flashed"].Value<int>();
if (flashed == 0 && !DrawingFlash) if (flashed == 0 && !DrawingFlash)
return; return;
EventRect.Colors = new List<Color> {Color.FromArgb(flashed, 255, 255, 255)}; EventRect.Colors = new List<Color> {Color.FromArgb(flashed, 255, 255, 255)};
DrawingFlash = flashed != 0; DrawingFlash = flashed != 0;
} }
private void UpdateTeam() private void UpdateTeam()
{ {
var currentTeam = CsJson["player"]?["team"]; var currentTeam = CsJson["player"]?["team"];
if (currentTeam == null) if (currentTeam == null)
return; return;
var t1 = Color.FromArgb(255, 255, 129, 0); var t1 = Color.FromArgb(255, 255, 129, 0);
var t2 = Color.FromArgb(255, 255, 170, 125); var t2 = Color.FromArgb(255, 255, 170, 125);
var ct1 = Color.FromArgb(255, 203, 238, 255); var ct1 = Color.FromArgb(255, 203, 238, 255);
var ct2 = Color.FromArgb(255, 0, 173, 255); var ct2 = Color.FromArgb(255, 0, 173, 255);
TeamRect.Colors = currentTeam.Value<string>() == "T" TeamRect.Colors = currentTeam.Value<string>() == "T"
? new List<Color> {t1, t2, t1, t2} ? new List<Color> {t1, t2, t1, t2}
: new List<Color> {ct1, ct2, ct1, ct2}; : new List<Color> {ct1, ct2, ct1, ct2};
TeamRect.Rotate = true; TeamRect.Rotate = true;
} }
private void UpdateAmmo() private void UpdateAmmo()
{ {
if (CsJson["player"]["weapons"] == null) if (CsJson["player"]["weapons"] == null)
return; return;
var activeWeapon = var activeWeapon =
CsJson["player"]["weapons"].Children() CsJson["player"]["weapons"].Children()
.Select(c => c.First) .Select(c => c.First)
.FirstOrDefault(w => w["state"]?.Value<string>() == "active"); .FirstOrDefault(w => w["state"]?.Value<string>() == "active");
// Update the ammo display // Update the ammo display
if (activeWeapon?["ammo_clip_max"] == null || activeWeapon["ammo_clip"] == null) if (activeWeapon?["ammo_clip_max"] == null || activeWeapon["ammo_clip"] == null)
return; return;
var maxAmmo = activeWeapon["ammo_clip_max"].Value<int>(); var maxAmmo = activeWeapon["ammo_clip_max"].Value<int>();
var ammo = activeWeapon["ammo_clip"].Value<int>(); var ammo = activeWeapon["ammo_clip"].Value<int>();
if (maxAmmo < 0) if (maxAmmo < 0)
return; return;
var ammoPercentage = (int) Math.Ceiling(100.00/maxAmmo)*ammo; var ammoPercentage = (int) Math.Ceiling(100.00/maxAmmo)*ammo;
AmmoRect.Width = (int) Math.Floor(_topRow.BottomRight.Y/100.00*ammoPercentage)*Scale; AmmoRect.Width = (int) Math.Floor(_topRow.BottomRight.Y/100.00*ammoPercentage)*Scale;
AmmoRect.Colors = new List<Color> AmmoRect.Colors = new List<Color>
{ {
ColorHelpers.ToDrawingColor(Settings.AmmoMainColor), ColorHelpers.ToDrawingColor(Settings.AmmoMainColor),
ColorHelpers.ToDrawingColor(Settings.AmmoSecondaryColor) ColorHelpers.ToDrawingColor(Settings.AmmoSecondaryColor)
}; };
// Low ammo indicator // Low ammo indicator
if (ammoPercentage < 37) if (ammoPercentage < 37)
AmmoRect.StartBlink(1000); AmmoRect.StartBlink(1000);
else else
AmmoRect.StopBlink(); AmmoRect.StopBlink();
} }
public override Bitmap GenerateBitmap() public override Bitmap GenerateBitmap()
{ {
var bitmap = MainManager.KeyboardManager.ActiveKeyboard.KeyboardBitmap(Scale); var bitmap = MainManager.KeyboardManager.ActiveKeyboard.KeyboardBitmap(Scale);
using (var g = Graphics.FromImage(bitmap)) using (var g = Graphics.FromImage(bitmap))
{ {
g.Clear(Color.Transparent); g.Clear(Color.Transparent);
AmmoRect.Draw(g); AmmoRect.Draw(g);
TeamRect.Draw(g); TeamRect.Draw(g);
EventRect.Draw(g); EventRect.Draw(g);
} }
return bitmap; return bitmap;
} }
public void HandleGameData(object sender, GameDataReceivedEventArgs e) public void HandleGameData(object sender, GameDataReceivedEventArgs e)
{ {
var jsonString = e.Json.ToString(); var jsonString = e.Json.ToString();
// Ensure it's CS:GO JSON // Ensure it's CS:GO JSON
if (!jsonString.Contains("Counter-Strike: Global Offensive")) if (!jsonString.Contains("Counter-Strike: Global Offensive"))
return; return;
// Parse the JSON // Parse the JSON
CsJson = JsonConvert.DeserializeObject<JObject>(jsonString); CsJson = JsonConvert.DeserializeObject<JObject>(jsonString);
} }
} }
} }

140
Artemis/Artemis/Modules/Games/CounterStrike/CounterStrikeSettings.cs
View File

@ -1,71 +1,71 @@
using System.Windows.Media; using System.Windows.Media;
using Artemis.Models; using Artemis.Models;
namespace Artemis.Modules.Games.CounterStrike namespace Artemis.Modules.Games.CounterStrike
{ {
public class CounterStrikeSettings : GameSettings public class CounterStrikeSettings : GameSettings
{ {
public CounterStrikeSettings() public CounterStrikeSettings()
{ {
Load(); Load();
} }
public string GameDirectory { get; set; } public string GameDirectory { get; set; }
public bool AmmoEnabled { get; set; } public bool AmmoEnabled { get; set; }
public Color AmmoMainColor { get; set; } public Color AmmoMainColor { get; set; }
public Color AmmoSecondaryColor { get; set; } public Color AmmoSecondaryColor { get; set; }
public bool TeamColorEnabled { get; set; } public bool TeamColorEnabled { get; set; }
public bool FlashEnabled { get; set; } public bool FlashEnabled { get; set; }
public bool SmokeEnabled { get; set; } public bool SmokeEnabled { get; set; }
public bool LowHpEnabled { get; set; } public bool LowHpEnabled { get; set; }
public sealed override void Load() public sealed override void Load()
{ {
Enabled = CounterStrike.Default.Enabled; Enabled = CounterStrike.Default.Enabled;
GameDirectory = CounterStrike.Default.GameDirectory; GameDirectory = CounterStrike.Default.GameDirectory;
AmmoEnabled = CounterStrike.Default.AmmoEnabled; AmmoEnabled = CounterStrike.Default.AmmoEnabled;
AmmoMainColor = CounterStrike.Default.AmmoMainColor; AmmoMainColor = CounterStrike.Default.AmmoMainColor;
AmmoSecondaryColor = CounterStrike.Default.AmmoSecondaryColor; AmmoSecondaryColor = CounterStrike.Default.AmmoSecondaryColor;
TeamColorEnabled = CounterStrike.Default.TeamColorEnabled; TeamColorEnabled = CounterStrike.Default.TeamColorEnabled;
FlashEnabled = CounterStrike.Default.FlashEnabled; FlashEnabled = CounterStrike.Default.FlashEnabled;
SmokeEnabled = CounterStrike.Default.SmokeEnabled; SmokeEnabled = CounterStrike.Default.SmokeEnabled;
LowHpEnabled = CounterStrike.Default.LowHpEnabled; LowHpEnabled = CounterStrike.Default.LowHpEnabled;
} }
public sealed override void Save() public sealed override void Save()
{ {
CounterStrike.Default.Enabled = Enabled; CounterStrike.Default.Enabled = Enabled;
CounterStrike.Default.GameDirectory = GameDirectory; CounterStrike.Default.GameDirectory = GameDirectory;
CounterStrike.Default.AmmoEnabled = AmmoEnabled; CounterStrike.Default.AmmoEnabled = AmmoEnabled;
CounterStrike.Default.AmmoMainColor = AmmoMainColor; CounterStrike.Default.AmmoMainColor = AmmoMainColor;
CounterStrike.Default.AmmoSecondaryColor = AmmoSecondaryColor; CounterStrike.Default.AmmoSecondaryColor = AmmoSecondaryColor;
CounterStrike.Default.TeamColorEnabled = TeamColorEnabled; CounterStrike.Default.TeamColorEnabled = TeamColorEnabled;
CounterStrike.Default.FlashEnabled = FlashEnabled; CounterStrike.Default.FlashEnabled = FlashEnabled;
CounterStrike.Default.SmokeEnabled = SmokeEnabled; CounterStrike.Default.SmokeEnabled = SmokeEnabled;
CounterStrike.Default.LowHpEnabled = LowHpEnabled; CounterStrike.Default.LowHpEnabled = LowHpEnabled;
CounterStrike.Default.Save(); CounterStrike.Default.Save();
} }
public sealed override void ToDefault() public sealed override void ToDefault()
{ {
Enabled = true; Enabled = true;
GameDirectory = string.Empty; GameDirectory = string.Empty;
AmmoEnabled = true; AmmoEnabled = true;
AmmoMainColor = Color.FromArgb(255, 38, 246, 0); AmmoMainColor = Color.FromArgb(255, 38, 246, 0);
AmmoSecondaryColor = Color.FromArgb(255, 255, 41, 0); AmmoSecondaryColor = Color.FromArgb(255, 255, 41, 0);
TeamColorEnabled = true; TeamColorEnabled = true;
FlashEnabled = true; FlashEnabled = true;
SmokeEnabled = true; SmokeEnabled = true;
LowHpEnabled = true; LowHpEnabled = true;
} }
} }
} }

28
Artemis/Artemis/Modules/Games/CounterStrike/CounterStrikeView.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Modules.Games.CounterStrike namespace Artemis.Modules.Games.CounterStrike
{ {
/// <summary> /// <summary>
/// Interaction logic for CounterStrikeView.xaml /// Interaction logic for CounterStrikeView.xaml
/// </summary> /// </summary>
public partial class CounterStrikeView : UserControl public partial class CounterStrikeView : UserControl
{ {
public CounterStrikeView() public CounterStrikeView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

126
Artemis/Artemis/Modules/Games/CounterStrike/CounterStrikeViewModel.cs
View File

@ -1,64 +1,64 @@
using System.IO; using System.IO;
using System.Windows.Forms; using System.Windows.Forms;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Properties; using Artemis.Properties;
using Artemis.ViewModels.Abstract; using Artemis.ViewModels.Abstract;
namespace Artemis.Modules.Games.CounterStrike namespace Artemis.Modules.Games.CounterStrike
{ {
public class CounterStrikeViewModel : GameViewModel public class CounterStrikeViewModel : GameViewModel
{ {
public CounterStrikeViewModel(MainManager mainManager) public CounterStrikeViewModel(MainManager mainManager)
{ {
MainManager = mainManager; MainManager = mainManager;
// Settings are loaded from file by class // Settings are loaded from file by class
GameSettings = new CounterStrikeSettings(); GameSettings = new CounterStrikeSettings();
// Create effect model and add it to MainManager // Create effect model and add it to MainManager
GameModel = new CounterStrikeModel(mainManager, (CounterStrikeSettings) GameSettings); GameModel = new CounterStrikeModel(mainManager, (CounterStrikeSettings) GameSettings);
MainManager.EffectManager.EffectModels.Add(GameModel); MainManager.EffectManager.EffectModels.Add(GameModel);
PlaceConfigFile(); PlaceConfigFile();
} }
public static string Name => "CS:GO"; public static string Name => "CS:GO";
public string Content => "Counter-Strike: GO Content"; public string Content => "Counter-Strike: GO Content";
public void BrowseDirectory() public void BrowseDirectory()
{ {
var dialog = new FolderBrowserDialog {SelectedPath = ((CounterStrikeSettings) GameSettings).GameDirectory}; var dialog = new FolderBrowserDialog {SelectedPath = ((CounterStrikeSettings) GameSettings).GameDirectory};
var result = dialog.ShowDialog(); var result = dialog.ShowDialog();
if (result != DialogResult.OK) if (result != DialogResult.OK)
return; return;
((CounterStrikeSettings) GameSettings).GameDirectory = dialog.SelectedPath; ((CounterStrikeSettings) GameSettings).GameDirectory = dialog.SelectedPath;
NotifyOfPropertyChange(() => GameSettings); NotifyOfPropertyChange(() => GameSettings);
GameSettings.Save(); GameSettings.Save();
PlaceConfigFile(); PlaceConfigFile();
} }
public void PlaceConfigFile() public void PlaceConfigFile()
{ {
if (((CounterStrikeSettings) GameSettings).GameDirectory == string.Empty) if (((CounterStrikeSettings) GameSettings).GameDirectory == string.Empty)
return; return;
if (Directory.Exists(((CounterStrikeSettings) GameSettings).GameDirectory + "/csgo/cfg")) if (Directory.Exists(((CounterStrikeSettings) GameSettings).GameDirectory + "/csgo/cfg"))
{ {
var cfgFile = Resources.csgoGamestateConfiguration.Replace("{{port}}", var cfgFile = Resources.csgoGamestateConfiguration.Replace("{{port}}",
MainManager.GameStateWebServer.Port.ToString()); MainManager.GameStateWebServer.Port.ToString());
File.WriteAllText( File.WriteAllText(
((CounterStrikeSettings) GameSettings).GameDirectory + "/csgo/cfg/gamestate_integration_artemis.cfg", ((CounterStrikeSettings) GameSettings).GameDirectory + "/csgo/cfg/gamestate_integration_artemis.cfg",
cfgFile); cfgFile);
return; return;
} }
MainManager.DialogService.ShowErrorMessageBox("Please select a valid CS:GO directory\n\n" + MainManager.DialogService.ShowErrorMessageBox("Please select a valid CS:GO directory\n\n" +
@"By default CS:GO is in \SteamApps\common\Counter-Strike Global Offensive"); @"By default CS:GO is in \SteamApps\common\Counter-Strike Global Offensive");
((CounterStrikeSettings) GameSettings).GameDirectory = string.Empty; ((CounterStrikeSettings) GameSettings).GameDirectory = string.Empty;
NotifyOfPropertyChange(() => GameSettings); NotifyOfPropertyChange(() => GameSettings);
GameSettings.Save(); GameSettings.Save();
} }
} }
} }

28
Artemis/Artemis/Modules/Games/Dota2/Dota2View.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Modules.Games.Dota2 namespace Artemis.Modules.Games.Dota2
{ {
/// <summary> /// <summary>
/// Interaction logic for Dota2View.xaml /// Interaction logic for Dota2View.xaml
/// </summary> /// </summary>
public partial class Dota2View : UserControl public partial class Dota2View : UserControl
{ {
public Dota2View() public Dota2View()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

84
Artemis/Artemis/Modules/Games/RocketLeague/RocketLeagueSettings.cs
View File

@ -1,43 +1,43 @@
using System.Windows.Media; using System.Windows.Media;
using Artemis.Models; using Artemis.Models;
namespace Artemis.Modules.Games.RocketLeague namespace Artemis.Modules.Games.RocketLeague
{ {
public class RocketLeagueSettings : GameSettings public class RocketLeagueSettings : GameSettings
{ {
public RocketLeagueSettings() public RocketLeagueSettings()
{ {
Load(); Load();
} }
public Color MainColor { get; set; } public Color MainColor { get; set; }
public Color SecondaryColor { get; set; } public Color SecondaryColor { get; set; }
public bool ContextualColor { get; set; } public bool ContextualColor { get; set; }
public sealed override void Load() public sealed override void Load()
{ {
Enabled = RocketLeague.Default.Enabled; Enabled = RocketLeague.Default.Enabled;
MainColor = RocketLeague.Default.MainColor; MainColor = RocketLeague.Default.MainColor;
SecondaryColor = RocketLeague.Default.SecondaryColor; SecondaryColor = RocketLeague.Default.SecondaryColor;
ContextualColor = RocketLeague.Default.ContextualColor; ContextualColor = RocketLeague.Default.ContextualColor;
} }
public sealed override void Save() public sealed override void Save()
{ {
RocketLeague.Default.Enabled = Enabled; RocketLeague.Default.Enabled = Enabled;
RocketLeague.Default.MainColor = MainColor; RocketLeague.Default.MainColor = MainColor;
RocketLeague.Default.SecondaryColor = SecondaryColor; RocketLeague.Default.SecondaryColor = SecondaryColor;
RocketLeague.Default.ContextualColor = ContextualColor; RocketLeague.Default.ContextualColor = ContextualColor;
RocketLeague.Default.Save(); RocketLeague.Default.Save();
} }
public sealed override void ToDefault() public sealed override void ToDefault()
{ {
Enabled = true; Enabled = true;
MainColor = Color.FromArgb(255, 255, 80, 0); MainColor = Color.FromArgb(255, 255, 80, 0);
SecondaryColor = Color.FromArgb(255, 255, 0, 0); SecondaryColor = Color.FromArgb(255, 255, 0, 0);
ContextualColor = false; ContextualColor = false;
} }
} }
} }

28
Artemis/Artemis/Modules/Games/RocketLeague/RocketLeagueView.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Modules.Games.RocketLeague namespace Artemis.Modules.Games.RocketLeague
{ {
/// <summary> /// <summary>
/// Interaction logic for RocketLeagueView.xaml /// Interaction logic for RocketLeagueView.xaml
/// </summary> /// </summary>
public partial class RocketLeagueView : UserControl public partial class RocketLeagueView : UserControl
{ {
public RocketLeagueView() public RocketLeagueView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

118
Artemis/Artemis/Modules/Games/RocketLeague/RocketLeagueViewModel.cs
View File

@ -1,60 +1,60 @@
using Artemis.Managers; using Artemis.Managers;
using Artemis.Settings; using Artemis.Settings;
using Artemis.Utilities; using Artemis.Utilities;
using Artemis.Utilities.Memory; using Artemis.Utilities.Memory;
using Artemis.ViewModels.Abstract; using Artemis.ViewModels.Abstract;
using Newtonsoft.Json; using Newtonsoft.Json;
namespace Artemis.Modules.Games.RocketLeague namespace Artemis.Modules.Games.RocketLeague
{ {
public class RocketLeagueViewModel : GameViewModel public class RocketLeagueViewModel : GameViewModel
{ {
private string _versionText; private string _versionText;
public RocketLeagueViewModel(MainManager mainManager) public RocketLeagueViewModel(MainManager mainManager)
{ {
MainManager = mainManager; MainManager = mainManager;
// Settings are loaded from file by class // Settings are loaded from file by class
GameSettings = new RocketLeagueSettings(); GameSettings = new RocketLeagueSettings();
// Create effect model and add it to MainManager // Create effect model and add it to MainManager
GameModel = new RocketLeagueModel(mainManager, (RocketLeagueSettings) GameSettings); GameModel = new RocketLeagueModel(mainManager, (RocketLeagueSettings) GameSettings);
MainManager.EffectManager.EffectModels.Add(GameModel); MainManager.EffectManager.EffectModels.Add(GameModel);
SetVersionText(); SetVersionText();
} }
public static string Name => "Rocket League"; public static string Name => "Rocket League";
public string VersionText public string VersionText
{ {
get { return _versionText; } get { return _versionText; }
set set
{ {
if (value == _versionText) return; if (value == _versionText) return;
_versionText = value; _versionText = value;
NotifyOfPropertyChange(() => VersionText); NotifyOfPropertyChange(() => VersionText);
} }
} }
public RocketLeagueModel RocketLeagueModel { get; set; } public RocketLeagueModel RocketLeagueModel { get; set; }
private void SetVersionText() private void SetVersionText()
{ {
if (!General.Default.EnablePointersUpdate) if (!General.Default.EnablePointersUpdate)
{ {
VersionText = "Note: You disabled pointer updates, this could result in the " + VersionText = "Note: You disabled pointer updates, this could result in the " +
"Rocket League effect not working after a game update."; "Rocket League effect not working after a game update.";
return; return;
} }
Updater.GetPointers(); Updater.GetPointers();
var version = JsonConvert var version = JsonConvert
.DeserializeObject<GamePointersCollection>(Offsets.Default.RocketLeague) .DeserializeObject<GamePointersCollection>(Offsets.Default.RocketLeague)
.GameVersion; .GameVersion;
VersionText = $"Note: Requires patch {version}. When a new patch is released Artemis downloads " + VersionText = $"Note: Requires patch {version}. When a new patch is released Artemis downloads " +
"new pointers for the latest version (unless disabled in settings)."; "new pointers for the latest version (unless disabled in settings).";
} }
} }
} }

512
Artemis/Artemis/Modules/Games/TheDivision/TheDivisionModel.cs
View File

@ -1,257 +1,257 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Drawing; using System.Drawing;
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using System.Linq; using System.Linq;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Models; using Artemis.Models;
using Artemis.Modules.Effects.TypeWave; using Artemis.Modules.Effects.TypeWave;
using Artemis.Utilities; using Artemis.Utilities;
using Artemis.Utilities.Keyboard; using Artemis.Utilities.Keyboard;
using Artemis.Utilities.LogitechDll; using Artemis.Utilities.LogitechDll;
using CUE.NET; using CUE.NET;
namespace Artemis.Modules.Games.TheDivision namespace Artemis.Modules.Games.TheDivision
{ {
public class TheDivisionModel : GameModel public class TheDivisionModel : GameModel
{ {
private Wave _ammoWave; private Wave _ammoWave;
private TheDivisionDataModel _dataModel; private TheDivisionDataModel _dataModel;
private KeyboardRectangle _hpRect; private KeyboardRectangle _hpRect;
private KeyboardRectangle _p2; private KeyboardRectangle _p2;
private KeyboardRectangle _p3; private KeyboardRectangle _p3;
private KeyboardRectangle _p4; private KeyboardRectangle _p4;
private StickyValue<bool> _stickyAmmo; private StickyValue<bool> _stickyAmmo;
private StickyValue<bool> _stickyHp; private StickyValue<bool> _stickyHp;
private int _trans; private int _trans;
public TheDivisionModel(MainManager mainManager, TheDivisionSettings settings) : base(mainManager) public TheDivisionModel(MainManager mainManager, TheDivisionSettings settings) : base(mainManager)
{ {
Settings = settings; Settings = settings;
Name = "TheDivision"; Name = "TheDivision";
ProcessName = "TheDivision"; ProcessName = "TheDivision";
Scale = 4; Scale = 4;
Enabled = Settings.Enabled; Enabled = Settings.Enabled;
Initialized = false; Initialized = false;
} }
public TheDivisionSettings Settings { get; set; } public TheDivisionSettings Settings { get; set; }
public int Scale { get; set; } public int Scale { get; set; }
public override void Dispose() public override void Dispose()
{ {
Initialized = false; Initialized = false;
DllManager.RestoreDll(); DllManager.RestoreDll();
_stickyAmmo.Dispose(); _stickyAmmo.Dispose();
_stickyHp.Dispose(); _stickyHp.Dispose();
} }
public override void Enable() public override void Enable()
{ {
Initialized = false; Initialized = false;
_ammoWave = new Wave(new Point(30, 14), 0, Color.Transparent); _ammoWave = new Wave(new Point(30, 14), 0, Color.Transparent);
_hpRect = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 3*Scale, 0*Scale, _hpRect = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 3*Scale, 0*Scale,
new List<Color>(), new List<Color>(),
LinearGradientMode.Horizontal) LinearGradientMode.Horizontal)
{ {
Height = 7*Scale, Height = 7*Scale,
Width = 21*Scale, Width = 21*Scale,
Rotate = true, Rotate = true,
ContainedBrush = false ContainedBrush = false
}; };
_p2 = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0*Scale, 1*Scale, _p2 = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0*Scale, 1*Scale,
new List<Color>(), new List<Color>(),
LinearGradientMode.Horizontal) LinearGradientMode.Horizontal)
{ {
Height = 2*Scale, Height = 2*Scale,
Width = 3*Scale, Width = 3*Scale,
Rotate = true, Rotate = true,
ContainedBrush = false ContainedBrush = false
}; };
_p3 = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0*Scale, 3*Scale, _p3 = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0*Scale, 3*Scale,
new List<Color>(), new List<Color>(),
LinearGradientMode.Horizontal) LinearGradientMode.Horizontal)
{ {
Height = 2*Scale, Height = 2*Scale,
Width = 3*Scale, Width = 3*Scale,
Rotate = true, Rotate = true,
ContainedBrush = false ContainedBrush = false
}; };
_p4 = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0*Scale, 5*Scale, _p4 = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0*Scale, 5*Scale,
new List<Color>(), new List<Color>(),
LinearGradientMode.Horizontal) LinearGradientMode.Horizontal)
{ {
Height = 2*Scale, Height = 2*Scale,
Width = 3*Scale, Width = 3*Scale,
Rotate = true, Rotate = true,
ContainedBrush = false ContainedBrush = false
}; };
_stickyAmmo = new StickyValue<bool>(200); _stickyAmmo = new StickyValue<bool>(200);
_stickyHp = new StickyValue<bool>(200); _stickyHp = new StickyValue<bool>(200);
DllManager.PlaceDll(); DllManager.PlaceDll();
_dataModel = new TheDivisionDataModel(); _dataModel = new TheDivisionDataModel();
for (var i = 1; i < 5; i++) for (var i = 1; i < 5; i++)
_dataModel.DivisionPlayers.Add(new DivisionPlayer(i)); _dataModel.DivisionPlayers.Add(new DivisionPlayer(i));
MainManager.PipeServer.PipeMessage += PipeServerOnPipeMessage; MainManager.PipeServer.PipeMessage += PipeServerOnPipeMessage;
Initialized = true; Initialized = true;
} }
private void PipeServerOnPipeMessage(string reply) private void PipeServerOnPipeMessage(string reply)
{ {
if (!Initialized) if (!Initialized)
return; return;
// Convert the given string to a list of ints // Convert the given string to a list of ints
var stringParts = reply.Split(' '); var stringParts = reply.Split(' ');
var parts = new int[stringParts.Length]; var parts = new int[stringParts.Length];
for (var i = 0; i < stringParts.Length; i++) for (var i = 0; i < stringParts.Length; i++)
parts[i] = int.Parse(stringParts[i]); parts[i] = int.Parse(stringParts[i]);
if (parts[0] == 1) if (parts[0] == 1)
InterpertrateDivisionKey(parts); InterpertrateDivisionKey(parts);
} }
// Parses Division key data to game data // Parses Division key data to game data
private void InterpertrateDivisionKey(int[] parts) private void InterpertrateDivisionKey(int[] parts)
{ {
var keyCode = parts[1]; var keyCode = parts[1];
var rPer = parts[2]; var rPer = parts[2];
var gPer = parts[3]; var gPer = parts[3];
var bPer = parts[4]; var bPer = parts[4];
// F1 to F4 indicate the player and his party. Blinks red on damage taken // F1 to F4 indicate the player and his party. Blinks red on damage taken
if (keyCode >= 59 && keyCode <= 62) if (keyCode >= 59 && keyCode <= 62)
{ {
var playerId = keyCode - 58; var playerId = keyCode - 58;
var playerDataModel = _dataModel.DivisionPlayers.FirstOrDefault(p => p.Id == playerId); var playerDataModel = _dataModel.DivisionPlayers.FirstOrDefault(p => p.Id == playerId);
if (playerDataModel == null) if (playerDataModel == null)
return; return;
if (gPer > 10) if (gPer > 10)
playerDataModel.PlayerState = PlayerState.Online; playerDataModel.PlayerState = PlayerState.Online;
else if (rPer > 10) else if (rPer > 10)
playerDataModel.PlayerState = PlayerState.Hit; playerDataModel.PlayerState = PlayerState.Hit;
else else
playerDataModel.PlayerState = PlayerState.Offline; playerDataModel.PlayerState = PlayerState.Offline;
} }
// R blinks white when low on ammo // R blinks white when low on ammo
else if (keyCode == 19) else if (keyCode == 19)
{ {
_stickyAmmo.Value = rPer == 100 && gPer > 1 && bPer > 1; _stickyAmmo.Value = rPer == 100 && gPer > 1 && bPer > 1;
_dataModel.LowAmmo = _stickyAmmo.Value; _dataModel.LowAmmo = _stickyAmmo.Value;
} }
// G turns white when holding a grenade, turns off when out of grenades // G turns white when holding a grenade, turns off when out of grenades
else if (keyCode == 34) else if (keyCode == 34)
{ {
if (rPer == 100 && gPer < 10 && bPer < 10) if (rPer == 100 && gPer < 10 && bPer < 10)
_dataModel.GrenadeState = GrenadeState.HasGrenade; _dataModel.GrenadeState = GrenadeState.HasGrenade;
else if (rPer == 100 && gPer > 10 && bPer > 10) else if (rPer == 100 && gPer > 10 && bPer > 10)
_dataModel.GrenadeState = GrenadeState.GrenadeEquipped; _dataModel.GrenadeState = GrenadeState.GrenadeEquipped;
else else
_dataModel.GrenadeState = GrenadeState.HasNoGrenade; _dataModel.GrenadeState = GrenadeState.HasNoGrenade;
} }
// V blinks on low HP // V blinks on low HP
else if (keyCode == 47) else if (keyCode == 47)
{ {
_stickyHp.Value = rPer == 100 && gPer > 1 && bPer > 1; _stickyHp.Value = rPer == 100 && gPer > 1 && bPer > 1;
_dataModel.LowHp = _stickyHp.Value; _dataModel.LowHp = _stickyHp.Value;
} }
} }
public override void Update() public override void Update()
{ {
if (_dataModel.LowAmmo) if (_dataModel.LowAmmo)
{ {
_ammoWave.Size++; _ammoWave.Size++;
if (_ammoWave.Size > 30) if (_ammoWave.Size > 30)
{ {
_ammoWave.Size = 0; _ammoWave.Size = 0;
_trans = 255; _trans = 255;
} }
} }
else else
_ammoWave.Size = 0; _ammoWave.Size = 0;
_hpRect.Colors = _dataModel.LowHp _hpRect.Colors = _dataModel.LowHp
? new List<Color> {Color.Red, Color.Orange} ? new List<Color> {Color.Red, Color.Orange}
: new List<Color> {Color.FromArgb(10, 255, 0), Color.FromArgb(80, 255, 45) }; : new List<Color> {Color.FromArgb(10, 255, 0), Color.FromArgb(80, 255, 45) };
if (_dataModel.DivisionPlayers[1].PlayerState == PlayerState.Offline) if (_dataModel.DivisionPlayers[1].PlayerState == PlayerState.Offline)
_p2.Colors = new List<Color> {Color.Gray, Color.White}; _p2.Colors = new List<Color> {Color.Gray, Color.White};
else if (_dataModel.DivisionPlayers[1].PlayerState == PlayerState.Online) else if (_dataModel.DivisionPlayers[1].PlayerState == PlayerState.Online)
_p2.Colors = new List<Color> { Color.FromArgb(10, 255, 0), Color.FromArgb(80, 255, 45) }; _p2.Colors = new List<Color> { Color.FromArgb(10, 255, 0), Color.FromArgb(80, 255, 45) };
else else
_p2.Colors = new List<Color> {Color.Red, Color.Orange}; _p2.Colors = new List<Color> {Color.Red, Color.Orange};
if (_dataModel.DivisionPlayers[2].PlayerState == PlayerState.Offline) if (_dataModel.DivisionPlayers[2].PlayerState == PlayerState.Offline)
_p3.Colors = new List<Color> {Color.Gray, Color.White}; _p3.Colors = new List<Color> {Color.Gray, Color.White};
else if (_dataModel.DivisionPlayers[2].PlayerState == PlayerState.Online) else if (_dataModel.DivisionPlayers[2].PlayerState == PlayerState.Online)
_p3.Colors = new List<Color> { Color.FromArgb(10, 255, 0), Color.FromArgb(80, 255, 45) }; _p3.Colors = new List<Color> { Color.FromArgb(10, 255, 0), Color.FromArgb(80, 255, 45) };
else else
_p3.Colors = new List<Color> {Color.Red, Color.Orange}; _p3.Colors = new List<Color> {Color.Red, Color.Orange};
if (_dataModel.DivisionPlayers[3].PlayerState == PlayerState.Offline) if (_dataModel.DivisionPlayers[3].PlayerState == PlayerState.Offline)
_p4.Colors = new List<Color> {Color.Gray, Color.White}; _p4.Colors = new List<Color> {Color.Gray, Color.White};
else if (_dataModel.DivisionPlayers[3].PlayerState == PlayerState.Online) else if (_dataModel.DivisionPlayers[3].PlayerState == PlayerState.Online)
_p4.Colors = new List<Color> { Color.FromArgb(10, 255, 0), Color.FromArgb(80, 255, 45) }; _p4.Colors = new List<Color> { Color.FromArgb(10, 255, 0), Color.FromArgb(80, 255, 45) };
else else
_p4.Colors = new List<Color> {Color.Red, Color.Orange}; _p4.Colors = new List<Color> {Color.Red, Color.Orange};
if (!_dataModel.LowAmmo) if (!_dataModel.LowAmmo)
{ {
foreach (var corsairLed in CueSDK.MouseSDK.Leds) foreach (var corsairLed in CueSDK.MouseSDK.Leds)
corsairLed.Color = Color.Green; corsairLed.Color = Color.Green;
} }
else else
{ {
foreach (var corsairLed in CueSDK.MouseSDK.Leds) foreach (var corsairLed in CueSDK.MouseSDK.Leds)
corsairLed.Color = Color.Red; corsairLed.Color = Color.Red;
} }
CueSDK.MouseSDK.Update(); CueSDK.MouseSDK.Update();
} }
public override Bitmap GenerateBitmap() public override Bitmap GenerateBitmap()
{ {
var bitmap = MainManager.KeyboardManager.ActiveKeyboard.KeyboardBitmap(Scale); var bitmap = MainManager.KeyboardManager.ActiveKeyboard.KeyboardBitmap(Scale);
using (var g = Graphics.FromImage(bitmap)) using (var g = Graphics.FromImage(bitmap))
{ {
g.Clear(Color.Transparent); g.Clear(Color.Transparent);
_hpRect.Draw(g); _hpRect.Draw(g);
_p2.Draw(g); _p2.Draw(g);
_p3.Draw(g); _p3.Draw(g);
_p4.Draw(g); _p4.Draw(g);
// Very, very PH // Very, very PH
if (_ammoWave.Size != 0) if (_ammoWave.Size != 0)
{ {
var path = new GraphicsPath(); var path = new GraphicsPath();
path.AddEllipse(_ammoWave.Point.X - _ammoWave.Size/2, _ammoWave.Point.Y - _ammoWave.Size/2, path.AddEllipse(_ammoWave.Point.X - _ammoWave.Size/2, _ammoWave.Point.Y - _ammoWave.Size/2,
_ammoWave.Size, _ammoWave.Size); _ammoWave.Size, _ammoWave.Size);
if (_ammoWave.Size > 15) if (_ammoWave.Size > 15)
_trans = _trans - 16; _trans = _trans - 16;
if (_trans < 1) if (_trans < 1)
_trans = 255; _trans = 255;
var pthGrBrush = new PathGradientBrush(path) var pthGrBrush = new PathGradientBrush(path)
{ {
SurroundColors = new[] {_ammoWave.Color}, SurroundColors = new[] {_ammoWave.Color},
CenterColor = Color.FromArgb(_trans, 255, 0, 0) CenterColor = Color.FromArgb(_trans, 255, 0, 0)
}; };
g.FillPath(pthGrBrush, path); g.FillPath(pthGrBrush, path);
pthGrBrush.FocusScales = new PointF(0.3f, 0.8f); pthGrBrush.FocusScales = new PointF(0.3f, 0.8f);
g.FillPath(pthGrBrush, path); g.FillPath(pthGrBrush, path);
g.DrawEllipse(new Pen(pthGrBrush, 1), _ammoWave.Point.X - _ammoWave.Size/2, g.DrawEllipse(new Pen(pthGrBrush, 1), _ammoWave.Point.X - _ammoWave.Size/2,
_ammoWave.Point.Y - _ammoWave.Size/2, _ammoWave.Size, _ammoWave.Size); _ammoWave.Point.Y - _ammoWave.Size/2, _ammoWave.Size, _ammoWave.Size);
} }
} }
return bitmap; return bitmap;
} }
} }
} }

56
Artemis/Artemis/Modules/Games/TheDivision/TheDivisionSettings.cs
View File

@ -1,29 +1,29 @@
using Artemis.Models; using Artemis.Models;
namespace Artemis.Modules.Games.TheDivision namespace Artemis.Modules.Games.TheDivision
{ {
public class TheDivisionSettings : GameSettings public class TheDivisionSettings : GameSettings
{ {
public TheDivisionSettings() public TheDivisionSettings()
{ {
Load(); Load();
} }
public sealed override void Load() public sealed override void Load()
{ {
Enabled = TheDivision.Default.Enabled; Enabled = TheDivision.Default.Enabled;
} }
public sealed override void Save() public sealed override void Save()
{ {
TheDivision.Default.Enabled = Enabled; TheDivision.Default.Enabled = Enabled;
TheDivision.Default.Save(); TheDivision.Default.Save();
} }
public sealed override void ToDefault() public sealed override void ToDefault()
{ {
Enabled = true; Enabled = true;
} }
} }
} }

42
Artemis/Artemis/Modules/Games/TheDivision/TheDivisionViewModel.cs
View File

@ -1,22 +1,22 @@
using Artemis.Managers; using Artemis.Managers;
using Artemis.ViewModels.Abstract; using Artemis.ViewModels.Abstract;
namespace Artemis.Modules.Games.TheDivision namespace Artemis.Modules.Games.TheDivision
{ {
public class TheDivisionViewModel : GameViewModel public class TheDivisionViewModel : GameViewModel
{ {
public TheDivisionViewModel(MainManager mainManager) public TheDivisionViewModel(MainManager mainManager)
{ {
MainManager = mainManager; MainManager = mainManager;
// Settings are loaded from file by class // Settings are loaded from file by class
GameSettings = new TheDivisionSettings(); GameSettings = new TheDivisionSettings();
// Create effect model and add it to MainManager // Create effect model and add it to MainManager
GameModel = new TheDivisionModel(mainManager, (TheDivisionSettings) GameSettings); GameModel = new TheDivisionModel(mainManager, (TheDivisionSettings) GameSettings);
MainManager.EffectManager.EffectModels.Add(GameModel); MainManager.EffectManager.EffectModels.Add(GameModel);
} }
public static string Name => "The Division"; public static string Name => "The Division";
} }
} }

240
Artemis/Artemis/Modules/Games/Witcher3/Witcher3Model.cs
View File

@ -1,121 +1,121 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics; using System.Diagnostics;
using System.Drawing; using System.Drawing;
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using System.IO; using System.IO;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Models; using Artemis.Models;
using Artemis.Utilities.Keyboard; using Artemis.Utilities.Keyboard;
namespace Artemis.Modules.Games.Witcher3 namespace Artemis.Modules.Games.Witcher3
{ {
public class Witcher3Model : GameModel public class Witcher3Model : GameModel
{ {
private readonly Regex _signRegex; private readonly Regex _signRegex;
private readonly Stopwatch _updateSw; private readonly Stopwatch _updateSw;
private KeyboardRectangle _signRect; private KeyboardRectangle _signRect;
private string _witcherSettings; private string _witcherSettings;
public Witcher3Model(MainManager mainManager, Witcher3Settings settings) : base(mainManager) public Witcher3Model(MainManager mainManager, Witcher3Settings settings) : base(mainManager)
{ {
Settings = settings; Settings = settings;
Name = "Witcher3"; Name = "Witcher3";
ProcessName = "witcher3"; ProcessName = "witcher3";
Scale = 4; Scale = 4;
Enabled = Settings.Enabled; Enabled = Settings.Enabled;
Initialized = false; Initialized = false;
_updateSw = new Stopwatch(); _updateSw = new Stopwatch();
_signRegex = new Regex("ActiveSign=(.*)", RegexOptions.Compiled); _signRegex = new Regex("ActiveSign=(.*)", RegexOptions.Compiled);
} }
public Witcher3Settings Settings { get; set; } public Witcher3Settings Settings { get; set; }
public int Scale { get; set; } public int Scale { get; set; }
public override void Dispose() public override void Dispose()
{ {
Initialized = false; Initialized = false;
_witcherSettings = null; _witcherSettings = null;
_updateSw.Reset(); _updateSw.Reset();
} }
public override void Enable() public override void Enable()
{ {
Initialized = false; Initialized = false;
_signRect = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0, 0, new List<Color>(), _signRect = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0, 0, new List<Color>(),
LinearGradientMode.Horizontal) LinearGradientMode.Horizontal)
{ {
Rotate = true, Rotate = true,
LoopSpeed = 0.5 LoopSpeed = 0.5
}; };
// Ensure the config file is found // Ensure the config file is found
var witcherSettings = Environment.GetFolderPath(Environment.SpecialFolder.Personal) + var witcherSettings = Environment.GetFolderPath(Environment.SpecialFolder.Personal) +
@"\The Witcher 3\user.settings"; @"\The Witcher 3\user.settings";
if (File.Exists(witcherSettings)) if (File.Exists(witcherSettings))
_witcherSettings = witcherSettings; _witcherSettings = witcherSettings;
_updateSw.Start(); _updateSw.Start();
Initialized = true; Initialized = true;
} }
public override void Update() public override void Update()
{ {
// Witcher effect is very static and reads from disk, don't want to update too often. // Witcher effect is very static and reads from disk, don't want to update too often.
if (_updateSw.ElapsedMilliseconds < 500) if (_updateSw.ElapsedMilliseconds < 500)
return; return;
_updateSw.Restart(); _updateSw.Restart();
if (_witcherSettings == null) if (_witcherSettings == null)
return; return;
var reader = new StreamReader(File.Open(_witcherSettings, var reader = new StreamReader(File.Open(_witcherSettings,
FileMode.Open, FileMode.Open,
FileAccess.Read, FileAccess.Read,
FileShare.ReadWrite)); FileShare.ReadWrite));
var configContent = reader.ReadToEnd(); var configContent = reader.ReadToEnd();
reader.Close(); reader.Close();
var signRes = _signRegex.Match(configContent); var signRes = _signRegex.Match(configContent);
if (signRes.Groups.Count < 2) if (signRes.Groups.Count < 2)
return; return;
var sign = signRes.Groups[1].Value; var sign = signRes.Groups[1].Value;
switch (sign) switch (sign)
{ {
case "ST_Aard\r": case "ST_Aard\r":
_signRect.Colors = new List<Color> {Color.DeepSkyBlue, Color.Blue}; _signRect.Colors = new List<Color> {Color.DeepSkyBlue, Color.Blue};
break; break;
case "ST_Yrden\r": case "ST_Yrden\r":
_signRect.Colors = new List<Color> {Color.Purple, Color.DeepPink}; _signRect.Colors = new List<Color> {Color.Purple, Color.DeepPink};
break; break;
case "ST_Igni\r": case "ST_Igni\r":
_signRect.Colors = new List<Color> {Color.DarkOrange, Color.Red}; _signRect.Colors = new List<Color> {Color.DarkOrange, Color.Red};
break; break;
case "ST_Quen\r": case "ST_Quen\r":
_signRect.Colors = new List<Color> {Color.DarkOrange, Color.FromArgb(232, 193, 0)}; _signRect.Colors = new List<Color> {Color.DarkOrange, Color.FromArgb(232, 193, 0)};
break; break;
case "ST_Axii\r": case "ST_Axii\r":
_signRect.Colors = new List<Color> {Color.LawnGreen, Color.DarkGreen}; _signRect.Colors = new List<Color> {Color.LawnGreen, Color.DarkGreen};
break; break;
} }
} }
public override Bitmap GenerateBitmap() public override Bitmap GenerateBitmap()
{ {
var bitmap = MainManager.KeyboardManager.ActiveKeyboard.KeyboardBitmap(Scale); var bitmap = MainManager.KeyboardManager.ActiveKeyboard.KeyboardBitmap(Scale);
using (var g = Graphics.FromImage(bitmap)) using (var g = Graphics.FromImage(bitmap))
{ {
g.Clear(Color.Transparent); g.Clear(Color.Transparent);
_signRect.Draw(g); _signRect.Draw(g);
} }
return bitmap; return bitmap;
} }
} }
} }

56
Artemis/Artemis/Modules/Games/Witcher3/Witcher3Settings.cs
View File

@ -1,29 +1,29 @@
using Artemis.Models; using Artemis.Models;
namespace Artemis.Modules.Games.Witcher3 namespace Artemis.Modules.Games.Witcher3
{ {
public class Witcher3Settings : GameSettings public class Witcher3Settings : GameSettings
{ {
public Witcher3Settings() public Witcher3Settings()
{ {
Load(); Load();
} }
public sealed override void Load() public sealed override void Load()
{ {
Enabled = Witcher3.Default.Enabled; Enabled = Witcher3.Default.Enabled;
} }
public sealed override void Save() public sealed override void Save()
{ {
Witcher3.Default.Enabled = Enabled; Witcher3.Default.Enabled = Enabled;
Witcher3.Default.Save(); Witcher3.Default.Save();
} }
public sealed override void ToDefault() public sealed override void ToDefault()
{ {
Enabled = true; Enabled = true;
} }
} }
} }

28
Artemis/Artemis/Modules/Games/Witcher3/Witcher3View.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Modules.Games.Witcher3 namespace Artemis.Modules.Games.Witcher3
{ {
/// <summary> /// <summary>
/// Interaction logic for Witcher3View.xaml /// Interaction logic for Witcher3View.xaml
/// </summary> /// </summary>
public partial class Witcher3View : UserControl public partial class Witcher3View : UserControl
{ {
public Witcher3View() public Witcher3View()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

222
Artemis/Artemis/Modules/Games/Witcher3/Witcher3ViewModel.cs
View File

@ -1,112 +1,112 @@
using System; using System;
using System.Diagnostics; using System.Diagnostics;
using System.IO; using System.IO;
using System.Linq; using System.Linq;
using System.Windows.Forms; using System.Windows.Forms;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Properties; using Artemis.Properties;
using Artemis.ViewModels.Abstract; using Artemis.ViewModels.Abstract;
namespace Artemis.Modules.Games.Witcher3 namespace Artemis.Modules.Games.Witcher3
{ {
public class Witcher3ViewModel : GameViewModel public class Witcher3ViewModel : GameViewModel
{ {
public Witcher3ViewModel(MainManager mainManager) public Witcher3ViewModel(MainManager mainManager)
{ {
MainManager = mainManager; MainManager = mainManager;
// Settings are loaded from file by class // Settings are loaded from file by class
GameSettings = new Witcher3Settings(); GameSettings = new Witcher3Settings();
// Create effect model and add it to MainManager // Create effect model and add it to MainManager
GameModel = new Witcher3Model(mainManager, (Witcher3Settings) GameSettings); GameModel = new Witcher3Model(mainManager, (Witcher3Settings) GameSettings);
MainManager.EffectManager.EffectModels.Add(GameModel); MainManager.EffectManager.EffectModels.Add(GameModel);
} }
public static string Name => "The Witcher 3"; public static string Name => "The Witcher 3";
public async void AutoInstall() public async void AutoInstall()
{ {
// Request The Witcher 3 folder // Request The Witcher 3 folder
var dialog = new FolderBrowserDialog var dialog = new FolderBrowserDialog
{ {
Description = "Please select your Witcher 3 install path (root directory)." Description = "Please select your Witcher 3 install path (root directory)."
}; };
var result = dialog.ShowDialog(); var result = dialog.ShowDialog();
if (result != DialogResult.OK) if (result != DialogResult.OK)
return; return;
// If the subfolder doesn't contain witcher3.exe, it's the wrong folder. // If the subfolder doesn't contain witcher3.exe, it's the wrong folder.
if (!File.Exists(dialog.SelectedPath + @"\bin\x64\witcher3.exe")) if (!File.Exists(dialog.SelectedPath + @"\bin\x64\witcher3.exe"))
{ {
var retry = await var retry = await
MainManager.DialogService.ShowQuestionMessageBox("Installation error", MainManager.DialogService.ShowQuestionMessageBox("Installation error",
"That's not a valid Witcher 3 directory\n\n" + "That's not a valid Witcher 3 directory\n\n" +
"Default directories:\n" + "Default directories:\n" +
"Steam: \\SteamApps\\common\\The Witcher 3\n" + "Steam: \\SteamApps\\common\\The Witcher 3\n" +
"GOG: C:\\GOG Games\\The Witcher 3 Wild Hunt\n\n" + "GOG: C:\\GOG Games\\The Witcher 3 Wild Hunt\n\n" +
"Retry?"); "Retry?");
if (retry.Value) if (retry.Value)
AutoInstall(); AutoInstall();
return; return;
} }
// Look for any conflicting mods // Look for any conflicting mods
if (Directory.Exists(dialog.SelectedPath + @"\mods")) if (Directory.Exists(dialog.SelectedPath + @"\mods"))
{ {
var file = var file =
Directory.GetFiles(dialog.SelectedPath + @"\mods", "playerWitcher.ws", SearchOption.AllDirectories) Directory.GetFiles(dialog.SelectedPath + @"\mods", "playerWitcher.ws", SearchOption.AllDirectories)
.FirstOrDefault(); .FirstOrDefault();
if (file != null) if (file != null)
{ {
// Don't trip over our own mod // Don't trip over our own mod
if (!file.Contains("modArtemis")) if (!file.Contains("modArtemis"))
{ {
var viewHelp = await var viewHelp = await
MainManager.DialogService.ShowQuestionMessageBox("Conflicting mod found", MainManager.DialogService.ShowQuestionMessageBox("Conflicting mod found",
"Oh no, you have a conflicting mod!\n\n" + "Oh no, you have a conflicting mod!\n\n" +
"Conflicting file: " + file.Remove(0, dialog.SelectedPath.Length) + "Conflicting file: " + file.Remove(0, dialog.SelectedPath.Length) +
"\n\nWould you like to view instructions on how to manually install the mod?"); "\n\nWould you like to view instructions on how to manually install the mod?");
if (!viewHelp.Value) if (!viewHelp.Value)
return; return;
// Put the mod in the documents folder instead // Put the mod in the documents folder instead
// Create the directory structure // Create the directory structure
var folder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + @"\Artemis"; var folder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + @"\Artemis";
if ( if (
!Directory.Exists(folder + @"\Witcher3\mods\modArtemis\content\scripts\game\player")) !Directory.Exists(folder + @"\Witcher3\mods\modArtemis\content\scripts\game\player"))
Directory.CreateDirectory(folder + Directory.CreateDirectory(folder +
@"\Witcher3\mods\modArtemis\content\scripts\game\player"); @"\Witcher3\mods\modArtemis\content\scripts\game\player");
if ( if (
!Directory.Exists(folder + @"\Witcher3\bin\config\r4game\user_config_matrix\pc")) !Directory.Exists(folder + @"\Witcher3\bin\config\r4game\user_config_matrix\pc"))
Directory.CreateDirectory(folder + @"\Witcher3\bin\config\r4game\user_config_matrix\pc"); Directory.CreateDirectory(folder + @"\Witcher3\bin\config\r4game\user_config_matrix\pc");
// Install the mod files // Install the mod files
File.WriteAllText(folder + @"\Witcher3\bin\config\r4game\user_config_matrix\pc\artemis.xml", File.WriteAllText(folder + @"\Witcher3\bin\config\r4game\user_config_matrix\pc\artemis.xml",
Resources.artemisXml); Resources.artemisXml);
File.WriteAllText( File.WriteAllText(
folder + @"\Witcher3\mods\modArtemis\content\scripts\game\player\playerWitcher.ws", folder + @"\Witcher3\mods\modArtemis\content\scripts\game\player\playerWitcher.ws",
Resources.playerWitcherWs); Resources.playerWitcherWs);
Process.Start(new ProcessStartInfo("https://github.com/SpoinkyNL/Artemis/wiki/The-Witcher-3")); Process.Start(new ProcessStartInfo("https://github.com/SpoinkyNL/Artemis/wiki/The-Witcher-3"));
return; return;
} }
} }
} }
// Create the directory structure // Create the directory structure
if (!Directory.Exists(dialog.SelectedPath + @"\mods\modArtemis\content\scripts\game\player")) if (!Directory.Exists(dialog.SelectedPath + @"\mods\modArtemis\content\scripts\game\player"))
Directory.CreateDirectory(dialog.SelectedPath + @"\mods\modArtemis\content\scripts\game\player"); Directory.CreateDirectory(dialog.SelectedPath + @"\mods\modArtemis\content\scripts\game\player");
if (!Directory.Exists(dialog.SelectedPath + @"\bin\config\r4game\user_config_matrix\pc")) if (!Directory.Exists(dialog.SelectedPath + @"\bin\config\r4game\user_config_matrix\pc"))
Directory.CreateDirectory(dialog.SelectedPath + @"\bin\config\r4game\user_config_matrix\pc"); Directory.CreateDirectory(dialog.SelectedPath + @"\bin\config\r4game\user_config_matrix\pc");
// Install the mod files // Install the mod files
File.WriteAllText(dialog.SelectedPath + @"\bin\config\r4game\user_config_matrix\pc\artemis.xml", File.WriteAllText(dialog.SelectedPath + @"\bin\config\r4game\user_config_matrix\pc\artemis.xml",
Resources.artemisXml); Resources.artemisXml);
File.WriteAllText(dialog.SelectedPath + @"\mods\modArtemis\content\scripts\game\player\playerWitcher.ws", File.WriteAllText(dialog.SelectedPath + @"\mods\modArtemis\content\scripts\game\player\playerWitcher.ws",
Resources.playerWitcherWs); Resources.playerWitcherWs);
MainManager.DialogService.ShowMessageBox("Success", "The mod was successfully installed!"); MainManager.DialogService.ShowMessageBox("Success", "The mod was successfully installed!");
} }
} }
} }

90
Artemis/Artemis/Modules/Overlays/VolumeDisplay/VolumeDisplay.cs
View File

@ -1,46 +1,46 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Drawing; using System.Drawing;
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Utilities; using Artemis.Utilities;
using Artemis.Utilities.Keyboard; using Artemis.Utilities.Keyboard;
namespace Artemis.Modules.Overlays.VolumeDisplay namespace Artemis.Modules.Overlays.VolumeDisplay
{ {
public class VolumeBar public class VolumeBar
{ {
public VolumeBar(MainManager mainManager, VolumeDisplaySettings settings) public VolumeBar(MainManager mainManager, VolumeDisplaySettings settings)
{ {
MainManager = mainManager; MainManager = mainManager;
Settings = settings; Settings = settings;
Transparancy = 255; Transparancy = 255;
Scale = 4; Scale = 4;
} }
public MainManager MainManager { get; set; } public MainManager MainManager { get; set; }
public VolumeDisplaySettings Settings { get; set; } public VolumeDisplaySettings Settings { get; set; }
public int Scale { get; set; } public int Scale { get; set; }
public int Ttl { get; set; } public int Ttl { get; set; }
public byte Transparancy { get; set; } public byte Transparancy { get; set; }
public int Volume { get; set; } public int Volume { get; set; }
public void Draw(Graphics g) public void Draw(Graphics g)
{ {
var volumeRect = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0, 0, new List<Color> var volumeRect = new KeyboardRectangle(MainManager.KeyboardManager.ActiveKeyboard, 0, 0, new List<Color>
{ {
ColorHelpers.ToDrawingColor(Settings.MainColor), ColorHelpers.ToDrawingColor(Settings.MainColor),
ColorHelpers.ToDrawingColor(Settings.SecondaryColor) ColorHelpers.ToDrawingColor(Settings.SecondaryColor)
}, },
LinearGradientMode.Horizontal) LinearGradientMode.Horizontal)
{ {
Width = (int) (MainManager.KeyboardManager.ActiveKeyboard.Width*Scale/100.00*Volume), Width = (int) (MainManager.KeyboardManager.ActiveKeyboard.Width*Scale/100.00*Volume),
ContainedBrush = false ContainedBrush = false
}; };
volumeRect.Draw(g); volumeRect.Draw(g);
} }
} }
} }

180
Artemis/Artemis/Modules/Overlays/VolumeDisplay/VolumeDisplayModel.cs
View File

@ -1,91 +1,91 @@
using System.Drawing; using System.Drawing;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Windows.Forms; using System.Windows.Forms;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Models; using Artemis.Models;
using NAudio.CoreAudioApi; using NAudio.CoreAudioApi;
namespace Artemis.Modules.Overlays.VolumeDisplay namespace Artemis.Modules.Overlays.VolumeDisplay
{ {
public class VolumeDisplayModel : OverlayModel public class VolumeDisplayModel : OverlayModel
{ {
public VolumeDisplayModel(MainManager mainManager, VolumeDisplaySettings settings) : base(mainManager) public VolumeDisplayModel(MainManager mainManager, VolumeDisplaySettings settings) : base(mainManager)
{ {
Settings = settings; Settings = settings;
Name = "VolumeDisplay"; Name = "VolumeDisplay";
Enabled = Settings.Enabled; Enabled = Settings.Enabled;
VolumeDisplay = new VolumeBar(mainManager, settings); VolumeDisplay = new VolumeBar(mainManager, settings);
} }
public VolumeBar VolumeDisplay { get; set; } public VolumeBar VolumeDisplay { get; set; }
public VolumeDisplaySettings Settings { get; set; } public VolumeDisplaySettings Settings { get; set; }
public override void Dispose() public override void Dispose()
{ {
MainManager.KeyboardHook.KeyDownCallback -= KeyPressTask; MainManager.KeyboardHook.KeyDownCallback -= KeyPressTask;
} }
public override void Enable() public override void Enable()
{ {
// Listener won't start unless the effect is active // Listener won't start unless the effect is active
MainManager.KeyboardHook.KeyDownCallback += KeyPressTask; MainManager.KeyboardHook.KeyDownCallback += KeyPressTask;
} }
public override void Update() public override void Update()
{ {
// TODO: Get from settings // TODO: Get from settings
var fps = 25; var fps = 25;
if (VolumeDisplay == null) if (VolumeDisplay == null)
return; return;
if (VolumeDisplay.Ttl < 1) if (VolumeDisplay.Ttl < 1)
return; return;
var decreaseAmount = 500/fps; var decreaseAmount = 500/fps;
VolumeDisplay.Ttl = VolumeDisplay.Ttl - decreaseAmount; VolumeDisplay.Ttl = VolumeDisplay.Ttl - decreaseAmount;
if (VolumeDisplay.Ttl < 128) if (VolumeDisplay.Ttl < 128)
VolumeDisplay.Transparancy = (byte) (VolumeDisplay.Transparancy - 20); VolumeDisplay.Transparancy = (byte) (VolumeDisplay.Transparancy - 20);
try try
{ {
var enumerator = new MMDeviceEnumerator(); var enumerator = new MMDeviceEnumerator();
var volumeFloat = var volumeFloat =
enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console) enumerator.GetDefaultAudioEndpoint(DataFlow.Render, Role.Console)
.AudioEndpointVolume.MasterVolumeLevelScalar; .AudioEndpointVolume.MasterVolumeLevelScalar;
VolumeDisplay.Volume = (int) (volumeFloat*100); VolumeDisplay.Volume = (int) (volumeFloat*100);
} }
catch (COMException) catch (COMException)
{ {
} }
} }
public override Bitmap GenerateBitmap() public override Bitmap GenerateBitmap()
{ {
return GenerateBitmap(MainManager.KeyboardManager.ActiveKeyboard.KeyboardBitmap(4)); return GenerateBitmap(MainManager.KeyboardManager.ActiveKeyboard.KeyboardBitmap(4));
} }
public override Bitmap GenerateBitmap(Bitmap bitmap) public override Bitmap GenerateBitmap(Bitmap bitmap)
{ {
if (VolumeDisplay == null) if (VolumeDisplay == null)
return bitmap; return bitmap;
if (VolumeDisplay.Ttl < 1) if (VolumeDisplay.Ttl < 1)
return bitmap; return bitmap;
using (var g = Graphics.FromImage(bitmap)) using (var g = Graphics.FromImage(bitmap))
VolumeDisplay.Draw(g); VolumeDisplay.Draw(g);
return bitmap; return bitmap;
} }
private void KeyPressTask(KeyEventArgs e) private void KeyPressTask(KeyEventArgs e)
{ {
if (e.KeyCode != Keys.VolumeUp && e.KeyCode != Keys.VolumeDown) if (e.KeyCode != Keys.VolumeUp && e.KeyCode != Keys.VolumeDown)
return; return;
VolumeDisplay.Ttl = 1000; VolumeDisplay.Ttl = 1000;
VolumeDisplay.Transparancy = 255; VolumeDisplay.Transparancy = 255;
} }
} }
} }

78
Artemis/Artemis/Modules/Overlays/VolumeDisplay/VolumeDisplaySettings.cs
View File

@ -1,40 +1,40 @@
using System.Windows.Media; using System.Windows.Media;
using Artemis.Models; using Artemis.Models;
namespace Artemis.Modules.Overlays.VolumeDisplay namespace Artemis.Modules.Overlays.VolumeDisplay
{ {
public class VolumeDisplaySettings : EffectSettings public class VolumeDisplaySettings : EffectSettings
{ {
public VolumeDisplaySettings() public VolumeDisplaySettings()
{ {
Load(); Load();
} }
public bool Enabled { get; set; } public bool Enabled { get; set; }
public Color MainColor { get; set; } public Color MainColor { get; set; }
public Color SecondaryColor { get; set; } public Color SecondaryColor { get; set; }
public sealed override void Load() public sealed override void Load()
{ {
Enabled = VolumeDisplay.Default.Enabled; Enabled = VolumeDisplay.Default.Enabled;
MainColor = VolumeDisplay.Default.MainColor; MainColor = VolumeDisplay.Default.MainColor;
SecondaryColor = VolumeDisplay.Default.SecondaryColor; SecondaryColor = VolumeDisplay.Default.SecondaryColor;
} }
public sealed override void Save() public sealed override void Save()
{ {
VolumeDisplay.Default.Enabled = Enabled; VolumeDisplay.Default.Enabled = Enabled;
VolumeDisplay.Default.MainColor = MainColor; VolumeDisplay.Default.MainColor = MainColor;
VolumeDisplay.Default.SecondaryColor = SecondaryColor; VolumeDisplay.Default.SecondaryColor = SecondaryColor;
VolumeDisplay.Default.Save(); VolumeDisplay.Default.Save();
} }
public sealed override void ToDefault() public sealed override void ToDefault()
{ {
Enabled = true; Enabled = true;
MainColor = Color.FromArgb(255, 38, 246, 0); MainColor = Color.FromArgb(255, 38, 246, 0);
SecondaryColor = Color.FromArgb(255, 255, 41, 0); SecondaryColor = Color.FromArgb(255, 255, 41, 0);
} }
} }
} }

28
Artemis/Artemis/Modules/Overlays/VolumeDisplay/VolumeDisplayView.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Modules.Overlays.VolumeDisplay namespace Artemis.Modules.Overlays.VolumeDisplay
{ {
/// <summary> /// <summary>
/// Interaction logic for MediaKeysDisplayView.xaml /// Interaction logic for MediaKeysDisplayView.xaml
/// </summary> /// </summary>
public partial class VolumeDisplayView : UserControl public partial class VolumeDisplayView : UserControl
{ {
public VolumeDisplayView() public VolumeDisplayView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

118
Artemis/Artemis/Modules/Overlays/VolumeDisplay/VolumeDisplayViewModel.cs
View File

@ -1,60 +1,60 @@
using Artemis.Managers; using Artemis.Managers;
using Caliburn.Micro; using Caliburn.Micro;
namespace Artemis.Modules.Overlays.VolumeDisplay namespace Artemis.Modules.Overlays.VolumeDisplay
{ {
public class VolumeDisplayViewModel : Screen public class VolumeDisplayViewModel : Screen
{ {
private VolumeDisplaySettings _volumeDisplaySettings; private VolumeDisplaySettings _volumeDisplaySettings;
public VolumeDisplayViewModel(MainManager mainManager) public VolumeDisplayViewModel(MainManager mainManager)
{ {
MainManager = mainManager; MainManager = mainManager;
// Settings are loaded from file by class // Settings are loaded from file by class
VolumeDisplaySettings = new VolumeDisplaySettings(); VolumeDisplaySettings = new VolumeDisplaySettings();
// Create effect model and add it to MainManager // Create effect model and add it to MainManager
VolumeDisplayModel = new VolumeDisplayModel(mainManager, VolumeDisplaySettings); VolumeDisplayModel = new VolumeDisplayModel(mainManager, VolumeDisplaySettings);
MainManager.EffectManager.EffectModels.Add(VolumeDisplayModel); MainManager.EffectManager.EffectModels.Add(VolumeDisplayModel);
} }
public static string Name => "Volume Display"; public static string Name => "Volume Display";
public MainManager MainManager { get; set; } public MainManager MainManager { get; set; }
public VolumeDisplayModel VolumeDisplayModel { get; set; } public VolumeDisplayModel VolumeDisplayModel { get; set; }
public VolumeDisplaySettings VolumeDisplaySettings public VolumeDisplaySettings VolumeDisplaySettings
{ {
get { return _volumeDisplaySettings; } get { return _volumeDisplaySettings; }
set set
{ {
if (Equals(value, _volumeDisplaySettings)) return; if (Equals(value, _volumeDisplaySettings)) return;
_volumeDisplaySettings = value; _volumeDisplaySettings = value;
NotifyOfPropertyChange(() => VolumeDisplaySettings); NotifyOfPropertyChange(() => VolumeDisplaySettings);
} }
} }
public void ToggleEffect() public void ToggleEffect()
{ {
VolumeDisplayModel.Enabled = _volumeDisplaySettings.Enabled; VolumeDisplayModel.Enabled = _volumeDisplaySettings.Enabled;
} }
public void SaveSettings() public void SaveSettings()
{ {
if (VolumeDisplayModel == null) if (VolumeDisplayModel == null)
return; return;
VolumeDisplaySettings.Save(); VolumeDisplaySettings.Save();
} }
public void ResetSettings() public void ResetSettings()
{ {
// TODO: Confirmation dialog (Generic MVVM approach) // TODO: Confirmation dialog (Generic MVVM approach)
VolumeDisplaySettings.ToDefault(); VolumeDisplaySettings.ToDefault();
NotifyOfPropertyChange(() => VolumeDisplaySettings); NotifyOfPropertyChange(() => VolumeDisplaySettings);
SaveSettings(); SaveSettings();
} }
} }
} }

2234
Artemis/Artemis/Properties/Annotations.cs
View File

File diff suppressed because it is too large Load Diff

110
Artemis/Artemis/Properties/AssemblyInfo.cs
View File

@ -1,56 +1,56 @@
using System.Reflection; using System.Reflection;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Windows; using System.Windows;
// General Information about an assembly is controlled through the following // General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information // set of attributes. Change these attribute values to modify the information
// associated with an assembly. // associated with an assembly.
[assembly: AssemblyTitle("Artemis")] [assembly: AssemblyTitle("Artemis")]
[assembly: AssemblyDescription("Adds third-party support for RGB keyboards to games")] [assembly: AssemblyDescription("Adds third-party support for RGB keyboards to games")]
[assembly: AssemblyConfiguration("")] [assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Artemis developers")] [assembly: AssemblyCompany("Artemis developers")]
[assembly: AssemblyProduct("Artemis")] [assembly: AssemblyProduct("Artemis")]
[assembly: AssemblyCopyright("Copyright © 2016")] [assembly: AssemblyCopyright("Copyright © 2016")]
[assembly: AssemblyTrademark("")] [assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")] [assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible // Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from // to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type. // COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)] [assembly: ComVisible(false)]
//In order to begin building localizable applications, set //In order to begin building localizable applications, set
//<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file //<UICulture>CultureYouAreCodingWith</UICulture> in your .csproj file
//inside a <PropertyGroup>. For example, if you are using US english //inside a <PropertyGroup>. For example, if you are using US english
//in your source files, set the <UICulture> to en-US. Then uncomment //in your source files, set the <UICulture> to en-US. Then uncomment
//the NeutralResourceLanguage attribute below. Update the "en-US" in //the NeutralResourceLanguage attribute below. Update the "en-US" in
//the line below to match the UICulture setting in the project file. //the line below to match the UICulture setting in the project file.
//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)] //[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
[assembly: ThemeInfo( [assembly: ThemeInfo(
ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
//(used if a resource is not found in the page, //(used if a resource is not found in the page,
// or application resource dictionaries) // or application resource dictionaries)
ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
//(used if a resource is not found in the page, //(used if a resource is not found in the page,
// app, or any theme specific resource dictionaries) // app, or any theme specific resource dictionaries)
)] )]
// Version information for an assembly consists of the following four values: // Version information for an assembly consists of the following four values:
// //
// Major Version // Major Version
// Minor Version // Minor Version
// Build Number // Build Number
// Revision // Revision
// //
// You can specify all the values or you can default the Build and Revision Numbers // You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below: // by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")] // [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")] [assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")] [assembly: AssemblyFileVersion("1.0.0.0")]

34
Artemis/Artemis/Resources/CounterStrike/csgoGamestateConfiguration.txt
View File

@ -1,18 +1,18 @@
"Artemis" "Artemis"
{ {
"uri" "http://localhost:{{port}}/csgo_game_event" "uri" "http://localhost:{{port}}/csgo_game_event"
"timeout" "5.0" "timeout" "5.0"
"buffer" "0.1" "buffer" "0.1"
"throttle" "0.1" "throttle" "0.1"
"heartbeat" "30.0" "heartbeat" "30.0"
"data" "data"
{ {
"provider" "1" "provider" "1"
"map" "1" "map" "1"
"round" "1" "round" "1"
"player_id" "1" "player_id" "1"
"player_state" "1" "player_state" "1"
"player_weapons" "1" "player_weapons" "1"
"player_match_stats" "1" "player_match_stats" "1"
} }
} }

4
Artemis/Artemis/Resources/Entypo-license.txt
View File

@ -1,3 +1,3 @@
Entypo (http://www.entypo.com/) is created by Daniel Bruce and released under the Creative Commons, Share Alike/Attribution license. Entypo (http://www.entypo.com/) is created by Daniel Bruce and released under the Creative Commons, Share Alike/Attribution license.
http://creativecommons.org/licenses/by-sa/3.0/ http://creativecommons.org/licenses/by-sa/3.0/

124
Artemis/Artemis/Resources/WindowsIcons-license.txt
View File

@ -1,62 +1,62 @@
# License # License
Please carefully understand the license and download the latest icons at ModernUIIcons.com. Please carefully understand the license and download the latest icons at ModernUIIcons.com.
## Understand Your Rights ## Understand Your Rights
No Attribution and No Derived Works No Attribution and No Derived Works
http://creativecommons.org/licenses/by-nd/3.0/ * http://creativecommons.org/licenses/by-nd/3.0/ *
- If your project is open source include this license file in the source. - If your project is open source include this license file in the source.
- Nothing is needed in the front facing project (UNLESS you - Nothing is needed in the front facing project (UNLESS you
are using any of the icons listed below in the attribution section). are using any of the icons listed below in the attribution section).
- Commercial use is not only allowed but encouraged. If it is an icon - Commercial use is not only allowed but encouraged. If it is an icon
in the attribution list below, you still need to attribute those! in the attribution list below, you still need to attribute those!
- Do not distribute the entire package (I've allowed this dozens of - Do not distribute the entire package (I've allowed this dozens of
times for open source projects, but email me first). times for open source projects, but email me first).
## Creator ## Creator
- Austin Andrews (@templarian) - Austin Andrews (@templarian)
## Contributor** ## Contributor**
- Jay Zawrotny (@JayZawrotny) - Jay Zawrotny (@JayZawrotny)
- A Bunch - A Bunch
- Oren Nachman - Oren Nachman
- appbar.chevron.down - appbar.chevron.down
- appbar.chevron.up - appbar.chevron.up
- appbar.chevron.left - appbar.chevron.left
- appbar.chevron.right - appbar.chevron.right
## Derived Works ## Derived Works
- Alex Peattie - Alex Peattie
- Social: http://www.alexpeattie.com/projects/justvector_icons/ - Social: http://www.alexpeattie.com/projects/justvector_icons/
## Attribution*** ## Attribution***
- Kris Vandermotten (@kvandermotten) - Kris Vandermotten (@kvandermotten)
- appbar.medical.pulse - appbar.medical.pulse
- Constantin Kichinsky (@kichinsky) - Constantin Kichinsky (@kichinsky)
- appbar.currency.rubles - appbar.currency.rubles
- appbar.currency.grivna - appbar.currency.grivna
- Massimo Savazzi (@msavazzi) - Massimo Savazzi (@msavazzi)
- List of missing exported icons - List of missing exported icons
- Proletkult Graphik, from The Noun Project - Proletkult Graphik, from The Noun Project
- appbar.draw.pen (inspired) - appbar.draw.pen (inspired)
- Olivier Guin, from The Noun Project - Olivier Guin, from The Noun Project
- appbar.draw.marker - appbar.draw.marker
- Gibran Bisio, from The Noun Project - Gibran Bisio, from The Noun Project
- appbar.draw.bucket - appbar.draw.bucket
Andrew Forrester, from The Noun Project Andrew Forrester, from The Noun Project
- appbar.fingerprint - appbar.fingerprint
* The license is for attribution, but this is not required. * The license is for attribution, but this is not required.
** Developers and designers that emailed Templarian the source .design icons to be added into the package. PNGs also accepted, but may take longer to be added. ** Developers and designers that emailed Templarian the source .design icons to be added into the package. PNGs also accepted, but may take longer to be added.
*** Icons I've copied so closely you want to attribute them and are also under the CC license. *** Icons I've copied so closely you want to attribute them and are also under the CC license.
Contact Contact
- http://templarian.com/ - http://templarian.com/
- admin[@]templarian[.]com - admin[@]templarian[.]com
* Does not apply to copyrighted logos * Does not apply to copyrighted logos
- Skype - Skype
- Facebook - Facebook
- Twitter - Twitter
- etc... - etc...

16
Artemis/Artemis/Resources/Witcher3/artemis.txt
View File

@ -1,9 +1,9 @@
<?xml version="1.0" encoding="UTF-16"?> <?xml version="1.0" encoding="UTF-16"?>
<!-- Used by Artemis to get the active Sign --> <!-- Used by Artemis to get the active Sign -->
<UserConfig> <UserConfig>
<Group id="Artemis" displayName="Artemis"> <Group id="Artemis" displayName="Artemis">
<VisibleVars> <VisibleVars>
<Var id="ActiveSign" displayName="ActiveSign" displayType="SLIDER:0:1:1000000"/> <Var id="ActiveSign" displayName="ActiveSign" displayType="SLIDER:0:1:1000000"/>
</VisibleVars> </VisibleVars>
</Group> </Group>
</UserConfig> </UserConfig>

198
Artemis/Artemis/Settings/GeneralSettings.cs
View File

@ -1,100 +1,100 @@
using System; using System;
using System.IO; using System.IO;
using System.Reflection; using System.Reflection;
using System.Runtime.InteropServices.ComTypes; using System.Runtime.InteropServices.ComTypes;
using Artemis.Utilities; using Artemis.Utilities;
namespace Artemis.Settings namespace Artemis.Settings
{ {
public class GeneralSettings public class GeneralSettings
{ {
public int GamestatePort public int GamestatePort
{ {
get { return General.Default.GamestatePort; } get { return General.Default.GamestatePort; }
set set
{ {
if (General.Default.GamestatePort == value) return; if (General.Default.GamestatePort == value) return;
General.Default.GamestatePort = value; General.Default.GamestatePort = value;
} }
} }
public bool EnablePointersUpdate public bool EnablePointersUpdate
{ {
get { return General.Default.EnablePointersUpdate; } get { return General.Default.EnablePointersUpdate; }
set set
{ {
if (General.Default.EnablePointersUpdate == value) return; if (General.Default.EnablePointersUpdate == value) return;
General.Default.EnablePointersUpdate = value; General.Default.EnablePointersUpdate = value;
} }
} }
public bool Autorun public bool Autorun
{ {
get { return General.Default.Autorun; } get { return General.Default.Autorun; }
set set
{ {
if (General.Default.Autorun == value) return; if (General.Default.Autorun == value) return;
General.Default.Autorun = value; General.Default.Autorun = value;
} }
} }
public bool CheckForUpdates public bool CheckForUpdates
{ {
get { return General.Default.CheckForUpdates; } get { return General.Default.CheckForUpdates; }
set set
{ {
if (General.Default.CheckForUpdates == value) return; if (General.Default.CheckForUpdates == value) return;
General.Default.CheckForUpdates = value; General.Default.CheckForUpdates = value;
} }
} }
public bool ShowOnStartup public bool ShowOnStartup
{ {
get { return General.Default.ShowOnStartup; } get { return General.Default.ShowOnStartup; }
set set
{ {
if (General.Default.ShowOnStartup == value) return; if (General.Default.ShowOnStartup == value) return;
General.Default.ShowOnStartup = value; General.Default.ShowOnStartup = value;
} }
} }
private void ApplyGamestatePort() private void ApplyGamestatePort()
{ {
// TODO: Restart Gamestate server with new port // TODO: Restart Gamestate server with new port
} }
private void ApplyAutorun() private void ApplyAutorun()
{ {
var startupFolder = Environment.GetFolderPath(Environment.SpecialFolder.Startup); var startupFolder = Environment.GetFolderPath(Environment.SpecialFolder.Startup);
if (Autorun) if (Autorun)
{ {
var link = (IShellLink) new ShellLink(); var link = (IShellLink) new ShellLink();
link.SetPath(Assembly.GetExecutingAssembly().Location); link.SetPath(Assembly.GetExecutingAssembly().Location);
var file = (IPersistFile) link; var file = (IPersistFile) link;
file.Save(startupFolder + @"\Artemis.lnk", false); file.Save(startupFolder + @"\Artemis.lnk", false);
} }
else if (File.Exists(startupFolder + @"\Artemis.lnk")) else if (File.Exists(startupFolder + @"\Artemis.lnk"))
File.Delete(startupFolder + @"\Artemis.lnk"); File.Delete(startupFolder + @"\Artemis.lnk");
} }
public void SaveSettings() public void SaveSettings()
{ {
General.Default.Save(); General.Default.Save();
ApplyAutorun(); ApplyAutorun();
ApplyGamestatePort(); ApplyGamestatePort();
} }
public void ResetSettings() public void ResetSettings()
{ {
GamestatePort = 51364; GamestatePort = 51364;
EnablePointersUpdate = true; EnablePointersUpdate = true;
Autorun = true; Autorun = true;
CheckForUpdates = true; CheckForUpdates = true;
ShowOnStartup = true; ShowOnStartup = true;
SaveSettings(); SaveSettings();
} }
} }
} }

104
Artemis/Artemis/Settings/Offsets.Designer.cs generated
View File

@ -1,52 +1,52 @@
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// <auto-generated> // <auto-generated>
// This code was generated by a tool. // This code was generated by a tool.
// Runtime Version:4.0.30319.42000 // Runtime Version:4.0.30319.42000
// //
// Changes to this file may cause incorrect behavior and will be lost if // Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated. // the code is regenerated.
// </auto-generated> // </auto-generated>
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
namespace Artemis.Settings { namespace Artemis.Settings {
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
[global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "14.0.0.0")] [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "14.0.0.0")]
internal sealed partial class Offsets : global::System.Configuration.ApplicationSettingsBase { internal sealed partial class Offsets : global::System.Configuration.ApplicationSettingsBase {
private static Offsets defaultInstance = ((Offsets)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Offsets()))); private static Offsets defaultInstance = ((Offsets)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Offsets())));
public static Offsets Default { public static Offsets Default {
get { get {
return defaultInstance; return defaultInstance;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("{\"Game\":\"RocketLeague\",\"GameVersion\":\"1.10\",\"GameAddresses\":[{\"Description\":\"Boos" + [global::System.Configuration.DefaultSettingValueAttribute("{\"Game\":\"RocketLeague\",\"GameVersion\":\"1.10\",\"GameAddresses\":[{\"Description\":\"Boos" +
"t\",\"BasePointer\":{\"value\":21998084},\"Offsets\":[88,1452,1780,540]}]}")] "t\",\"BasePointer\":{\"value\":21998084},\"Offsets\":[88,1452,1780,540]}]}")]
public string RocketLeague { public string RocketLeague {
get { get {
return ((string)(this["RocketLeague"])); return ((string)(this["RocketLeague"]));
} }
set { set {
this["RocketLeague"] = value; this["RocketLeague"] = value;
} }
} }
[global::System.Configuration.UserScopedSettingAttribute()] [global::System.Configuration.UserScopedSettingAttribute()]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()] [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Configuration.DefaultSettingValueAttribute("{\"Game\":\"Witcher3\",\"GameVersion\":\"1.11\",\"GameAddresses\":[{\"Description\":\"Sign\",\"B" + [global::System.Configuration.DefaultSettingValueAttribute("{\"Game\":\"Witcher3\",\"GameVersion\":\"1.11\",\"GameAddresses\":[{\"Description\":\"Sign\",\"B" +
"asePointer\":{\"value\":42942304},\"Offsets\":[40,16,32,3008]}]}")] "asePointer\":{\"value\":42942304},\"Offsets\":[40,16,32,3008]}]}")]
public string Witcher3 { public string Witcher3 {
get { get {
return ((string)(this["Witcher3"])); return ((string)(this["Witcher3"]));
} }
set { set {
this["Witcher3"] = value; this["Witcher3"] = value;
} }
} }
} }
} }

164
Artemis/Artemis/Utilities/ColorHelpers.cs
View File

@ -1,83 +1,83 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Drawing; using System.Drawing;
using System.Linq; using System.Linq;
namespace Artemis.Utilities namespace Artemis.Utilities
{ {
public static class ColorHelpers public static class ColorHelpers
{ {
/// <summary> /// <summary>
/// Comes up with a 'pure' psuedo-random color /// Comes up with a 'pure' psuedo-random color
/// </summary> /// </summary>
/// <returns>The color</returns> /// <returns>The color</returns>
public static Color GetRandomRainbowColor() public static Color GetRandomRainbowColor()
{ {
var colors = new List<int>(); var colors = new List<int>();
var rand = new Random(); var rand = new Random();
for (var i = 0; i < 3; i++) for (var i = 0; i < 3; i++)
colors.Add(rand.Next(0, 256)); colors.Add(rand.Next(0, 256));
var highest = colors.Max(); var highest = colors.Max();
var lowest = colors.Min(); var lowest = colors.Min();
colors[colors.FindIndex(c => c == highest)] = 255; colors[colors.FindIndex(c => c == highest)] = 255;
colors[colors.FindIndex(c => c == lowest)] = 0; colors[colors.FindIndex(c => c == lowest)] = 0;
var returnColor = Color.FromArgb(255, colors[0], colors[1], colors[2]); var returnColor = Color.FromArgb(255, colors[0], colors[1], colors[2]);
return returnColor; return returnColor;
} }
public static Color ShiftColor(Color c, int shiftAmount) public static Color ShiftColor(Color c, int shiftAmount)
{ {
int newRed = c.R; int newRed = c.R;
int newGreen = c.G; int newGreen = c.G;
int newBlue = c.B; int newBlue = c.B;
// Red to purple // Red to purple
if (c.R == 255 && c.B < 255 && c.G == 0) if (c.R == 255 && c.B < 255 && c.G == 0)
newBlue = newBlue + shiftAmount; newBlue = newBlue + shiftAmount;
// Purple to blue // Purple to blue
else if (c.B == 255 && c.R > 0) else if (c.B == 255 && c.R > 0)
newRed = newRed - shiftAmount; newRed = newRed - shiftAmount;
// Blue to light-blue // Blue to light-blue
else if (c.B == 255 && c.G < 255) else if (c.B == 255 && c.G < 255)
newGreen = newGreen + shiftAmount; newGreen = newGreen + shiftAmount;
// Light-blue to green // Light-blue to green
else if (c.G == 255 && c.B > 0) else if (c.G == 255 && c.B > 0)
newBlue = newBlue - shiftAmount; newBlue = newBlue - shiftAmount;
// Green to yellow // Green to yellow
else if (c.G == 255 && c.R < 255) else if (c.G == 255 && c.R < 255)
newRed = newRed + shiftAmount; newRed = newRed + shiftAmount;
// Yellow to red // Yellow to red
else if (c.R == 255 && c.G > 0) else if (c.R == 255 && c.G > 0)
newGreen = newGreen - shiftAmount; newGreen = newGreen - shiftAmount;
newRed = BringIntInColorRange(newRed); newRed = BringIntInColorRange(newRed);
newGreen = BringIntInColorRange(newGreen); newGreen = BringIntInColorRange(newGreen);
newBlue = BringIntInColorRange(newBlue); newBlue = BringIntInColorRange(newBlue);
return Color.FromArgb(c.A, newRed, newGreen, newBlue); return Color.FromArgb(c.A, newRed, newGreen, newBlue);
} }
private static int BringIntInColorRange(int i) private static int BringIntInColorRange(int i)
{ {
if (i < 0) if (i < 0)
return 0; return 0;
if (i > 255) if (i > 255)
return 255; return 255;
return i; return i;
} }
public static Color ToDrawingColor(System.Windows.Media.Color mColor) public static Color ToDrawingColor(System.Windows.Media.Color mColor)
{ {
return Color.FromArgb(mColor.A, mColor.R, mColor.G, mColor.B); return Color.FromArgb(mColor.A, mColor.R, mColor.G, mColor.B);
} }
public static System.Windows.Media.Color ToMediaColor(Color dColor) public static System.Windows.Media.Color ToMediaColor(Color dColor)
{ {
return System.Windows.Media.Color.FromArgb(dColor.A, dColor.R, dColor.G, dColor.B); return System.Windows.Media.Color.FromArgb(dColor.A, dColor.R, dColor.G, dColor.B);
} }
} }
} }

26
Artemis/Artemis/Utilities/GameState/GameDataReceivedEventArgs.cs
View File

@ -1,14 +1,14 @@
using System; using System;
namespace Artemis.Utilities.GameState namespace Artemis.Utilities.GameState
{ {
public class GameDataReceivedEventArgs : EventArgs public class GameDataReceivedEventArgs : EventArgs
{ {
public GameDataReceivedEventArgs(object json) public GameDataReceivedEventArgs(object json)
{ {
Json = json; Json = json;
} }
public object Json { get; set; } public object Json { get; set; }
} }
} }

12
Artemis/Artemis/Utilities/GeneralHelpers.cs
View File

@ -37,12 +37,12 @@ namespace Artemis.Utilities
Environment.Exit(0); Environment.Exit(0);
} }
public static bool IsRunAsAdministrator() public static bool IsRunAsAdministrator()
{ {
var wi = WindowsIdentity.GetCurrent(); var wi = WindowsIdentity.GetCurrent();
var wp = new WindowsPrincipal(wi); var wp = new WindowsPrincipal(wi);
return wp.IsInRole(WindowsBuiltInRole.Administrator); return wp.IsInRole(WindowsBuiltInRole.Administrator);
} }
} }
} }

34
Artemis/Artemis/Utilities/Keyboard/Key.cs
View File

@ -1,18 +1,18 @@
using System.Windows.Forms; using System.Windows.Forms;
namespace Artemis.Utilities.Keyboard namespace Artemis.Utilities.Keyboard
{ {
public class Key public class Key
{ {
public Key(Keys keyCode, int posX, int posY) public Key(Keys keyCode, int posX, int posY)
{ {
KeyCode = keyCode; KeyCode = keyCode;
PosX = posX; PosX = posX;
PosY = posY; PosY = posY;
} }
public Keys KeyCode { get; set; } public Keys KeyCode { get; set; }
public int PosX { get; set; } public int PosX { get; set; }
public int PosY { get; set; } public int PosY { get; set; }
} }
} }

46
Artemis/Artemis/Utilities/Keyboard/KeyboardHook.cs
View File

@ -1,24 +1,24 @@
using System.Threading.Tasks; using System.Threading.Tasks;
using System.Windows.Forms; using System.Windows.Forms;
using VirtualInput; using VirtualInput;
namespace Artemis.Utilities.Keyboard namespace Artemis.Utilities.Keyboard
{ {
public class KeyboardHook public class KeyboardHook
{ {
public delegate void KeyDownCallbackHandler(KeyEventArgs e); public delegate void KeyDownCallbackHandler(KeyEventArgs e);
public KeyboardHook() public KeyboardHook()
{ {
VirtualKeyboard.KeyDown += VirtualKeyboardOnKeyDown; VirtualKeyboard.KeyDown += VirtualKeyboardOnKeyDown;
VirtualKeyboard.StartInterceptor(); VirtualKeyboard.StartInterceptor();
} }
private void VirtualKeyboardOnKeyDown(object sender, KeyEventArgs keyEventArgs) private void VirtualKeyboardOnKeyDown(object sender, KeyEventArgs keyEventArgs)
{ {
Task.Factory.StartNew(() => { KeyDownCallback?.Invoke(keyEventArgs); }); Task.Factory.StartNew(() => { KeyDownCallback?.Invoke(keyEventArgs); });
} }
public event KeyDownCallbackHandler KeyDownCallback; public event KeyDownCallbackHandler KeyDownCallback;
} }
} }

386
Artemis/Artemis/Utilities/Keyboard/KeyboardRectangle.cs
View File

@ -1,194 +1,194 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.ComponentModel; using System.ComponentModel;
using System.Drawing; using System.Drawing;
using System.Drawing.Drawing2D; using System.Drawing.Drawing2D;
using System.Linq; using System.Linq;
using System.Threading; using System.Threading;
using System.Threading.Tasks; using System.Threading.Tasks;
using Artemis.KeyboardProviders; using Artemis.KeyboardProviders;
namespace Artemis.Utilities.Keyboard namespace Artemis.Utilities.Keyboard
{ {
public class KeyboardRectangle public class KeyboardRectangle
{ {
private readonly BackgroundWorker _blinkWorker = new BackgroundWorker {WorkerSupportsCancellation = true}; private readonly BackgroundWorker _blinkWorker = new BackgroundWorker {WorkerSupportsCancellation = true};
private readonly KeyboardProvider _keyboard; private readonly KeyboardProvider _keyboard;
private int _blinkDelay; private int _blinkDelay;
private double _rotationProgress; private double _rotationProgress;
/// <summary> /// <summary>
/// Represents a Rectangle on the keyboard which can be drawn to a Bitmap. /// Represents a Rectangle on the keyboard which can be drawn to a Bitmap.
/// By default, a rectangle is the entire keyboard's size. /// By default, a rectangle is the entire keyboard's size.
/// </summary> /// </summary>
/// <param name="keyboard">The keyboard this rectangle will be used for</param> /// <param name="keyboard">The keyboard this rectangle will be used for</param>
/// <param name="x"></param> /// <param name="x"></param>
/// <param name="y"></param> /// <param name="y"></param>
/// <param name="colors">An array of colors the ColorBlend will use</param> /// <param name="colors">An array of colors the ColorBlend will use</param>
/// <param name="gradientMode"></param> /// <param name="gradientMode"></param>
public KeyboardRectangle(KeyboardProvider keyboard, int x, int y, List<Color> colors, public KeyboardRectangle(KeyboardProvider keyboard, int x, int y, List<Color> colors,
LinearGradientMode gradientMode) LinearGradientMode gradientMode)
{ {
_keyboard = keyboard; _keyboard = keyboard;
_rotationProgress = 0; _rotationProgress = 0;
_blinkWorker.DoWork += BlinkWorker_DoWork; _blinkWorker.DoWork += BlinkWorker_DoWork;
Scale = 4; Scale = 4;
X = x; X = x;
Y = y; Y = y;
Width = keyboard.Width*Scale; Width = keyboard.Width*Scale;
Height = keyboard.Height*Scale; Height = keyboard.Height*Scale;
Visible = true; Visible = true;
Opacity = 255; Opacity = 255;
ContainedBrush = true; ContainedBrush = true;
GradientMode = gradientMode; GradientMode = gradientMode;
Rotate = false; Rotate = false;
LoopSpeed = 1; LoopSpeed = 1;
Colors = colors; Colors = colors;
} }
public int X { get; set; } public int X { get; set; }
public int Y { get; set; } public int Y { get; set; }
public int Width { get; set; } public int Width { get; set; }
public int Height { get; set; } public int Height { get; set; }
public bool Visible { get; set; } public bool Visible { get; set; }
public byte Opacity { get; set; } // TODO: Remove public byte Opacity { get; set; } // TODO: Remove
/// <summary> /// <summary>
/// Sets wether or not the colors should be contained within the rectangle, or span the entire keyboard. /// Sets wether or not the colors should be contained within the rectangle, or span the entire keyboard.
/// </summary> /// </summary>
public bool ContainedBrush { get; set; } public bool ContainedBrush { get; set; }
/// <summary> /// <summary>
/// Used when ContainedBrush is set to false to make sure the colors span the entire keyboard on a higher scale. /// Used when ContainedBrush is set to false to make sure the colors span the entire keyboard on a higher scale.
/// </summary> /// </summary>
public int Scale { get; set; } public int Scale { get; set; }
/// <summary> /// <summary>
/// Determines what grientmode to use in the LinearGradientBrush. /// Determines what grientmode to use in the LinearGradientBrush.
/// </summary> /// </summary>
public LinearGradientMode GradientMode { get; set; } public LinearGradientMode GradientMode { get; set; }
/// <summary> /// <summary>
/// Wether or not to rotate the colors over the brush. /// Wether or not to rotate the colors over the brush.
/// </summary> /// </summary>
public bool Rotate { get; set; } public bool Rotate { get; set; }
/// <summary> /// <summary>
/// What speed to ratate the colors on. /// What speed to ratate the colors on.
/// </summary> /// </summary>
public double LoopSpeed { get; set; } public double LoopSpeed { get; set; }
/// <summary> /// <summary>
/// Colors used on the brush. /// Colors used on the brush.
/// </summary> /// </summary>
public List<Color> Colors { get; set; } public List<Color> Colors { get; set; }
public void StartBlink(int delay) public void StartBlink(int delay)
{ {
_blinkDelay = delay; _blinkDelay = delay;
if (!_blinkWorker.IsBusy) if (!_blinkWorker.IsBusy)
_blinkWorker.RunWorkerAsync(); _blinkWorker.RunWorkerAsync();
} }
public void StartBlink(int delay, int time) public void StartBlink(int delay, int time)
{ {
StartBlink(delay); StartBlink(delay);
Task.Factory.StartNew(() => Task.Factory.StartNew(() =>
{ {
Thread.Sleep(delay); Thread.Sleep(delay);
StopBlink(); StopBlink();
}); });
} }
public void StopBlink() public void StopBlink()
{ {
if (_blinkWorker.IsBusy) if (_blinkWorker.IsBusy)
_blinkWorker.CancelAsync(); _blinkWorker.CancelAsync();
} }
private void BlinkWorker_DoWork(object sender, DoWorkEventArgs e) private void BlinkWorker_DoWork(object sender, DoWorkEventArgs e)
{ {
while (!_blinkWorker.CancellationPending) while (!_blinkWorker.CancellationPending)
{ {
Thread.Sleep(_blinkDelay); Thread.Sleep(_blinkDelay);
Visible = !Visible; Visible = !Visible;
} }
Visible = true; Visible = true;
} }
public void Draw(Graphics g) public void Draw(Graphics g)
{ {
if (!Visible || Height < 1 || Width < 1 || !Colors.Any()) if (!Visible || Height < 1 || Width < 1 || !Colors.Any())
return; return;
var brush = CreateBrush(); var brush = CreateBrush();
var baseRect = new Rectangle(X, Y, Width, Height); var baseRect = new Rectangle(X, Y, Width, Height);
g.FillRectangle(brush, baseRect); g.FillRectangle(brush, baseRect);
if (!Rotate) if (!Rotate)
return; return;
_rotationProgress = _rotationProgress + LoopSpeed; _rotationProgress = _rotationProgress + LoopSpeed;
if (ContainedBrush && _rotationProgress > Width) if (ContainedBrush && _rotationProgress > Width)
_rotationProgress = LoopSpeed; _rotationProgress = LoopSpeed;
else if (!ContainedBrush && _rotationProgress > _keyboard.Width*Scale) else if (!ContainedBrush && _rotationProgress > _keyboard.Width*Scale)
_rotationProgress = LoopSpeed; _rotationProgress = LoopSpeed;
} }
private LinearGradientBrush CreateBrush() private LinearGradientBrush CreateBrush()
{ {
var colorBlend = CreateColorBlend(); var colorBlend = CreateColorBlend();
RectangleF rect; RectangleF rect;
if (Rotate) if (Rotate)
rect = ContainedBrush rect = ContainedBrush
? new Rectangle((int) _rotationProgress, Y, Width*2, Height*2) ? new Rectangle((int) _rotationProgress, Y, Width*2, Height*2)
: new Rectangle((int) _rotationProgress, 0, _keyboard.Width*Scale*2, _keyboard.Height*Scale*2); : new Rectangle((int) _rotationProgress, 0, _keyboard.Width*Scale*2, _keyboard.Height*Scale*2);
else else
rect = ContainedBrush rect = ContainedBrush
? new Rectangle(X, Y, Width, Height) ? new Rectangle(X, Y, Width, Height)
: new Rectangle(0, 0, _keyboard.Width*Scale, _keyboard.Height*Scale); : new Rectangle(0, 0, _keyboard.Width*Scale, _keyboard.Height*Scale);
return new LinearGradientBrush(rect, Color.Transparent, Color.Transparent, GradientMode) return new LinearGradientBrush(rect, Color.Transparent, Color.Transparent, GradientMode)
{ {
InterpolationColors = colorBlend InterpolationColors = colorBlend
}; };
} }
private ColorBlend CreateColorBlend() private ColorBlend CreateColorBlend()
{ {
if (Colors.Count == 1) if (Colors.Count == 1)
return new ColorBlend {Colors = new[] {Colors[0], Colors[0]}, Positions = new[] {0F, 1F}}; return new ColorBlend {Colors = new[] {Colors[0], Colors[0]}, Positions = new[] {0F, 1F}};
var colorBlend = Rotate var colorBlend = Rotate
? new ColorBlend {Colors = CreateTilebleColors(Colors).ToArray()} ? new ColorBlend {Colors = CreateTilebleColors(Colors).ToArray()}
: new ColorBlend {Colors = Colors.ToArray()}; : new ColorBlend {Colors = Colors.ToArray()};
// If needed, apply opacity to the colors in the blend // If needed, apply opacity to the colors in the blend
if (Opacity < 255) if (Opacity < 255)
for (var i = 0; i < colorBlend.Colors.Length; i++) for (var i = 0; i < colorBlend.Colors.Length; i++)
colorBlend.Colors[i] = Color.FromArgb(Opacity, colorBlend.Colors[i]); colorBlend.Colors[i] = Color.FromArgb(Opacity, colorBlend.Colors[i]);
// Devide the colors over the colorblend // Devide the colors over the colorblend
var devider = (float) colorBlend.Colors.Length - 1; var devider = (float) colorBlend.Colors.Length - 1;
var positions = new List<float>(); var positions = new List<float>();
for (var i = 0; i < colorBlend.Colors.Length; i++) for (var i = 0; i < colorBlend.Colors.Length; i++)
positions.Add(i/devider); positions.Add(i/devider);
// Apply the devided positions // Apply the devided positions
colorBlend.Positions = positions.ToArray(); colorBlend.Positions = positions.ToArray();
return colorBlend; return colorBlend;
} }
private List<Color> CreateTilebleColors(List<Color> sourceColors) private List<Color> CreateTilebleColors(List<Color> sourceColors)
{ {
// Create a list using the original colors // Create a list using the original colors
var tilebleColors = new List<Color>(sourceColors); var tilebleColors = new List<Color>(sourceColors);
// Add the original colors again // Add the original colors again
tilebleColors.AddRange(sourceColors); tilebleColors.AddRange(sourceColors);
// Add the first color, smoothing the transition // Add the first color, smoothing the transition
tilebleColors.Add(sourceColors.FirstOrDefault()); tilebleColors.Add(sourceColors.FirstOrDefault());
return tilebleColors; return tilebleColors;
} }
} }
} }

848
Artemis/Artemis/Utilities/Memory/Memory.cs
View File

@ -1,425 +1,425 @@
using System; using System;
using System.Diagnostics; using System.Diagnostics;
using System.Text.RegularExpressions; using System.Text.RegularExpressions;
namespace Artemis.Utilities.Memory namespace Artemis.Utilities.Memory
{ {
/// <summary> /// <summary>
/// Represents an access to a remote process memory /// Represents an access to a remote process memory
/// </summary> /// </summary>
public class Memory : IDisposable public class Memory : IDisposable
{ {
public const string OffsetPattern = "(\\+|\\-){0,1}(0x){0,1}[a-fA-F0-9]{1,}"; public const string OffsetPattern = "(\\+|\\-){0,1}(0x){0,1}[a-fA-F0-9]{1,}";
private bool isDisposed; private bool isDisposed;
private IntPtr processHandle; private IntPtr processHandle;
/// <summary> /// <summary>
/// Initializes a new instance of the Memory /// Initializes a new instance of the Memory
/// </summary> /// </summary>
/// <param name="process">Remote process</param> /// <param name="process">Remote process</param>
public Memory(Process process) public Memory(Process process)
{ {
if (process == null) if (process == null)
throw new ArgumentNullException("process"); throw new ArgumentNullException("process");
Process = process; Process = process;
processHandle = Win32.OpenProcess( processHandle = Win32.OpenProcess(
Win32.ProcessAccessType.PROCESS_VM_READ | Win32.ProcessAccessType.PROCESS_VM_WRITE | Win32.ProcessAccessType.PROCESS_VM_READ | Win32.ProcessAccessType.PROCESS_VM_WRITE |
Win32.ProcessAccessType.PROCESS_VM_OPERATION, true, (uint) process.Id); Win32.ProcessAccessType.PROCESS_VM_OPERATION, true, (uint) process.Id);
if (processHandle == IntPtr.Zero) if (processHandle == IntPtr.Zero)
throw new InvalidOperationException("Could not open the process"); throw new InvalidOperationException("Could not open the process");
} }
#region Properties #region Properties
/// <summary> /// <summary>
/// Gets the process to which this memory is attached to /// Gets the process to which this memory is attached to
/// </summary> /// </summary>
public Process Process { get; private set; } public Process Process { get; private set; }
#endregion #endregion
/// <summary> /// <summary>
/// Finds module with the given name /// Finds module with the given name
/// </summary> /// </summary>
/// <param name="name">Module name</param> /// <param name="name">Module name</param>
/// <returns></returns> /// <returns></returns>
protected ProcessModule FindModule(string name) protected ProcessModule FindModule(string name)
{ {
if (string.IsNullOrEmpty(name)) if (string.IsNullOrEmpty(name))
throw new ArgumentNullException("name"); throw new ArgumentNullException("name");
foreach (ProcessModule module in Process.Modules) foreach (ProcessModule module in Process.Modules)
{ {
if (module.ModuleName.ToLower() == name.ToLower()) if (module.ModuleName.ToLower() == name.ToLower())
return module; return module;
} }
return null; return null;
} }
/// <summary> /// <summary>
/// Gets module based address /// Gets module based address
/// </summary> /// </summary>
/// <param name="moduleName">Module name</param> /// <param name="moduleName">Module name</param>
/// <param name="baseAddress">Base address</param> /// <param name="baseAddress">Base address</param>
/// <param name="offsets">Collection of offsets</param> /// <param name="offsets">Collection of offsets</param>
/// <returns></returns> /// <returns></returns>
public IntPtr GetAddress(string moduleName, IntPtr baseAddress, int[] offsets) public IntPtr GetAddress(string moduleName, IntPtr baseAddress, int[] offsets)
{ {
if (string.IsNullOrEmpty(moduleName)) if (string.IsNullOrEmpty(moduleName))
throw new ArgumentNullException("moduleName"); throw new ArgumentNullException("moduleName");
var module = FindModule(moduleName); var module = FindModule(moduleName);
if (module == null) if (module == null)
return IntPtr.Zero; return IntPtr.Zero;
var address = module.BaseAddress.ToInt32() + baseAddress.ToInt32(); var address = module.BaseAddress.ToInt32() + baseAddress.ToInt32();
return GetAddress((IntPtr) address, offsets); return GetAddress((IntPtr) address, offsets);
} }
/// <summary> /// <summary>
/// Gets module based address /// Gets module based address
/// </summary> /// </summary>
/// <param name="moduleName">Module name</param> /// <param name="moduleName">Module name</param>
/// <param name="baseAddress">Base address</param> /// <param name="baseAddress">Base address</param>
/// <param name="offsets">Collection of offsets</param> /// <param name="offsets">Collection of offsets</param>
/// <returns></returns> /// <returns></returns>
public IntPtr GetAddressX64(string moduleName, IntPtr baseAddress, int[] offsets) public IntPtr GetAddressX64(string moduleName, IntPtr baseAddress, int[] offsets)
{ {
if (string.IsNullOrEmpty(moduleName)) if (string.IsNullOrEmpty(moduleName))
throw new ArgumentNullException("moduleName"); throw new ArgumentNullException("moduleName");
var module = FindModule(moduleName); var module = FindModule(moduleName);
if (module == null) if (module == null)
return IntPtr.Zero; return IntPtr.Zero;
var address = module.BaseAddress.ToInt64() + baseAddress.ToInt64(); var address = module.BaseAddress.ToInt64() + baseAddress.ToInt64();
return GetAddressX64((IntPtr) address, offsets); return GetAddressX64((IntPtr) address, offsets);
} }
/// <summary> /// <summary>
/// Gets address /// Gets address
/// </summary> /// </summary>
/// <param name="baseAddress">Base address</param> /// <param name="baseAddress">Base address</param>
/// <param name="offsets">Collection of offsets</param> /// <param name="offsets">Collection of offsets</param>
/// <returns></returns> /// <returns></returns>
public IntPtr GetAddress(IntPtr baseAddress, int[] offsets) public IntPtr GetAddress(IntPtr baseAddress, int[] offsets)
{ {
if (baseAddress == IntPtr.Zero) if (baseAddress == IntPtr.Zero)
throw new ArgumentException("Invalid base address"); throw new ArgumentException("Invalid base address");
var address = baseAddress.ToInt32(); var address = baseAddress.ToInt32();
if (offsets != null && offsets.Length > 0) if (offsets != null && offsets.Length > 0)
{ {
var buffer = new byte[4]; var buffer = new byte[4];
foreach (var offset in offsets) foreach (var offset in offsets)
address = ReadInt32((IntPtr) address) + offset; address = ReadInt32((IntPtr) address) + offset;
} }
return (IntPtr) address; return (IntPtr) address;
} }
/// <summary> /// <summary>
/// Gets address /// Gets address
/// </summary> /// </summary>
/// <param name="baseAddress">Base address</param> /// <param name="baseAddress">Base address</param>
/// <param name="offsets">Collection of offsets</param> /// <param name="offsets">Collection of offsets</param>
/// <returns></returns> /// <returns></returns>
public IntPtr GetAddressX64(IntPtr baseAddress, int[] offsets) public IntPtr GetAddressX64(IntPtr baseAddress, int[] offsets)
{ {
if (baseAddress == IntPtr.Zero) if (baseAddress == IntPtr.Zero)
throw new ArgumentException("Invalid base address"); throw new ArgumentException("Invalid base address");
var address = baseAddress.ToInt64(); var address = baseAddress.ToInt64();
if (offsets != null && offsets.Length > 0) if (offsets != null && offsets.Length > 0)
{ {
var buffer = new byte[4]; var buffer = new byte[4];
foreach (var offset in offsets) foreach (var offset in offsets)
address = ReadInt32((IntPtr) address) + offset; address = ReadInt32((IntPtr) address) + offset;
} }
return (IntPtr) address; return (IntPtr) address;
} }
/// <summary> /// <summary>
/// Gets address pointer /// Gets address pointer
/// </summary> /// </summary>
/// <param name="address">Address</param> /// <param name="address">Address</param>
/// <returns></returns> /// <returns></returns>
public IntPtr GetAddressX64(string address) public IntPtr GetAddressX64(string address)
{ {
if (string.IsNullOrEmpty(address)) if (string.IsNullOrEmpty(address))
throw new ArgumentNullException("address"); throw new ArgumentNullException("address");
string moduleName = null; string moduleName = null;
var index = address.IndexOf('"'); var index = address.IndexOf('"');
if (index != -1) if (index != -1)
{ {
// Module name at the beginning // Module name at the beginning
var endIndex = address.IndexOf('"', index + 1); var endIndex = address.IndexOf('"', index + 1);
if (endIndex == -1) if (endIndex == -1)
throw new ArgumentException("Invalid module name. Could not find matching \""); throw new ArgumentException("Invalid module name. Could not find matching \"");
moduleName = address.Substring(index + 1, endIndex - 1); moduleName = address.Substring(index + 1, endIndex - 1);
address = address.Substring(endIndex + 1); address = address.Substring(endIndex + 1);
} }
var offsets = GetAddressOffsets(address); var offsets = GetAddressOffsets(address);
int[] _offsets = null; int[] _offsets = null;
var baseAddress = offsets != null && offsets.Length > 0 var baseAddress = offsets != null && offsets.Length > 0
? (IntPtr) offsets[0] ? (IntPtr) offsets[0]
: IntPtr.Zero; : IntPtr.Zero;
if (offsets != null && offsets.Length > 1) if (offsets != null && offsets.Length > 1)
{ {
_offsets = new int[offsets.Length - 1]; _offsets = new int[offsets.Length - 1];
for (var i = 0; i < offsets.Length - 1; i++) for (var i = 0; i < offsets.Length - 1; i++)
_offsets[i] = offsets[i + 1]; _offsets[i] = offsets[i + 1];
} }
if (moduleName != null) if (moduleName != null)
return GetAddressX64(moduleName, baseAddress, _offsets); return GetAddressX64(moduleName, baseAddress, _offsets);
return GetAddressX64(baseAddress, _offsets); return GetAddressX64(baseAddress, _offsets);
} }
/// <summary> /// <summary>
/// Gets address pointer /// Gets address pointer
/// </summary> /// </summary>
/// <param name="address">Address</param> /// <param name="address">Address</param>
/// <returns></returns> /// <returns></returns>
public IntPtr GetAddress(string address) public IntPtr GetAddress(string address)
{ {
if (string.IsNullOrEmpty(address)) if (string.IsNullOrEmpty(address))
throw new ArgumentNullException("address"); throw new ArgumentNullException("address");
string moduleName = null; string moduleName = null;
var index = address.IndexOf('"'); var index = address.IndexOf('"');
if (index != -1) if (index != -1)
{ {
// Module name at the beginning // Module name at the beginning
var endIndex = address.IndexOf('"', index + 1); var endIndex = address.IndexOf('"', index + 1);
if (endIndex == -1) if (endIndex == -1)
throw new ArgumentException("Invalid module name. Could not find matching \""); throw new ArgumentException("Invalid module name. Could not find matching \"");
moduleName = address.Substring(index + 1, endIndex - 1); moduleName = address.Substring(index + 1, endIndex - 1);
address = address.Substring(endIndex + 1); address = address.Substring(endIndex + 1);
} }
var offsets = GetAddressOffsets(address); var offsets = GetAddressOffsets(address);
int[] _offsets = null; int[] _offsets = null;
var baseAddress = offsets != null && offsets.Length > 0 var baseAddress = offsets != null && offsets.Length > 0
? (IntPtr) offsets[0] ? (IntPtr) offsets[0]
: IntPtr.Zero; : IntPtr.Zero;
if (offsets != null && offsets.Length > 1) if (offsets != null && offsets.Length > 1)
{ {
_offsets = new int[offsets.Length - 1]; _offsets = new int[offsets.Length - 1];
for (var i = 0; i < offsets.Length - 1; i++) for (var i = 0; i < offsets.Length - 1; i++)
_offsets[i] = offsets[i + 1]; _offsets[i] = offsets[i + 1];
} }
if (moduleName != null) if (moduleName != null)
return GetAddress(moduleName, baseAddress, _offsets); return GetAddress(moduleName, baseAddress, _offsets);
return GetAddress(baseAddress, _offsets); return GetAddress(baseAddress, _offsets);
} }
/// <summary> /// <summary>
/// Gets address offsets /// Gets address offsets
/// </summary> /// </summary>
/// <param name="address">Address</param> /// <param name="address">Address</param>
/// <returns></returns> /// <returns></returns>
protected static int[] GetAddressOffsets(string address) protected static int[] GetAddressOffsets(string address)
{ {
if (string.IsNullOrEmpty(address)) if (string.IsNullOrEmpty(address))
return new int[0]; return new int[0];
var matches = Regex.Matches(address, OffsetPattern); var matches = Regex.Matches(address, OffsetPattern);
var offsets = new int[matches.Count]; var offsets = new int[matches.Count];
string value; string value;
char ch; char ch;
for (var i = 0; i < matches.Count; i++) for (var i = 0; i < matches.Count; i++)
{ {
ch = matches[i].Value[0]; ch = matches[i].Value[0];
if (ch == '+' || ch == '-') if (ch == '+' || ch == '-')
value = matches[i].Value.Substring(1); value = matches[i].Value.Substring(1);
else else
value = matches[i].Value; value = matches[i].Value;
offsets[i] = Convert.ToInt32(value, 16); offsets[i] = Convert.ToInt32(value, 16);
if (ch == '-') if (ch == '-')
offsets[i] = -offsets[i]; offsets[i] = -offsets[i];
} }
return offsets; return offsets;
} }
/// <summary> /// <summary>
/// Reads memory at the address /// Reads memory at the address
/// </summary> /// </summary>
/// <param name="address">Memory address</param> /// <param name="address">Memory address</param>
/// <param name="buffer">Buffer</param> /// <param name="buffer">Buffer</param>
/// <param name="size">Size in bytes</param> /// <param name="size">Size in bytes</param>
public void ReadMemory(IntPtr address, byte[] buffer, int size) public void ReadMemory(IntPtr address, byte[] buffer, int size)
{ {
if (isDisposed) if (isDisposed)
throw new ObjectDisposedException("Memory"); throw new ObjectDisposedException("Memory");
if (buffer == null) if (buffer == null)
throw new ArgumentNullException("buffer"); throw new ArgumentNullException("buffer");
if (size <= 0) if (size <= 0)
throw new ArgumentException("Size must be greater than zero"); throw new ArgumentException("Size must be greater than zero");
if (address == IntPtr.Zero) if (address == IntPtr.Zero)
throw new ArgumentException("Invalid address"); throw new ArgumentException("Invalid address");
uint read = 0; uint read = 0;
Win32.ReadProcessMemory(processHandle, address, buffer, (uint) size, ref read); Win32.ReadProcessMemory(processHandle, address, buffer, (uint) size, ref read);
} }
/// <summary> /// <summary>
/// Writes memory at the address /// Writes memory at the address
/// </summary> /// </summary>
/// <param name="address">Memory address</param> /// <param name="address">Memory address</param>
/// <param name="buffer">Buffer</param> /// <param name="buffer">Buffer</param>
/// <param name="size">Size in bytes</param> /// <param name="size">Size in bytes</param>
public void WriteMemory(IntPtr address, byte[] buffer, int size) public void WriteMemory(IntPtr address, byte[] buffer, int size)
{ {
if (isDisposed) if (isDisposed)
throw new ObjectDisposedException("Memory"); throw new ObjectDisposedException("Memory");
if (buffer == null) if (buffer == null)
throw new ArgumentNullException("buffer"); throw new ArgumentNullException("buffer");
if (size <= 0) if (size <= 0)
throw new ArgumentException("Size must be greater than zero"); throw new ArgumentException("Size must be greater than zero");
if (address == IntPtr.Zero) if (address == IntPtr.Zero)
throw new ArgumentException("Invalid address"); throw new ArgumentException("Invalid address");
uint write = 0; uint write = 0;
if (!Win32.WriteProcessMemory(processHandle, address, buffer, (uint) size, ref write) || if (!Win32.WriteProcessMemory(processHandle, address, buffer, (uint) size, ref write) ||
write != size) write != size)
throw new AccessViolationException(); throw new AccessViolationException();
} }
/// <summary> /// <summary>
/// Reads 32 bit signed integer at the address /// Reads 32 bit signed integer at the address
/// </summary> /// </summary>
/// <param name="address">Memory address</param> /// <param name="address">Memory address</param>
/// <returns></returns> /// <returns></returns>
public int ReadInt32(IntPtr address) public int ReadInt32(IntPtr address)
{ {
var buffer = new byte[4]; var buffer = new byte[4];
ReadMemory(address, buffer, 4); ReadMemory(address, buffer, 4);
return BitConverter.ToInt32(buffer, 0); return BitConverter.ToInt32(buffer, 0);
} }
/// <summary> /// <summary>
/// Reads 32 bit signed integer at the address /// Reads 32 bit signed integer at the address
/// </summary> /// </summary>
/// <param name="address">Memory address</param> /// <param name="address">Memory address</param>
/// <returns></returns> /// <returns></returns>
public long ReadInt64(IntPtr address) public long ReadInt64(IntPtr address)
{ {
var buffer = new byte[8]; var buffer = new byte[8];
ReadMemory(address, buffer, 8); ReadMemory(address, buffer, 8);
return BitConverter.ToInt64(buffer, 0); return BitConverter.ToInt64(buffer, 0);
} }
/// <summary> /// <summary>
/// Reads 32 bit unsigned integer at the address /// Reads 32 bit unsigned integer at the address
/// </summary> /// </summary>
/// <param name="address">Memory address</param> /// <param name="address">Memory address</param>
/// <returns></returns> /// <returns></returns>
public uint ReadUInt32(IntPtr address) public uint ReadUInt32(IntPtr address)
{ {
var buffer = new byte[4]; var buffer = new byte[4];
ReadMemory(address, buffer, 4); ReadMemory(address, buffer, 4);
return BitConverter.ToUInt32(buffer, 0); return BitConverter.ToUInt32(buffer, 0);
} }
/// <summary> /// <summary>
/// Reads single precision value at the address /// Reads single precision value at the address
/// </summary> /// </summary>
/// <param name="address">Memory address</param> /// <param name="address">Memory address</param>
/// <returns></returns> /// <returns></returns>
public float ReadFloat(IntPtr address) public float ReadFloat(IntPtr address)
{ {
var buffer = new byte[4]; var buffer = new byte[4];
ReadMemory(address, buffer, 4); ReadMemory(address, buffer, 4);
return BitConverter.ToSingle(buffer, 0); return BitConverter.ToSingle(buffer, 0);
} }
/// <summary> /// <summary>
/// Reads double precision value at the address /// Reads double precision value at the address
/// </summary> /// </summary>
/// <param name="address">Memory address</param> /// <param name="address">Memory address</param>
/// <returns></returns> /// <returns></returns>
public double ReadDouble(IntPtr address) public double ReadDouble(IntPtr address)
{ {
var buffer = new byte[8]; var buffer = new byte[8];
ReadMemory(address, buffer, 8); ReadMemory(address, buffer, 8);
return BitConverter.ToDouble(buffer, 0); return BitConverter.ToDouble(buffer, 0);
} }
/// <summary> /// <summary>
/// Writes 32 bit unsigned integer at the address /// Writes 32 bit unsigned integer at the address
/// </summary> /// </summary>
/// <param name="address">Memory address</param> /// <param name="address">Memory address</param>
/// <param name="value">Value</param> /// <param name="value">Value</param>
/// <returns></returns> /// <returns></returns>
public void WriteUInt32(IntPtr address, uint value) public void WriteUInt32(IntPtr address, uint value)
{ {
var buffer = BitConverter.GetBytes(value); var buffer = BitConverter.GetBytes(value);
WriteMemory(address, buffer, 4); WriteMemory(address, buffer, 4);
} }
/// <summary> /// <summary>
/// Writes 32 bit signed integer at the address /// Writes 32 bit signed integer at the address
/// </summary> /// </summary>
/// <param name="address">Memory address</param> /// <param name="address">Memory address</param>
/// <param name="value">Value</param> /// <param name="value">Value</param>
/// <returns></returns> /// <returns></returns>
public void WriteInt32(IntPtr address, int value) public void WriteInt32(IntPtr address, int value)
{ {
var buffer = BitConverter.GetBytes(value); var buffer = BitConverter.GetBytes(value);
WriteMemory(address, buffer, 4); WriteMemory(address, buffer, 4);
} }
/// <summary> /// <summary>
/// Writes single precision value at the address /// Writes single precision value at the address
/// </summary> /// </summary>
/// <param name="address">Memory address</param> /// <param name="address">Memory address</param>
/// <param name="value">Value</param> /// <param name="value">Value</param>
/// <returns></returns> /// <returns></returns>
public void WriteFloat(IntPtr address, float value) public void WriteFloat(IntPtr address, float value)
{ {
var buffer = BitConverter.GetBytes(value); var buffer = BitConverter.GetBytes(value);
WriteMemory(address, buffer, 4); WriteMemory(address, buffer, 4);
} }
/// <summary> /// <summary>
/// Writes double precision value at the address /// Writes double precision value at the address
/// </summary> /// </summary>
/// <param name="address">Memory address</param> /// <param name="address">Memory address</param>
/// <param name="value">Value</param> /// <param name="value">Value</param>
/// <returns></returns> /// <returns></returns>
public void WriteDouble(IntPtr address, double value) public void WriteDouble(IntPtr address, double value)
{ {
var buffer = BitConverter.GetBytes(value); var buffer = BitConverter.GetBytes(value);
WriteMemory(address, buffer, 8); WriteMemory(address, buffer, 8);
} }
#region IDisposable #region IDisposable
~Memory() ~Memory()
{ {
Dispose(false); Dispose(false);
} }
public void Dispose() public void Dispose()
{ {
Dispose(true); Dispose(true);
GC.SuppressFinalize(this); GC.SuppressFinalize(this);
} }
private void Dispose(bool disposing) private void Dispose(bool disposing)
{ {
if (isDisposed) if (isDisposed)
return; return;
Win32.CloseHandle(processHandle); Win32.CloseHandle(processHandle);
Process = null; Process = null;
processHandle = IntPtr.Zero; processHandle = IntPtr.Zero;
isDisposed = true; isDisposed = true;
} }
#endregion #endregion
} }
} }

80
Artemis/Artemis/Utilities/Memory/MemoryHelpers.cs
View File

@ -1,41 +1,41 @@
using System; using System;
using System.Diagnostics; using System.Diagnostics;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
namespace Artemis.Utilities.Memory namespace Artemis.Utilities.Memory
{ {
public static class MemoryHelpers public static class MemoryHelpers
{ {
[DllImport("kernel32.dll", SetLastError = true)] [DllImport("kernel32.dll", SetLastError = true)]
public static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [Out] byte[] lpBuffer, public static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [Out] byte[] lpBuffer,
int dwSize, ref int lpNumberOfBytesRead); int dwSize, ref int lpNumberOfBytesRead);
public static Process GetProcessIfRunning(string processName) public static Process GetProcessIfRunning(string processName)
{ {
var processes = Process.GetProcessesByName(processName); var processes = Process.GetProcessesByName(processName);
return processes.Length >= 1 ? processes[0] : null; return processes.Length >= 1 ? processes[0] : null;
} }
public static IntPtr FindAddress(IntPtr pHandle, IntPtr baseAddress, IntPtr staticPointer, int[] offsets) public static IntPtr FindAddress(IntPtr pHandle, IntPtr baseAddress, IntPtr staticPointer, int[] offsets)
{ {
// Create a buffer that is 4 bytes on a 32-bit system or 8 bytes on a 64-bit system. // Create a buffer that is 4 bytes on a 32-bit system or 8 bytes on a 64-bit system.
var tmp = new byte[IntPtr.Size]; var tmp = new byte[IntPtr.Size];
var address = baseAddress; var address = baseAddress;
// We must check for 32-bit vs 64-bit. // We must check for 32-bit vs 64-bit.
address = IntPtr.Size == 4 address = IntPtr.Size == 4
? new IntPtr(address.ToInt32() + staticPointer.ToInt32()) ? new IntPtr(address.ToInt32() + staticPointer.ToInt32())
: new IntPtr(address.ToInt64() + staticPointer.ToInt64()); : new IntPtr(address.ToInt64() + staticPointer.ToInt64());
// Loop through each offset to find the address // Loop through each offset to find the address
foreach (IntPtr t in offsets) foreach (IntPtr t in offsets)
{ {
var lpNumberOfBytesRead = 0; var lpNumberOfBytesRead = 0;
ReadProcessMemory(pHandle, address, tmp, IntPtr.Size, ref lpNumberOfBytesRead); ReadProcessMemory(pHandle, address, tmp, IntPtr.Size, ref lpNumberOfBytesRead);
address = IntPtr.Size == 4 address = IntPtr.Size == 4
? new IntPtr(BitConverter.ToInt32(tmp, 0) + t.ToInt32()) ? new IntPtr(BitConverter.ToInt32(tmp, 0) + t.ToInt32())
: new IntPtr(BitConverter.ToInt64(tmp, 0) + t.ToInt64()); : new IntPtr(BitConverter.ToInt64(tmp, 0) + t.ToInt64());
} }
return address; return address;
} }
} }
} }

84
Artemis/Artemis/Utilities/Memory/Win32.cs
View File

@ -1,43 +1,43 @@
using System; using System;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
namespace Artemis.Utilities.Memory namespace Artemis.Utilities.Memory
{ {
/// <summary> /// <summary>
/// Win32 methods /// Win32 methods
/// </summary> /// </summary>
public static class Win32 public static class Win32
{ {
[Flags] [Flags]
public enum ProcessAccessType public enum ProcessAccessType
{ {
PROCESS_TERMINATE = 0x0001, PROCESS_TERMINATE = 0x0001,
PROCESS_CREATE_THREAD = 0x0002, PROCESS_CREATE_THREAD = 0x0002,
PROCESS_SET_SESSIONID = 0x0004, PROCESS_SET_SESSIONID = 0x0004,
PROCESS_VM_OPERATION = 0x0008, PROCESS_VM_OPERATION = 0x0008,
PROCESS_VM_READ = 0x0010, PROCESS_VM_READ = 0x0010,
PROCESS_VM_WRITE = 0x0020, PROCESS_VM_WRITE = 0x0020,
PROCESS_DUP_HANDLE = 0x0040, PROCESS_DUP_HANDLE = 0x0040,
PROCESS_CREATE_PROCESS = 0x0080, PROCESS_CREATE_PROCESS = 0x0080,
PROCESS_SET_QUOTA = 0x0100, PROCESS_SET_QUOTA = 0x0100,
PROCESS_SET_INFORMATION = 0x0200, PROCESS_SET_INFORMATION = 0x0200,
PROCESS_QUERY_INFORMATION = 0x0400 PROCESS_QUERY_INFORMATION = 0x0400
} }
[DllImport("kernel32.dll", SetLastError = true)] [DllImport("kernel32.dll", SetLastError = true)]
public static extern bool WriteProcessMemory( public static extern bool WriteProcessMemory(
IntPtr process, IntPtr address, byte[] buffer, uint size, ref uint written); IntPtr process, IntPtr address, byte[] buffer, uint size, ref uint written);
[DllImport("Kernel32.dll", SetLastError = true)] [DllImport("Kernel32.dll", SetLastError = true)]
public static extern bool ReadProcessMemory( public static extern bool ReadProcessMemory(
IntPtr process, IntPtr address, byte[] buffer, uint size, ref uint read); IntPtr process, IntPtr address, byte[] buffer, uint size, ref uint read);
[DllImport("kernel32.dll")] [DllImport("kernel32.dll")]
public static extern IntPtr OpenProcess( public static extern IntPtr OpenProcess(
[MarshalAs(UnmanagedType.U4)] ProcessAccessType access, [MarshalAs(UnmanagedType.U4)] ProcessAccessType access,
[MarshalAs(UnmanagedType.Bool)] bool inheritHandler, uint processId); [MarshalAs(UnmanagedType.Bool)] bool inheritHandler, uint processId);
[DllImport("kernel32.dll")] [DllImport("kernel32.dll")]
public static extern int CloseHandle(IntPtr objectHandle); public static extern int CloseHandle(IntPtr objectHandle);
} }
} }

90
Artemis/Artemis/Utilities/ShellLink.cs
View File

@ -1,46 +1,46 @@
using System; using System;
using System.Runtime.InteropServices; using System.Runtime.InteropServices;
using System.Text; using System.Text;
namespace Artemis.Utilities namespace Artemis.Utilities
{ {
/// <summary> /// <summary>
/// Creates a shortcut (.lnk) file. /// Creates a shortcut (.lnk) file.
/// Source: http://stackoverflow.com/a/14632782/5015269 /// Source: http://stackoverflow.com/a/14632782/5015269
/// </summary> /// </summary>
[ComImport] [ComImport]
[Guid("00021401-0000-0000-C000-000000000046")] [Guid("00021401-0000-0000-C000-000000000046")]
internal class ShellLink internal class ShellLink
{ {
} }
[ComImport] [ComImport]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
[Guid("000214F9-0000-0000-C000-000000000046")] [Guid("000214F9-0000-0000-C000-000000000046")]
internal interface IShellLink internal interface IShellLink
{ {
void GetPath([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszFile, int cchMaxPath, out IntPtr pfd, void GetPath([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszFile, int cchMaxPath, out IntPtr pfd,
int fFlags); int fFlags);
void GetIDList(out IntPtr ppidl); void GetIDList(out IntPtr ppidl);
void SetIDList(IntPtr pidl); void SetIDList(IntPtr pidl);
void GetDescription([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszName, int cchMaxName); void GetDescription([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszName, int cchMaxName);
void SetDescription([MarshalAs(UnmanagedType.LPWStr)] string pszName); void SetDescription([MarshalAs(UnmanagedType.LPWStr)] string pszName);
void GetWorkingDirectory([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszDir, int cchMaxPath); void GetWorkingDirectory([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszDir, int cchMaxPath);
void SetWorkingDirectory([MarshalAs(UnmanagedType.LPWStr)] string pszDir); void SetWorkingDirectory([MarshalAs(UnmanagedType.LPWStr)] string pszDir);
void GetArguments([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszArgs, int cchMaxPath); void GetArguments([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszArgs, int cchMaxPath);
void SetArguments([MarshalAs(UnmanagedType.LPWStr)] string pszArgs); void SetArguments([MarshalAs(UnmanagedType.LPWStr)] string pszArgs);
void GetHotkey(out short pwHotkey); void GetHotkey(out short pwHotkey);
void SetHotkey(short wHotkey); void SetHotkey(short wHotkey);
void GetShowCmd(out int piShowCmd); void GetShowCmd(out int piShowCmd);
void SetShowCmd(int iShowCmd); void SetShowCmd(int iShowCmd);
void GetIconLocation([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszIconPath, int cchIconPath, void GetIconLocation([Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszIconPath, int cchIconPath,
out int piIcon); out int piIcon);
void SetIconLocation([MarshalAs(UnmanagedType.LPWStr)] string pszIconPath, int iIcon); void SetIconLocation([MarshalAs(UnmanagedType.LPWStr)] string pszIconPath, int iIcon);
void SetRelativePath([MarshalAs(UnmanagedType.LPWStr)] string pszPathRel, int dwReserved); void SetRelativePath([MarshalAs(UnmanagedType.LPWStr)] string pszPathRel, int dwReserved);
void Resolve(IntPtr hwnd, int fFlags); void Resolve(IntPtr hwnd, int fFlags);
void SetPath([MarshalAs(UnmanagedType.LPWStr)] string pszFile); void SetPath([MarshalAs(UnmanagedType.LPWStr)] string pszFile);
} }
} }

76
Artemis/Artemis/ViewModels/EffectsViewModel.cs
View File

@ -1,39 +1,39 @@
using Artemis.Managers; using Artemis.Managers;
using Artemis.Modules.Effects.AmbientLightning; using Artemis.Modules.Effects.AmbientLightning;
using Artemis.Modules.Effects.AudioVisualizer; using Artemis.Modules.Effects.AudioVisualizer;
using Artemis.Modules.Effects.Debug; using Artemis.Modules.Effects.Debug;
using Artemis.Modules.Effects.TypeHole; using Artemis.Modules.Effects.TypeHole;
using Artemis.Modules.Effects.TypeWave; using Artemis.Modules.Effects.TypeWave;
using Caliburn.Micro; using Caliburn.Micro;
namespace Artemis.ViewModels namespace Artemis.ViewModels
{ {
public class EffectsViewModel : Conductor<IScreen>.Collection.OneActive public class EffectsViewModel : Conductor<IScreen>.Collection.OneActive
{ {
private readonly AudioVisualizerViewModel _audioVisualizerVm; private readonly AudioVisualizerViewModel _audioVisualizerVm;
private readonly DebugEffectViewModel _debugVm; private readonly DebugEffectViewModel _debugVm;
private readonly TypeHoleViewModel _typeHoleVm; private readonly TypeHoleViewModel _typeHoleVm;
private readonly TypeWaveViewModel _typeWaveVm; private readonly TypeWaveViewModel _typeWaveVm;
//private readonly AmbientLightningEffectViewModel _ambientLightningVm; //private readonly AmbientLightningEffectViewModel _ambientLightningVm;
public EffectsViewModel(MainManager mainManager) public EffectsViewModel(MainManager mainManager)
{ {
_typeWaveVm = new TypeWaveViewModel(mainManager) {DisplayName = "Type Waves"}; _typeWaveVm = new TypeWaveViewModel(mainManager) {DisplayName = "Type Waves"};
//_typeHoleVm = new TypeHoleViewModel(MainManager) {DisplayName = "Type Holes (NYI)"}; //_typeHoleVm = new TypeHoleViewModel(MainManager) {DisplayName = "Type Holes (NYI)"};
_audioVisualizerVm = new AudioVisualizerViewModel(mainManager) {DisplayName = "Audio Visualization"}; _audioVisualizerVm = new AudioVisualizerViewModel(mainManager) {DisplayName = "Audio Visualization"};
//_ambientLightningVm = new AmbientLightningEffectViewModel(mainManager) {DisplayName = "Ambient Lightning"}; //_ambientLightningVm = new AmbientLightningEffectViewModel(mainManager) {DisplayName = "Ambient Lightning"};
_debugVm = new DebugEffectViewModel(mainManager) {DisplayName = "Debug Effect"}; _debugVm = new DebugEffectViewModel(mainManager) {DisplayName = "Debug Effect"};
} }
protected override void OnActivate() protected override void OnActivate()
{ {
base.OnActivate(); base.OnActivate();
ActivateItem(_typeWaveVm); ActivateItem(_typeWaveVm);
//ActivateItem(_typeHoleVm); //ActivateItem(_typeHoleVm);
ActivateItem(_audioVisualizerVm); ActivateItem(_audioVisualizerVm);
//ActivateItem(_ambientLightningVm); //ActivateItem(_ambientLightningVm);
ActivateItem(_debugVm); ActivateItem(_debugVm);
} }
} }
} }

112
Artemis/Artemis/ViewModels/FlyoutBaseViewModel.cs
View File

@ -1,57 +1,57 @@
using Caliburn.Micro; using Caliburn.Micro;
using MahApps.Metro.Controls; using MahApps.Metro.Controls;
namespace Artemis.ViewModels namespace Artemis.ViewModels
{ {
public abstract class FlyoutBaseViewModel : PropertyChangedBase public abstract class FlyoutBaseViewModel : PropertyChangedBase
{ {
private string _header; private string _header;
private bool _isOpen; private bool _isOpen;
private Position _position; private Position _position;
public string Header public string Header
{ {
get { return _header; } get { return _header; }
set set
{ {
if (value == _header) if (value == _header)
return; return;
_header = value; _header = value;
NotifyOfPropertyChange(() => Header); NotifyOfPropertyChange(() => Header);
} }
} }
public bool IsOpen public bool IsOpen
{ {
get { return _isOpen; } get { return _isOpen; }
set set
{ {
if (value.Equals(_isOpen)) if (value.Equals(_isOpen))
return; return;
_isOpen = value; _isOpen = value;
HandleOpen(); HandleOpen();
NotifyOfPropertyChange(() => IsOpen); NotifyOfPropertyChange(() => IsOpen);
} }
} }
public Position Position public Position Position
{ {
get { return _position; } get { return _position; }
set set
{ {
if (value == _position) if (value == _position)
return; return;
_position = value; _position = value;
NotifyOfPropertyChange(() => Position); NotifyOfPropertyChange(() => Position);
} }
} }
protected abstract void HandleOpen(); protected abstract void HandleOpen();
} }
} }

266
Artemis/Artemis/ViewModels/Flyouts/FlyoutSettingsViewModel.cs
View File

@ -1,134 +1,134 @@
using System.Diagnostics; using System.Diagnostics;
using System.Linq; using System.Linq;
using Artemis.Events; using Artemis.Events;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Settings; using Artemis.Settings;
using Caliburn.Micro; using Caliburn.Micro;
using MahApps.Metro.Controls; using MahApps.Metro.Controls;
namespace Artemis.ViewModels.Flyouts namespace Artemis.ViewModels.Flyouts
{ {
public class FlyoutSettingsViewModel : FlyoutBaseViewModel, IHandle<ToggleEnabled>, IHandle<ActiveEffectChanged> public class FlyoutSettingsViewModel : FlyoutBaseViewModel, IHandle<ToggleEnabled>, IHandle<ActiveEffectChanged>
{ {
private string _activeEffectName; private string _activeEffectName;
private bool _enabled; private bool _enabled;
private GeneralSettings _generalSettings; private GeneralSettings _generalSettings;
private string _selectedKeyboardProvider; private string _selectedKeyboardProvider;
public FlyoutSettingsViewModel(MainManager mainManager) public FlyoutSettingsViewModel(MainManager mainManager)
{ {
MainManager = mainManager; MainManager = mainManager;
Header = "Settings"; Header = "Settings";
Position = Position.Right; Position = Position.Right;
GeneralSettings = new GeneralSettings(); GeneralSettings = new GeneralSettings();
MainManager.Events.Subscribe(this); MainManager.Events.Subscribe(this);
} }
public GeneralSettings GeneralSettings public GeneralSettings GeneralSettings
{ {
get { return _generalSettings; } get { return _generalSettings; }
set set
{ {
if (Equals(value, _generalSettings)) return; if (Equals(value, _generalSettings)) return;
_generalSettings = value; _generalSettings = value;
NotifyOfPropertyChange(() => GeneralSettings); NotifyOfPropertyChange(() => GeneralSettings);
} }
} }
public MainManager MainManager { get; set; } public MainManager MainManager { get; set; }
public BindableCollection<string> KeyboardProviders public BindableCollection<string> KeyboardProviders
{ {
get get
{ {
var collection = new BindableCollection<string>(MainManager.KeyboardManager.KeyboardProviders var collection = new BindableCollection<string>(MainManager.KeyboardManager.KeyboardProviders
.Select(k => k.Name)); .Select(k => k.Name));
collection.Insert(0, "None"); collection.Insert(0, "None");
return collection; return collection;
} }
} }
public string SelectedKeyboardProvider public string SelectedKeyboardProvider
{ {
get { return _selectedKeyboardProvider; } get { return _selectedKeyboardProvider; }
set set
{ {
if (value == _selectedKeyboardProvider) return; if (value == _selectedKeyboardProvider) return;
_selectedKeyboardProvider = value; _selectedKeyboardProvider = value;
NotifyOfPropertyChange(() => SelectedKeyboardProvider); NotifyOfPropertyChange(() => SelectedKeyboardProvider);
if (value == null) if (value == null)
return; return;
MainManager.KeyboardManager.ChangeKeyboard( MainManager.KeyboardManager.ChangeKeyboard(
MainManager.KeyboardManager.KeyboardProviders.FirstOrDefault( MainManager.KeyboardManager.KeyboardProviders.FirstOrDefault(
k => k.Name == _selectedKeyboardProvider)); k => k.Name == _selectedKeyboardProvider));
} }
} }
public bool Enabled public bool Enabled
{ {
get { return MainManager.ProgramEnabled; } get { return MainManager.ProgramEnabled; }
set set
{ {
if (value) if (value)
MainManager.EnableProgram(); MainManager.EnableProgram();
else else
MainManager.DisableProgram(); MainManager.DisableProgram();
} }
} }
public string ActiveEffectName public string ActiveEffectName
{ {
get { return _activeEffectName; } get { return _activeEffectName; }
set set
{ {
if (value == _activeEffectName) return; if (value == _activeEffectName) return;
_activeEffectName = value; _activeEffectName = value;
NotifyOfPropertyChange(() => ActiveEffectName); NotifyOfPropertyChange(() => ActiveEffectName);
} }
} }
public void Handle(ActiveEffectChanged message) public void Handle(ActiveEffectChanged message)
{ {
var effectDisplay = message.ActiveEffect.Length > 0 ? message.ActiveEffect : "none"; var effectDisplay = message.ActiveEffect.Length > 0 ? message.ActiveEffect : "none";
ActiveEffectName = $"Active effect: {effectDisplay}"; ActiveEffectName = $"Active effect: {effectDisplay}";
} }
public void Handle(ToggleEnabled message) public void Handle(ToggleEnabled message)
{ {
NotifyOfPropertyChange(() => Enabled); NotifyOfPropertyChange(() => Enabled);
} }
public void ToggleEnabled() public void ToggleEnabled()
{ {
if (Enabled) if (Enabled)
MainManager.DisableProgram(); MainManager.DisableProgram();
else else
MainManager.EnableProgram(); MainManager.EnableProgram();
} }
public void ResetSettings() public void ResetSettings()
{ {
GeneralSettings.ResetSettings(); GeneralSettings.ResetSettings();
NotifyOfPropertyChange(() => GeneralSettings); NotifyOfPropertyChange(() => GeneralSettings);
} }
public void SaveSettings() public void SaveSettings()
{ {
GeneralSettings.SaveSettings(); GeneralSettings.SaveSettings();
} }
public void NavigateTo(string url) public void NavigateTo(string url)
{ {
Process.Start(new ProcessStartInfo(url)); Process.Start(new ProcessStartInfo(url));
} }
protected override void HandleOpen() protected override void HandleOpen()
{ {
SelectedKeyboardProvider = General.Default.LastKeyboard.Length > 0 SelectedKeyboardProvider = General.Default.LastKeyboard.Length > 0
? General.Default.LastKeyboard ? General.Default.LastKeyboard
: "None"; : "None";
} }
} }
} }

76
Artemis/Artemis/ViewModels/GamesViewModel.cs
View File

@ -1,39 +1,39 @@
using Artemis.Managers; using Artemis.Managers;
using Artemis.Modules.Games.CounterStrike; using Artemis.Modules.Games.CounterStrike;
using Artemis.Modules.Games.Dota2; using Artemis.Modules.Games.Dota2;
using Artemis.Modules.Games.RocketLeague; using Artemis.Modules.Games.RocketLeague;
using Artemis.Modules.Games.TheDivision; using Artemis.Modules.Games.TheDivision;
using Artemis.Modules.Games.Witcher3; using Artemis.Modules.Games.Witcher3;
using Caliburn.Micro; using Caliburn.Micro;
namespace Artemis.ViewModels namespace Artemis.ViewModels
{ {
public class GamesViewModel : Conductor<IScreen>.Collection.OneActive public class GamesViewModel : Conductor<IScreen>.Collection.OneActive
{ {
private readonly CounterStrikeViewModel _counterStrikeVm; private readonly CounterStrikeViewModel _counterStrikeVm;
private readonly Dota2ViewModel _dota2Vm; private readonly Dota2ViewModel _dota2Vm;
private readonly RocketLeagueViewModel _rocketLeagueVm; private readonly RocketLeagueViewModel _rocketLeagueVm;
private readonly Witcher3ViewModel _witcher3Vm; private readonly Witcher3ViewModel _witcher3Vm;
private readonly TheDivisionViewModel _divisionVm; private readonly TheDivisionViewModel _divisionVm;
public GamesViewModel(MainManager mainManager) public GamesViewModel(MainManager mainManager)
{ {
_rocketLeagueVm = new RocketLeagueViewModel(mainManager) {DisplayName = "Rocket League"}; _rocketLeagueVm = new RocketLeagueViewModel(mainManager) {DisplayName = "Rocket League"};
_counterStrikeVm = new CounterStrikeViewModel(mainManager) {DisplayName = "CS:GO"}; _counterStrikeVm = new CounterStrikeViewModel(mainManager) {DisplayName = "CS:GO"};
_dota2Vm = new Dota2ViewModel(mainManager) {DisplayName = "Dota 2"}; _dota2Vm = new Dota2ViewModel(mainManager) {DisplayName = "Dota 2"};
_witcher3Vm = new Witcher3ViewModel(mainManager) {DisplayName = "The Witcher 3"}; _witcher3Vm = new Witcher3ViewModel(mainManager) {DisplayName = "The Witcher 3"};
// _divisionVm = new TheDivisionViewModel(mainManager) {DisplayName = "The Division"}; // _divisionVm = new TheDivisionViewModel(mainManager) {DisplayName = "The Division"};
} }
protected override void OnActivate() protected override void OnActivate()
{ {
base.OnActivate(); base.OnActivate();
ActivateItem(_rocketLeagueVm); ActivateItem(_rocketLeagueVm);
ActivateItem(_counterStrikeVm); ActivateItem(_counterStrikeVm);
ActivateItem(_dota2Vm); ActivateItem(_dota2Vm);
ActivateItem(_witcher3Vm); ActivateItem(_witcher3Vm);
// ActivateItem(_divisionVm); // ActivateItem(_divisionVm);
} }
} }
} }

56
Artemis/Artemis/ViewModels/OverlaysViewModel.cs
View File

@ -1,29 +1,29 @@
using Artemis.Managers; using Artemis.Managers;
using Artemis.Modules.Overlays.VolumeDisplay; using Artemis.Modules.Overlays.VolumeDisplay;
using Caliburn.Micro; using Caliburn.Micro;
namespace Artemis.ViewModels namespace Artemis.ViewModels
{ {
public class OverlaysViewModel : Conductor<IScreen>.Collection.OneActive public class OverlaysViewModel : Conductor<IScreen>.Collection.OneActive
{ {
private readonly MainManager _mainManager; private readonly MainManager _mainManager;
private VolumeDisplayViewModel _volumeDisplayVm; private VolumeDisplayViewModel _volumeDisplayVm;
public OverlaysViewModel(MainManager mainManager) public OverlaysViewModel(MainManager mainManager)
{ {
_mainManager = mainManager; _mainManager = mainManager;
} }
protected override void OnActivate() protected override void OnActivate()
{ {
base.OnActivate(); base.OnActivate();
Items.Clear(); Items.Clear();
// This VM appears to be going out of scope, so recreating it every time just to be sure. // This VM appears to be going out of scope, so recreating it every time just to be sure.
_volumeDisplayVm = new VolumeDisplayViewModel(_mainManager) {DisplayName = "Volume Display"}; _volumeDisplayVm = new VolumeDisplayViewModel(_mainManager) {DisplayName = "Volume Display"};
ActivateItem(_volumeDisplayVm); ActivateItem(_volumeDisplayVm);
ActiveItem = _volumeDisplayVm; ActiveItem = _volumeDisplayVm;
} }
} }
} }

116
Artemis/Artemis/ViewModels/ShellViewModel.cs
View File

@ -1,59 +1,59 @@
using System.Linq; using System.Linq;
using Artemis.Managers; using Artemis.Managers;
using Artemis.Services; using Artemis.Services;
using Artemis.ViewModels.Flyouts; using Artemis.ViewModels.Flyouts;
using Caliburn.Micro; using Caliburn.Micro;
namespace Artemis.ViewModels namespace Artemis.ViewModels
{ {
public sealed class ShellViewModel : Conductor<IScreen>.Collection.OneActive public sealed class ShellViewModel : Conductor<IScreen>.Collection.OneActive
{ {
private readonly EffectsViewModel _effectsVm; private readonly EffectsViewModel _effectsVm;
private readonly GamesViewModel _gamesVm; private readonly GamesViewModel _gamesVm;
private readonly OverlaysViewModel _overlaysVm; private readonly OverlaysViewModel _overlaysVm;
private readonly WelcomeViewModel _welcomeVm; private readonly WelcomeViewModel _welcomeVm;
public ShellViewModel() public ShellViewModel()
{ {
var dialogService = new MetroDialogService(this); var dialogService = new MetroDialogService(this);
IEventAggregator events = new EventAggregator(); IEventAggregator events = new EventAggregator();
MainManager = new MainManager(events, dialogService); MainManager = new MainManager(events, dialogService);
DisplayName = "Artemis"; DisplayName = "Artemis";
_welcomeVm = new WelcomeViewModel {DisplayName = "Welcome"}; _welcomeVm = new WelcomeViewModel {DisplayName = "Welcome"};
_effectsVm = new EffectsViewModel(MainManager) {DisplayName = "Effects"}; _effectsVm = new EffectsViewModel(MainManager) {DisplayName = "Effects"};
_gamesVm = new GamesViewModel(MainManager) {DisplayName = "Games"}; _gamesVm = new GamesViewModel(MainManager) {DisplayName = "Games"};
_overlaysVm = new OverlaysViewModel(MainManager) {DisplayName = "Overlays"}; _overlaysVm = new OverlaysViewModel(MainManager) {DisplayName = "Overlays"};
Flyouts.Add(new FlyoutSettingsViewModel(MainManager)); Flyouts.Add(new FlyoutSettingsViewModel(MainManager));
} }
public IObservableCollection<FlyoutBaseViewModel> Flyouts { get; set; } = public IObservableCollection<FlyoutBaseViewModel> Flyouts { get; set; } =
new BindableCollection<FlyoutBaseViewModel>(); new BindableCollection<FlyoutBaseViewModel>();
public MainManager MainManager { get; set; } public MainManager MainManager { get; set; }
protected override void OnActivate() protected override void OnActivate()
{ {
base.OnActivate(); base.OnActivate();
ActivateItem(_welcomeVm); ActivateItem(_welcomeVm);
ActivateItem(_effectsVm); ActivateItem(_effectsVm);
ActivateItem(_gamesVm); ActivateItem(_gamesVm);
ActivateItem(_overlaysVm); ActivateItem(_overlaysVm);
ActiveItem = _welcomeVm; ActiveItem = _welcomeVm;
} }
public void Settings() public void Settings()
{ {
Flyouts.First().IsOpen = !Flyouts.First().IsOpen; Flyouts.First().IsOpen = !Flyouts.First().IsOpen;
} }
public void CloseSettings() public void CloseSettings()
{ {
Flyouts.First().IsOpen = false; Flyouts.First().IsOpen = false;
} }
} }
} }

248
Artemis/Artemis/ViewModels/SystemTrayViewModel.cs
View File

@ -1,54 +1,54 @@
using System; using System;
using System.Windows; using System.Windows;
using Artemis.Events; using Artemis.Events;
using Artemis.Properties; using Artemis.Properties;
using Artemis.Settings; using Artemis.Settings;
using Artemis.Utilities; using Artemis.Utilities;
using Caliburn.Micro; using Caliburn.Micro;
namespace Artemis.ViewModels namespace Artemis.ViewModels
{ {
public class SystemTrayViewModel : Screen, IHandle<ToggleEnabled> public class SystemTrayViewModel : Screen, IHandle<ToggleEnabled>
{ {
private readonly ShellViewModel _shellViewModel; private readonly ShellViewModel _shellViewModel;
private readonly IWindowManager _windowManager; private readonly IWindowManager _windowManager;
private string _activeIcon; private string _activeIcon;
private bool _checkedForUpdate; private bool _checkedForUpdate;
private bool _enabled; private bool _enabled;
private string _toggleText; private string _toggleText;
public SystemTrayViewModel(IWindowManager windowManager, ShellViewModel shellViewModel) public SystemTrayViewModel(IWindowManager windowManager, ShellViewModel shellViewModel)
{ {
_windowManager = windowManager; _windowManager = windowManager;
_shellViewModel = shellViewModel; _shellViewModel = shellViewModel;
_shellViewModel.MainManager.Events.Subscribe(this); _shellViewModel.MainManager.Events.Subscribe(this);
_shellViewModel.MainManager.EnableProgram(); _shellViewModel.MainManager.EnableProgram();
_checkedForUpdate = false; _checkedForUpdate = false;
//ActiveIcon = "../logo.ico"; //ActiveIcon = "../logo.ico";
if (General.Default.ShowOnStartup) if (General.Default.ShowOnStartup)
ShowWindow(); ShowWindow();
} }
public bool CanShowWindow => !_shellViewModel.IsActive; public bool CanShowWindow => !_shellViewModel.IsActive;
public bool CanHideWindow => _shellViewModel.IsActive; public bool CanHideWindow => _shellViewModel.IsActive;
public bool Enabled public bool Enabled
{ {
get { return _enabled; } get { return _enabled; }
set set
{ {
if (value == _enabled) return; if (value == _enabled) return;
_enabled = value; _enabled = value;
ToggleText = _enabled ? "Disable Artemis" : "Enable Artemis"; ToggleText = _enabled ? "Disable Artemis" : "Enable Artemis";
ActiveIcon = _enabled ? "../Resources/logo.ico" : "../Resources/logo-disabled.ico"; ActiveIcon = _enabled ? "../Resources/logo.ico" : "../Resources/logo-disabled.ico";
NotifyOfPropertyChange(() => Enabled); NotifyOfPropertyChange(() => Enabled);
} }
} }
public string ActiveIcon public string ActiveIcon
{ {
get { return _activeIcon; } get { return _activeIcon; }
@ -57,77 +57,77 @@ namespace Artemis.ViewModels
_activeIcon = value; _activeIcon = value;
NotifyOfPropertyChange(); NotifyOfPropertyChange();
} }
} }
public string ToggleText public string ToggleText
{ {
get { return _toggleText; } get { return _toggleText; }
set set
{ {
if (value == _toggleText) return; if (value == _toggleText) return;
_toggleText = value; _toggleText = value;
NotifyOfPropertyChange(() => ToggleText); NotifyOfPropertyChange(() => ToggleText);
} }
} }
public void Handle(ToggleEnabled message) public void Handle(ToggleEnabled message)
{ {
Enabled = message.Enabled; Enabled = message.Enabled;
} }
public void ToggleEnabled() public void ToggleEnabled()
{ {
if (Enabled) if (Enabled)
_shellViewModel.MainManager.DisableProgram(); _shellViewModel.MainManager.DisableProgram();
else else
_shellViewModel.MainManager.EnableProgram(); _shellViewModel.MainManager.EnableProgram();
} }
protected override void OnActivate() protected override void OnActivate()
{ {
base.OnActivate(); base.OnActivate();
NotifyOfPropertyChange(() => CanShowWindow); NotifyOfPropertyChange(() => CanShowWindow);
NotifyOfPropertyChange(() => CanHideWindow); NotifyOfPropertyChange(() => CanHideWindow);
} }
public void ShowWindow() public void ShowWindow()
{ {
if (!CanShowWindow) if (!CanShowWindow)
return; return;
// manually show the next window view-model // manually show the next window view-model
_windowManager.ShowWindow(_shellViewModel); _windowManager.ShowWindow(_shellViewModel);
NotifyOfPropertyChange(() => CanShowWindow); NotifyOfPropertyChange(() => CanShowWindow);
NotifyOfPropertyChange(() => CanHideWindow); NotifyOfPropertyChange(() => CanHideWindow);
if (_checkedForUpdate) if (_checkedForUpdate)
return; return;
_checkedForUpdate = true; _checkedForUpdate = true;
Updater.CheckForUpdate(_shellViewModel.MainManager.DialogService); Updater.CheckForUpdate(_shellViewModel.MainManager.DialogService);
} }
public void HideWindow() public void HideWindow()
{ {
if (!CanHideWindow) if (!CanHideWindow)
return; return;
_shellViewModel.TryClose(); _shellViewModel.TryClose();
NotifyOfPropertyChange(() => CanShowWindow); NotifyOfPropertyChange(() => CanShowWindow);
NotifyOfPropertyChange(() => CanHideWindow); NotifyOfPropertyChange(() => CanHideWindow);
} }
public void ExitApplication() public void ExitApplication()
{ {
_shellViewModel.MainManager.Shutdown(); _shellViewModel.MainManager.Shutdown();
Application.Current.Shutdown(); Application.Current.Shutdown();
// Sometimes you need to be rough. // Sometimes you need to be rough.
Environment.Exit(0); Environment.Exit(0);
} }
} }
} }

24
Artemis/Artemis/ViewModels/WelcomeViewModel.cs
View File

@ -1,13 +1,13 @@
using System.Diagnostics; using System.Diagnostics;
using Caliburn.Micro; using Caliburn.Micro;
namespace Artemis.ViewModels namespace Artemis.ViewModels
{ {
public class WelcomeViewModel : Screen public class WelcomeViewModel : Screen
{ {
public void NavigateTo(string url) public void NavigateTo(string url)
{ {
Process.Start(new ProcessStartInfo(url)); Process.Start(new ProcessStartInfo(url));
} }
} }
} }

28
Artemis/Artemis/Views/EffectsView.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Views namespace Artemis.Views
{ {
/// <summary> /// <summary>
/// Interaction logic for EffectsView.xaml /// Interaction logic for EffectsView.xaml
/// </summary> /// </summary>
public partial class EffectsView : UserControl public partial class EffectsView : UserControl
{ {
public EffectsView() public EffectsView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

28
Artemis/Artemis/Views/Flyouts/FlyoutSettingsView.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Views.Flyouts namespace Artemis.Views.Flyouts
{ {
/// <summary> /// <summary>
/// Interaction logic for FlyoutSettingsView.xaml /// Interaction logic for FlyoutSettingsView.xaml
/// </summary> /// </summary>
public partial class FlyoutSettingsView : UserControl public partial class FlyoutSettingsView : UserControl
{ {
public FlyoutSettingsView() public FlyoutSettingsView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

28
Artemis/Artemis/Views/GamesView.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Views namespace Artemis.Views
{ {
/// <summary> /// <summary>
/// Interaction logic for GamesView.xaml /// Interaction logic for GamesView.xaml
/// </summary> /// </summary>
public partial class GamesView : UserControl public partial class GamesView : UserControl
{ {
public GamesView() public GamesView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

28
Artemis/Artemis/Views/OverlaysView.xaml.cs
View File

@ -1,15 +1,15 @@
using System.Windows.Controls; using System.Windows.Controls;
namespace Artemis.Views namespace Artemis.Views
{ {
/// <summary> /// <summary>
/// Interaction logic for OverlaysView.xaml /// Interaction logic for OverlaysView.xaml
/// </summary> /// </summary>
public partial class OverlaysView : UserControl public partial class OverlaysView : UserControl
{ {
public OverlaysView() public OverlaysView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

24
Artemis/Artemis/Views/ShellView.xaml.cs
View File

@ -1,13 +1,13 @@
namespace Artemis.Views namespace Artemis.Views
{ {
/// <summary> /// <summary>
/// Interaction logic for ShellView.xaml /// Interaction logic for ShellView.xaml
/// </summary> /// </summary>
public partial class ShellView public partial class ShellView
{ {
public ShellView() public ShellView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

28
Artemis/Artemis/Views/SystemTrayView.xaml.cs
View File

@ -1,15 +1,15 @@
using MahApps.Metro.Controls; using MahApps.Metro.Controls;
namespace Artemis.Views namespace Artemis.Views
{ {
/// <summary> /// <summary>
/// Interaction logic for SystemTrayView.xaml /// Interaction logic for SystemTrayView.xaml
/// </summary> /// </summary>
public partial class SystemTrayView : MetroWindow public partial class SystemTrayView : MetroWindow
{ {
public SystemTrayView() public SystemTrayView()
{ {
InitializeComponent(); InitializeComponent();
} }
} }
} }

42
Artemis/Artemis/Views/WelcomeView.xaml.cs
View File

@ -1,22 +1,22 @@
using System.Diagnostics; using System.Diagnostics;
using System.Windows.Controls; using System.Windows.Controls;
using System.Windows.Navigation; using System.Windows.Navigation;
namespace Artemis.Views namespace Artemis.Views
{ {
/// <summary> /// <summary>
/// Interaction logic for WelcomeView.xaml /// Interaction logic for WelcomeView.xaml
/// </summary> /// </summary>
public partial class WelcomeView : UserControl public partial class WelcomeView : UserControl
{ {
public WelcomeView() public WelcomeView()
{ {
InitializeComponent(); InitializeComponent();
} }
private void Hyperlink_RequestNavigate(object sender, RequestNavigateEventArgs e) private void Hyperlink_RequestNavigate(object sender, RequestNavigateEventArgs e)
{ {
Process.Start("https://github.com/SpoinkyNL/Artemis/wiki/Frequently-Asked-Questions-(FAQ)"); Process.Start("https://github.com/SpoinkyNL/Artemis/wiki/Frequently-Asked-Questions-(FAQ)");
} }
} }
} }