ISettingsWindow CreateNewWindow()
{
var newWindow = new SettingsWindow(viewModel);
newWindow.Closed += WindowOnClosed;
return newWindow;
}
void ShowSettingsEventHandler(object sender, RoutedEventArgs e)
{
SettingsWindow settings = new SettingsWindow();
settings.DataContext = ServiceLocator.Resolve<SettingsViewModel>();
settings.ShowDialog();
}
private async void ShowSettings(object sender, RoutedEventArgs e)
{
var button = (Button)sender;
var settingsViewModel = (ISettingsViewModel)button.DataContext;
var window = new SettingsWindow { DataContext = settingsViewModel };
window.Show();
await AsyncHelper.ExecuteEventHandlerTask(this, settingsViewModel.Initialize);
}
public override bool TryGetBasicBotSettings(out BasicBotSettings botSettings)
{
var result = DialogHelper.ShowDialog(() =>
{
SettingsWindow settingsWindow = new SettingsWindow();
settingsWindow.Topmost = true;
return settingsWindow.ShowDialog();
});
botSettings = result;
return botSettings != null;
}
private void button1_Click(object sender, EventArgs e)
{
var settings = new SettingsWindow();
var result = settings.ShowDialog();
if (result.HasValue && result.Value)
{
var tmp = System.Threading.Interlocked.CompareExchange(ref OnSaved, null, null);
if (tmp != null)
{
tmp(this, EventArgs.Empty);
}
}
}
public void Execute(object parameter)
{
var targetWindow = parameter as BigVisibleCruiseWindow;
if (targetWindow == null)
{
//HACK: Couldn't figure out how to pass this in from XAML
targetWindow = Application.Current.MainWindow as BigVisibleCruiseWindow;
}
var settingsWindow = new SettingsWindow();
settingsWindow.Owner = targetWindow;
settingsWindow.ShowDialog();
targetWindow.ReInitializeWindow();
}
//public static event PropertyChangedEventHandler ClickThruChanged;
//public static event PropertyChangedEventHandler TccVisibilityChanged;
//public static event PropertyChangedEventHandler TccDimChanged;
//public static bool ClickThru
//{
// get => clickThru;
// set
// {
// if (clickThru != value)
// {
// clickThru = value;
// ClickThruChanged?.Invoke(null, new PropertyChangedEventArgs("ClickThruMode"));
// }
// }
//}
//public static bool IsTccVisible
//{
// get
// {
// if (SessionManager.Logged && !SessionManager.LoadingScreen && IsFocused)
// {
// isTccVisible = true;
// return isTccVisible;
// }
// else
// {
// isTccVisible = false || App.Debug;
// return isTccVisible;
// }
// }
// set
// {
// if (isTccVisible != value)
// {
// isTccVisible = value;
// NotifyVisibilityChanged();
// }
// }
//}
//public static bool IsFocused
//{
// get => isFocused;
// set
// {
// if (!FocusManager.Running) return;
// //if (isFocused == value)
// //{
// // //if(focusCount > 3)
// // //{
// // // return;
// // //}
// // return;
// //}
// isFocused = value;
// //if (isFocused)
// //{
// // focusCount++;
// //}
// //else
// //{
// // focusCount = 0;
// //}
// NotifyVisibilityChanged();
// }
//}
//public static bool SkillsEnded
//{
// get => skillsEnded;
// set
// {
// if (value == false)
// {
// _undimTimer.Stop();
// _undimTimer.Start();
// }
// if (skillsEnded == value) return;
// skillsEnded = value;
// CombatChanged?.Invoke();
// NotifyDimChanged();
// }
//}
//public static bool IsTccDim
//{
// get => SkillsEnded && !SessionManager.Encounter; // add more conditions here if needed
//}
public static void Init()
{
ForegroundManager = new ForegroundManager();
FocusManager.Init();
LoadWindows();
_contextMenu = new ContextMenu();
// ReSharper disable AssignNullToNotNullAttribute
DefaultIcon = new Icon(Application.GetResourceStream(new Uri("resources/tcc-logo.ico", UriKind.Relative))?.Stream);
ConnectedIcon = new Icon(Application.GetResourceStream(new Uri("resources/tcc-logo-on.ico", UriKind.Relative))?.Stream);
// ReSharper restore AssignNullToNotNullAttribute
TrayIcon = new NotifyIcon()
{
Icon = DefaultIcon,
Visible = true
};
TrayIcon.MouseDown += NI_MouseDown;
TrayIcon.MouseDoubleClick += TrayIcon_MouseDoubleClick;
var v = Assembly.GetExecutingAssembly().GetName().Version;
TrayIcon.Text = $"TCC v{v.Major}.{v.Minor}.{v.Build}";
var closeButton = new MenuItem()
{
Header = "Close"
};
closeButton.Click += (s, ev) => App.CloseApp();
_contextMenu.Items.Add(closeButton);
//_undimTimer.Elapsed += _undimTimer_Elapsed;
SettingsWindow = new SettingsWindow();
if (Settings.UseHotkeys)
{
KeyboardHook.Instance.RegisterKeyboardHook();
}
//TccWindow.RecreateWindow += TccWindow_RecreateWindow;
}
private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
if (Data.ShutdownStarted)
{
if (!shutdownCompleted)
{
e.Cancel = true;
}
return;
}
e.Cancel = true;
Data.ShutdownStarted = true;
ProxyUiWindow.CloseInstance();
SettingsWindow.CloseInstance();
ComponentEngine.Instance.Stop().ContinueWith(bla =>
{
Dispatcher.BeginInvoke(new Action(() =>
{
if (bla.Result.Count > 0)
{
MessageBox.Show($"The following errors occured while trying to restore your system:\r\n{string.Join("\r\n", bla.Result)}", "Shutdown Errors", MessageBoxButton.OK, MessageBoxImage.Warning);
}
shutdownCompleted = true;
Close();
Task.Run(async() =>
{
await Task.Delay(5000);
Application.Current.Shutdown(0);
});
}));
});
}
public MainWindow()
{
InitializeComponent();
_updateTime = new Timer {
Interval = 1000
};
_currentDateTime = new DateTime();
_aboutWindow = new About();
_updateTime.Elapsed += UpdateTime_Elapsed;
_updateTime.Start();
_path = (new FileInfo(Assembly.GetEntryAssembly().Location)).Directory + "//TimeOverlaySettings.xml";
//If settings save exists, deserialize it to SettingsWindow
if (File.Exists(_path)) {
var reader = new XmlSerializer(typeof (SettingsInfo));
var file = new StreamReader(_path);
_settingsWindowAccess = new SettingsWindow((SettingsInfo) reader.Deserialize(file));
}
else _settingsWindowAccess = new SettingsWindow();
_settingsWindowAccess.Settings.CloseApplication = false;
_settingsWindowAccess.Hide();
}
/// <summary>
/// Opens a new settings window or destroys and recreates one if it is already open.
/// Additionally we initiallise some of the data required for the bindings in the settings (Populate the midi devices).
/// </summary>
public void OpenSettingsWindow()
{
if (settingsWindow?.IsVisible ?? false)//if a settings window is already visible close it and make a new one
{
settingsWindow.Close();
}
settingsWindow = new SettingsWindow();
settingsWindow.DataContext = this;
settingsWindow.Show();
//Get available midi devices
MidiInputDevices.Clear();
foreach (IMidiPortDetails device in MidiManager.GetMidiInputDevices())
{
MidiInputDevices.Add(device);
}
MidiOutputDevices.Clear();
foreach (IMidiPortDetails device in MidiManager.GetMidiOutputDevices())
{
MidiOutputDevices.Add(device);
}
}
public void AdvancedSetup_Click(object sender, RoutedEventArgs e)
{
try
{
if (_settingsWindow == null)
{
// cjm-sep17 -- some menu items need to be disabled
// since the linphoneCore obj is null at this time
App.CurrentAccount.DisableAudioCodecs = true;
_settingsWindow = _mainWnd.BuildSettingsWindow();
_settingsWindow.GeneralSettings.disableElements();
_settingsWindow.AudioVideoSettings.disableElements();
_settingsWindow.AccountSettings.disableElements();
_settingsWindow.AdvancedSettings.disableElements();
_settingsWindow.AccountSettings.updateProviders += InitializeToProvider;
}
_settingsWindow.Show();
}
catch (Exception ex)
{
return;
}
}
public Settings()
{
if (File.Exists(Constants.SETTINGS_FILE))
{
UpdateSettings();
}
else
{
SaveSettings(EnableFullscreenCapture, EnableGIF, SaveAllImages, SaveDirectory, EnableImageShortcut, CaptureImageShortcutKeys, EnableGIFShortcut,
CaptureGIFShortcutKeys, EnablePrintScreen, EnableSound);
}
if (File.Exists(Constants.CONFIG_FILE))
{
return;
}
Logging.Log($"This must be your first run. Please input your server's image upload host location. An example php host file is located at {Constants.GITHUB}.");
var settingsWindow = new SettingsWindow(this, new Config());
settingsWindow.Show();
}
public void WindowLoaded(object sender, RoutedEventArgs e)
{
View.Loaded -= WindowLoaded;
if (!Configuration.IsInitialized)
{
View.Hide();
using (var settingsWindows = new SettingsWindow())
{
settingsWindows.ShowDialog();
}
View.Show();
}
var loadCollectionsAction = ActionManager.LoadCollections as ICommand;
if (loadCollectionsAction != null && loadCollectionsAction.CanExecute(null))
{
loadCollectionsAction.Execute(null);
}
}
public void OpenSettings()
{
SettingsWindow window = new SettingsWindow();
window.Owner = Application.Current.MainWindow;
// var test = Application.Current.Resources["settingsDialog"];
//BaseMetroDialog dialog = (BaseMetroDialog)Application.Current.Resources["settingsDialog"];
//dialog.DataContext = this;
//dialog = dialog.ShowModalDialogExternally();
// await TaskEx.Delay(5000);
// await dialog.RequestCloseAsync();
// this.Save();
window.DataContext = this;
bool? result = window.ShowDialog();
if (result == true)
{
this.Save();
}
else
{
this.Reset();
}
}
public async Task Loaded(object sender, RoutedEventArgs args)
{
var config = RegConfig.Load();
if (config == null)
{
// ReSharper disable once ExpressionIsAlwaysNull
var settingsVm = new SettingsVm(config);
var settingsWindow = new SettingsWindow(settingsVm);
if (settingsWindow.ShowDialog() == false)
{
_mainWindow.Close();
}
else
{
config = settingsVm.SqlConfig;
RegConfig.Save(config);
}
}
_repositoryDb = new RepositoryDb();
_repositoryDb.Connect(config);
}
private void UpdateGamepadRemap(SettingsWindow settingsWindow, bool cancel)
{
// Cancel remapping with escape
if (cancel ||
Global.Input.KeyPressed(Keys.Escape))
{
Global.game_system.play_se(System_Sounds.Cancel);
MenuSettingSelected = false;
settingsWindow.CancelSetting();
}
else
{
var pressed_keys = Global.Input.PressedButtons();
if (pressed_keys.Any())
{
bool success = false;
foreach (Buttons button in Input.REMAPPABLE_BUTTONS
.Intersect(pressed_keys))
{
if (settingsWindow.RemapInput(button))
{
Global.game_system.play_se(System_Sounds.Confirm);
MenuSettingSelected = false;
settingsWindow.ConfirmSetting();
IgnoreInputs();
success = true;
break;
}
}
if (!success)
{
Global.game_system.play_se(System_Sounds.Buzzer);
}
}
}
}
void AppInitialize(object sender, StartupEventArgs e)
{
InitializeMappings();
DiContainer = InitializeDiContainer();
// Setup FileLocator:
if (FileLocator.MustBeConfigured())
{
MessageBox.Show("Please specify folders for MusCat to look for media files");
// Disable shutdown when the dialog is closed
Current.ShutdownMode = ShutdownMode.OnExplicitShutdown;
var settingsWindow = new SettingsWindow();
if (settingsWindow.ShowDialog() == false)
{
MessageBox.Show("Default path will be used: " + FileLocator.Pathlist.FirstOrDefault());
}
}
FileLocator.LoadConfiguration();
// Normal shutdown
Current.ShutdownMode = ShutdownMode.OnLastWindowClose;
// Show main window:
var mainWindow = new MainWindow
{
DataContext = DiContainer.Resolve <MainViewModel>()
};
mainWindow.Show();
}
private static void OnRegistriesAdded(int registriesAddedCount)
{
void WaitForPackageManagerProjectSettings()
{
var projectSettings = SettingsWindow.FindWindowByScope(SettingsScope.Project);
if (projectSettings == null || !projectSettings.hasFocus || !(projectSettings.GetCurrentProvider() is PackageManagerProjectSettingsProvider))
{
return;
}
EditorApplication.update -= WaitForPackageManagerProjectSettings;
var servicesContainer = ServicesContainer.instance;
var packageManagerSettingsProxy = servicesContainer.Resolve <PackageManagerProjectSettingsProxy>();
var applicationProxy = servicesContainer.Resolve <ApplicationProxy>();
packageManagerSettingsProxy.scopedRegistriesSettingsExpanded = true;
var message = registriesAddedCount.Pluralize(
" now available in the Package Manager.",
"A new scoped registry is", $"{registriesAddedCount} new scoped registries are",
string.Empty, string.Empty);
var title = registriesAddedCount.Pluralize("Importing ",
string.Empty, string.Empty,
"a scoped registry", $"{registriesAddedCount} scoped registries");
if (applicationProxy.DisplayDialog("onRegistriesAddedPopup", L10n.Tr(title), L10n.Tr(message), L10n.Tr("Read more"), L10n.Tr("Close")))
{
applicationProxy.OpenURL($"https://docs.unity3d.com/{applicationProxy.shortUnityVersion}/Documentation/Manual/upm-scoped.html");
}
}
EditorApplication.update += WaitForPackageManagerProjectSettings;
SettingsService.OpenProjectSettings("Project/Package Manager");
}
public static bool AskForFileWorkshop(out string result, Window OwnerWindow)
{
bool OperationAllowed = false;
bool cancel = false;
String fwPath = "";
do
{
fwPath = Properties.Settings.Default.PathToFileWorkshop;
OperationAllowed = !(fwPath == String.Empty || !System.IO.File.Exists(fwPath));
if (!OperationAllowed)
{
var mbr = System.Windows.MessageBox.Show(
"Путь к приложению \"1С:Работа с файлами\" не задан или задан неверно. Задать его сейчас?",
"V8 Reader",
System.Windows.MessageBoxButton.YesNo,
System.Windows.MessageBoxImage.Question);
if (mbr == System.Windows.MessageBoxResult.Yes)
{
var mainWnd = new SettingsWindow();
mainWnd.Owner = OwnerWindow;
mainWnd.ShowDialog();
}
else if (mbr == System.Windows.MessageBoxResult.No)
{
cancel = true;
}
}
}while (!OperationAllowed && !cancel);
result = OperationAllowed ? fwPath : null;
return(OperationAllowed);
}
private void Settings_mi_Click(object sender, RoutedEventArgs e)
{
/// Показать окно настройки
SettingsWindow settingswnd = new SettingsWindow();
if (settingswnd != null)
{
Settings temp = new Settings();
temp.token = Settings.Default.token;
temp.width = Settings.Default.width;
temp.height = Settings.Default.height;
temp.maximized = Settings.Default.maximized;
temp.authorizeclose = Settings.Default.authorizeclose;
temp.updatesettings = Settings.Default.updatesettings;
temp.updateurl = Settings.Default.updateurl;
settingswnd.Owner = this;
if (settingswnd.ShowDialog() == true)
{
Settings.Default.Save();
}
else
{
Settings.Default.token = temp.token;
Settings.Default.width = temp.width;
Settings.Default.height = temp.height;
Settings.Default.maximized = temp.maximized;
Settings.Default.authorizeclose = temp.authorizeclose;
Settings.Default.updatesettings = temp.updatesettings;
Settings.Default.updateurl = temp.updateurl;
Settings.Default.Save();
}
}
}
/// <summary>
/// Shows the tool window when the menu item is clicked.
/// </summary>
/// <param name="sender">The event sender.</param>
/// <param name="e">The event args.</param>
private void Execute(object sender, EventArgs e)
{
ThreadHelper.ThrowIfNotOnUIThread();
// Get the instance number 0 of this tool window. This window is single instance so this instance
// is actually the only one.
// The last flag is set to true so that if the tool window does not exists it will be created.
//var window = this.package.FindToolWindow(typeof(OpenSettingsWindow), 0, true);
//if ((null == window) || (null == window.Frame))
//{
// throw new NotSupportedException("Cannot create tool window");
//}
//IVsWindowFrame windowFrame = (IVsWindowFrame)window.Frame;
BSMTSettingsManager.Instance.Reload();
var settingsDialog = new SettingsWindow();
var returnedTrue = settingsDialog.ShowDialog() ?? false;
if (returnedTrue)
{
BSMTSettingsManager.Instance.Store(settingsDialog.ReturnSettings);
}
}
public MainWindowViewModel(MainWindowModel model)
{
this.model = model;
NewTootBoxViewModel = new NewTootBoxViewModel(this.model.InReplyTo, this.model.Client);
TabViewModels = this.model.Tabs.ToReadOnlyReactiveCollection(p => TabContentViewModelBase.FromParam(p, this.model.InReplyTo, this.model.Tabs, this.model.Client));
SelectedTabIndex = this.model.Tabs.SelectedIndex;
OpenSettingsCommand = new ReactiveCommand()
.WithSubscribe(() =>
{
var w = new SettingsWindow(new SettingsViewModel(this.model.Tabs));
((SettingsViewModel)w.DataContext).Tabs = this.model.Tabs;
w.ShowDialog();
});
CloseTabCommand = new ReactiveCommand <TabContentViewModelBase>()
.WithSubscribe(vm =>
{
this.model.Tabs.CloseTab(TabViewModels.IndexOf(vm));
});
NextTabCommand = new ReactiveCommand()
.WithSubscribe(this.model.Tabs.SwitchToNextTab);
PrevTabCommand = new ReactiveCommand()
.WithSubscribe(this.model.Tabs.SwitchToPrevTab);
}
private void ShowSettings()
{
//Show the settings window.
SettingsWindow window = new SettingsWindow();
if (window.ShowDialog() != DialogResult.OK)
{
return;
}
//Apply settings.
if (window.SettingsChanged)
{
_graphicsManager.PreferredBackBufferWidth = (int)(SystemInformation.VirtualScreen.Width * Settings.Instance.BackBufferWidthFactor);
_graphicsManager.PreferredBackBufferHeight = (int)(SystemInformation.VirtualScreen.Height * Settings.Instance.BackBufferHeightFactor);
TargetElapsedTime = TimeSpan.FromSeconds(1.0F / Settings.Instance.FrameRate);
_graphicsManager.ApplyChanges();
}
//Apply new layout.
if (window.LayoutChanged)
{
if (_controllers != null)
{
//Dispose old controller rendertargets.
foreach (var controller in _controllers)
{
controller.RenderTarget.Dispose();
}
_controllers.Clear();
}
//Initialize the new layout.
InitializeControllers();
}
}
private void OnShowSettings()
{
try
{
Logger.WriteDebug("RIS: ShowSettingsCommand");
//Stop Services and Views
ServiceFactory.Stop();
//Show settingWindow
var _settingsWindow = new SettingsWindow();
_settingsWindow.ShowDialog();
//Start Services and Views
ServiceFactory.Start();
ViewModelFactory.Initialize();
}
catch (Exception ex)
{
Logger.WriteError(MethodBase.GetCurrentMethod(), ex);
MessageBox.Show("Leider ist ein Fehler aufgetreten:\r\n" + ex.Message, MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
private void InitNotifyIcon(NotifyIcon icon)
{
icon.Icon = PowerSupplyNotifier.Properties.Resources.app_icon;
icon.Visible = true;
icon.MouseClick += (_, args) =>
{
if (args.Button == MouseButtons.Left)
{
SettingsWindow.ShowUnique();
}
};
icon.ContextMenuStrip = new ContextMenuStrip
{
Items =
{
new ToolStripMenuItem(StringResources.Settings_Title, null, (_, __) => SettingsWindow.ShowUnique()),
new ToolStripMenuItem(StringResources.AboutProgram_Title, null, (_, __) => AboutProgram.ShowUnique()),
new ToolStripSeparator(),
new ToolStripMenuItem(StringResources.Exit, null, (_, __) => Shutdown(0))
}
};
}
public override void StartClientSide(ICoreClientAPI api)
{
Files.RegisterFile("wpex-global-config.data", FileScope.Global);
Files.RegisterFile("wpex-default-waypoints.data", FileScope.Global);
Files.RegisterFile("wpex-custom-waypoints.data", FileScope.World);
Files.RegisterFile("wpex-settings.data", FileScope.World);
Settings = Api.GetModFile("wpex-settings.data").ParseJsonAsObject <WorldSettings>();
RegisterChatCommands(api);
var settingsWindow = new SettingsWindow(api);
api.Input.RegisterHotKey("wpex-settings", "Waypoint Extensions Settings", GlKeys.F7,
HotkeyType.GUIOrOtherControls);
api.Input.SetHotKeyHandler("wpex-settings", _ =>
{
api.Event.RegisterCallback(_ =>
{
settingsWindow.ComposeWindow();
settingsWindow.Toggle();
}, 100);
return(true);
});
}
public SettingsWindowViewModel(SettingsWindow window, LocalizationContext context,
ref AppConfig config,
ApplicationStatusManager manager,
ThemeManager mainThemeManager,
ThemeManager settingsThemeManager)
{
_window = window;
this.LocalizationContext = context;
_settingsThemeManager = settingsThemeManager;
_mainThemeManager = mainThemeManager;
_config = config;
_newConfig = AppConfig.DeepCopy(_config);
_applicationStatusManager = manager;
this.WhenAnyValue(x => x.ThemeIndex)
.Skip(1)
.Subscribe(x => SwitchSettingsTheme());
SetupCommands();
MLUrl = _newConfig.MlModelConfig.Url;
UpdateModelStatusCommand.Execute().Subscribe();
}
private void MenuItemSettings_Click(object sender, RoutedEventArgs e)
{
if (_termsOfUseWindow != null)
{
return;
}
if (_settingsWindow != null)
{
_settingsWindow.Activate();
return;
}
_settingsWindow = new SettingsWindow();
StaticHelper.CenterOnScreen(_settingsWindow);
bool?dialogResult = _settingsWindow.ShowDialog();
if (dialogResult.HasValue && dialogResult.Value == true)
{
ApplySettings();
}
_settingsWindow = null;
}
public void OpenSettings()
{
SettingsWindow settingsWindow = new SettingsWindow();
settingsWindow.Show();
}
private static void OpenSettings()
{
if (SettingsWindow == null)
{
SettingsWindow = (SettingsWindow)CreateInstance("SettingsWindow");
}
SettingsWindow.ShowWindow();
}
private void MenuItem_Click_2(object sender, RoutedEventArgs e)
{
SettingsWindow settingsWindow = new SettingsWindow();
settingsWindow.ShowDialog();
}
private void OnSettingsClick()
{
SettingsWindow setWin = new SettingsWindow();
setWin.Show();
}
private void SettingsButtonClick(object sender, RoutedEventArgs e)
{
SettingsWindow settings = new SettingsWindow {Owner = this};
settings.ShowDialog();
}
private void OpenSettings()
{
settingsWindow = new SettingsWindow(Settings);
settingsWindow.Closed += CloseSettingsWindow;
settingsWindow.ApplyClicked += HandleApply;
OpenSettingsCommand.RaiseCanExecuteChanged();
settingsWindow.Show();
}
private void SettingsButton_Click(object sender, RoutedEventArgs e)
{
SettingsWindow el = new SettingsWindow();
el.Owner = this;
el.ShowDialog();
}
private void OnExit(object sender, System.ComponentModel.CancelEventArgs e)
{
DataModel.QuickSearch.Terminate();
DataModel.ServerSession.OnlineMode = false;
if (m_SettingsWindow != null)
{
m_SettingsWindow.Close();
m_SettingsWindow = null;
}
if (m_LicenseWindow != null)
{
m_LicenseWindow.Close();
m_LicenseWindow = null;
}
if (m_AboutWindow != null)
{
m_AboutWindow.Close();
m_AboutWindow = null;
}
SaveWindowState();
}
public MainWindow()
{
InitializeComponent();
this.ShowCloseButton = false;
this.Hide();
//this.WindowState = WindowState.Normal;
//this.Show();
SettingsWindow sw = new SettingsWindow();
sw.Hide();
/// Enumerate Displays
var MyInfoEnumProc = new NativeMethods.MonitorEnumDelegate(MonitorEnum);
NativeMethods.EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, MyInfoEnumProc, IntPtr.Zero);
ReadInfo(_monitorCollection[selectedMonitor]);
foreach (Monitor monitor in _monitorCollection)
{
monCollection.Add(monitor.Name);
}
var desktopWorkingArea = SystemParameters.WorkArea;
this.Left = desktopWorkingArea.Right - this.Width;
this.Top = desktopWorkingArea.Bottom - this.Height;
Console.WriteLine(selectedMonitor);
/// Create a tray icon & menu
NotifyIcon ni = new NotifyIcon();
ContextMenu cm = new ContextMenu();
MenuItem mi1 = new MenuItem();
MenuItem mi2 = new MenuItem();
ni.Icon = new System.Drawing.Icon("main.ico");
ni.Visible = true;
ni.Click +=
delegate (object sender, EventArgs e)
{
MouseEventArgs me = (MouseEventArgs)e;
if (me.Button == MouseButtons.Left)
{
if (WindowState == WindowState.Minimized)
{
this.WindowState = WindowState.Normal;
this.Show();
}
else if (WindowState == WindowState.Normal)
{
this.Hide();
this.WindowState = WindowState.Minimized;
}
}
};
ni.ContextMenu = cm;
cm.MenuItems.AddRange(
new MenuItem[] { mi2 });
mi2.Index = 0;
mi2.Text = "C&onfiguration";
mi2.Click +=
delegate (object sender, EventArgs args)
{
sw.WindowStartupLocation = WindowStartupLocation.CenterScreen;
if (sw.Visibility == Visibility.Hidden)
{
sw.WindowState = WindowState.Normal;
sw.ShowDialog();
} //////!!!!!!!!!!!!!!!!!!!! ON CLOSE SET TO HIDDEN
};
cm.MenuItems.AddRange(
new MenuItem[] { mi1 });
mi1.Index = 1;
mi1.Text = "E&xit";
mi1.Click +=
delegate (object sender, EventArgs args)
{
System.Windows.Application.Current.MainWindow.Hide();
System.Windows.Application.Current.Shutdown();
};
}
void Awake()
{
this.Log("Awake");
configFilename = IOUtils.GetFilePathFor(this.GetType(), "FuelBalancer.cfg");
settings = new Settings();
settingsWindow = new SettingsWindow(settings);
helpWindow = new HelpWindow();
mainWindow = new MainWindow(this, settings, settingsWindow, helpWindow);
button = new ButtonWrapper(new Rect(Screen.width * 0.7f, 0, 32, 32),
"ThunderAerospace/TacFuelBalancer/Textures/button", "FB",
"TAC Fuel Balancer", OnIconClicked);
resources = new Dictionary<string, ResourceInfo>();
numberOfParts = 0;
vesselSituation = Vessel.Situations.PRELAUNCH;
}
/// <summary>
/// Opens the setting window.
/// </summary>
private void OpenSettingWindow()
{
// HideSettings();
SettingsWindow set = new SettingsWindow();
set.Show();
//Dashboard MW = new Dashboard();
//MW.Close();
//IsSystemSettingVisible = Visibility.Visible;
//Dashboard._Dashboard.Close();
//ViewModelLocator.Cleanup(ViewModelType.MainWindow);
}
private void settingsButton_Click(object sender, RoutedEventArgs e)
{
SettingsWindow settings = new SettingsWindow();
settings.ConfigHandler = _configHandler;
settings.ShowDialog();
if (settings.ReloadConfig)
{
InitConfig();
}
}
private static void SettingsPopup()
{
using (var form = new SettingsWindow())
{
form.Show();
}
}
/// <summary>
/// Opens the settings window
/// </summary>
private void OpenSettingsOnClick(object sender, RoutedEventArgs e)
{
if (Application.Current.Windows.OfType<SettingsWindow>().Any())
return; //Check if a settings window is already open
SettingsWindow settingsWindow = new SettingsWindow {Owner = this};
settingsWindow.Show();
}
void UpdateTimerTick(object sender, EventArgs e)
{
((DispatcherTimer) sender).Stop();
bool reloadVersions = AppSettings.UpdateVersions;
if (AppSettings.FirstStart)
{
// get application settings from previous version, if possible
AppSettings.Upgrade();
if (AppSettings.FirstStart)
{
SettingsWindow settings = new SettingsWindow {Owner = this};
settings.ShowDialog();
}
else
{
if (AppSettings.ShowChangeLog)
{
ChangelogViewer changeLog = new ChangelogViewer {Owner = this};
changeLog.ShowDialog();
}
string msg = Processing.GetResourceString("update_done");
Xceed.Wpf.Toolkit.MessageBox.Show(msg,
"Update",
MessageBoxButton.OK,
MessageBoxImage.Information);
reloadVersions = true;
}
}
if (reloadVersions)
{
BackgroundWorker reloadV = new BackgroundWorker
{
WorkerReportsProgress = true,
WorkerSupportsCancellation = false
};
reloadV.RunWorkerCompleted += (o, args) => RunUpdateWorker();
reloadV.DoWork += (o, args) =>
{
BackgroundWorker bw = (BackgroundWorker) o;
bw.ReportProgress(-5);
Processing.GetAppVersions();
bw.ReportProgress(-6);
};
reloadV.ProgressChanged += (o, args) =>
{
switch (args.ProgressPercentage)
{
case -5:
string msg = Processing.GetResourceString("check_versions");
StatusItem.Text = msg;
StatusItem.FontWeight = FontWeights.Bold;
StatusItemHeader.Background = Brushes.Yellow;
break;
case -6:
StatusItem.Text = string.Empty;
StatusItem.FontWeight = FontWeights.Normal;
StatusItemHeader.Background = Brushes.Transparent;
break;
}
};
reloadV.RunWorkerAsync();
}
else
RunUpdateWorker();
}
protected override void Awake()
{
//toolbar
if (ToolbarManager.ToolbarAvailable)
{
_toolbarItem = AddComponent<LaunchCountDownToolbar>();
}
Visible = !ToolbarManager.ToolbarAvailable;
if (LaunchCountdownConfig.Instance.Info.IsLoaded)
{
WindowRect = LaunchCountdownConfig.Instance.Info.WindowPosition;
}
else
{
WindowRect = new Rect(0, 0, 459, 120);
WindowRect.CenterScreen();
}
WindowStyle = StyleFactory.MainWindowStyle;
_launchSequenceWindow = AddComponent<LaunchSequenceWindow>();
_launchSequenceWindow.WindowStyle = StyleFactory.LaunchSequenceStyle;
_launchSequenceWindow.OnClosed += WindowOnClosed;
_settingsWindow = AddComponent<SettingsWindow>();
_settingsWindow.WindowStyle = StyleFactory.SettingsStyle;
_settingsWindow.OnClosed += WindowOnClosed;
_launcher = AddComponent<LaunchControl>();
_launcher.OnTick += _launcher_OnTick;
_launcher.OnVesselLaunched += _launcher_OnVesselLaunched;
_launcher.OnVesselAborted += _launcher_OnVesselAborted;
LaunchCountdownConfig.Instance.Info.OnChanged += Instance_OnChanged;
}
public override bool? Show()
{
SettingsWindow window = new SettingsWindow();
window.Owner = Owner;
SettingsInfoCopier.Copy(window.Settings, this);
bool? result = window.ShowDialog();
if (result.GetValueOrDefault())
{
SettingsInfoCopier.Copy(this, window.Settings);
}
return result;
}
private void SettingButton_Click(object sender, RoutedEventArgs e)
{
Window settings = new SettingsWindow();
settings.ShowDialog();
}
private void ShowSettings(object o)
{
SettingsWindow.ShowSingle();
}
private void CloseSettingsWindow(object sender, EventArgs e)
{
var window = (SettingsWindow)sender;
window.Closed -= CloseSettingsWindow;
window.ApplyClicked -= HandleApply;
settingsWindow = null;
OpenSettingsCommand.RaiseCanExecuteChanged();
}
// ========== Settings ==========
protected void OnOptionsActionActivated(object sender, EventArgs e)
{
var settingsWindow = new SettingsWindow();
settingsWindow.Show();
}
void DrawOptions()
{
if (currentMode.headerState.options == TimelineModeGUIState.Hidden || state.editSequence.asset == null)
{
return;
}
using (new EditorGUI.DisabledScope(currentMode.headerState.options == TimelineModeGUIState.Disabled))
{
var rect = new Rect(position.width - WindowConstants.cogButtonWidth, 0, WindowConstants.cogButtonWidth, WindowConstants.timeAreaYPosition);
if (EditorGUI.DropdownButton(rect, DirectorStyles.optionsCogIcon, FocusType.Keyboard, EditorStyles.toolbarButton))
{
GenericMenu menu = new GenericMenu();
menu.AddItem(EditorGUIUtility.TrTextContent("Preferences Page..."), false, () => SettingsWindow.Show(SettingsScope.User, "Preferences/Timeline"));
menu.AddSeparator("");
menu.AddItem(EditorGUIUtility.TrTextContent("Seconds"), !state.timeInFrames, ChangeTimeCode, "seconds");
menu.AddItem(EditorGUIUtility.TrTextContent("Frames"), state.timeInFrames, ChangeTimeCode, "frames");
menu.AddSeparator("");
TimeAreaContextMenu.AddTimeAreaMenuItems(menu, state);
menu.AddSeparator("");
bool standardFrameRate = false;
for (int i = 0; i < TimelineProjectSettings.framerateValues.Length; i++)
{
standardFrameRate |= AddStandardFrameRateMenu(menu, "Frame Rate/" + TimelineProjectSettings.framerateLabels[i], TimelineProjectSettings.framerateValues[i]);
}
if (standardFrameRate)
{
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Frame Rate/Custom"));
}
else
{
menu.AddItem(EditorGUIUtility.TrTextContent("Frame Rate/Custom (" + state.editSequence.frameRate + ")"), true, () => {});
}
menu.AddSeparator("");
if (state.playRangeEnabled)
{
menu.AddItem(EditorGUIUtility.TrTextContent("Play Range Mode/Loop"), state.playRangeLoopMode, () => state.playRangeLoopMode = true);
menu.AddItem(EditorGUIUtility.TrTextContent("Play Range Mode/Once"), !state.playRangeLoopMode, () => state.playRangeLoopMode = false);
}
else
{
menu.AddDisabledItem(EditorGUIUtility.TrTextContent("Play Range Mode"));
}
if (Unsupported.IsDeveloperMode())
{
menu.AddSeparator("");
menu.AddItem(EditorGUIUtility.TrTextContent("Show Snapping Debug"), SnapEngine.displayDebugLayout,
() => SnapEngine.displayDebugLayout = !SnapEngine.displayDebugLayout);
menu.AddItem(EditorGUIUtility.TrTextContent("Debug TimeArea"), false,
() =>
Debug.LogFormat("translation: {0} scale: {1} rect: {2} shownRange: {3}", m_TimeArea.translation, m_TimeArea.scale, m_TimeArea.rect, m_TimeArea.shownArea));
menu.AddItem(EditorGUIUtility.TrTextContent("Edit Skin"), false, () => Selection.activeObject = DirectorStyles.Instance.customSkin);
menu.AddItem(EditorGUIUtility.TrTextContent("Show QuadTree Debugger"), state.showQuadTree,
() => state.showQuadTree = !state.showQuadTree);
}
menu.DropDown(rect);
}
}
}
public override void DoWindowContents(Rect inRect)
{
base.DoWindowContents(inRect);
float padding = 5f;
float btnWidth = 100f;
float btnHeight = 30f;
var rectBtn = new Rect(padding, 0, btnWidth, btnHeight);
if (Widgets.ButtonText(rectBtn, "Chat Window") && !Find.WindowStack.TryRemove(typeof(ChatWindow), true))
{
ChatWindow chatwnd = new ChatWindow();
Toolkit.client.activeChatWindow = chatwnd;
Find.WindowStack.Add(chatwnd);
}
rectBtn.x += btnWidth + padding;
if (Widgets.ButtonText(rectBtn, "Events"))
{
Type type = typeof(StoreIncidentsWindow);
Find.WindowStack.TryRemove(type);
Window window = new StoreIncidentsWindow();
Find.WindowStack.Add(window);
}
rectBtn.x += btnWidth + padding;
if (Widgets.ButtonText(rectBtn, "Items"))
{
Type type = typeof(StoreItemsWindow);
Find.WindowStack.TryRemove(type);
Window window = new StoreItemsWindow();
Find.WindowStack.Add(window);
}
rectBtn.x += btnWidth + padding;
if (Widgets.ButtonText(rectBtn, "Settings"))
{
Mod mod = LoadedModManager.GetMod(typeof(TwitchToolkit));
Type type = typeof(SettingsWindow);
Find.WindowStack.TryRemove(type);
Window window = new SettingsWindow(mod);
Find.WindowStack.Add(window);
}
rectBtn.x += btnWidth + padding;
if (Toolkit.client != null && Toolkit.client.Connected)
{
if (Widgets.ButtonText(rectBtn, "TwitchToolkitReconnect".Translate()))
{
Toolkit.client.Reconnect();
Helper.playerMessages = new List <string>();
Purchase_Handler.viewerNamesDoingVariableCommands = new List <string>();
}
}
else
{
if (Widgets.ButtonText(rectBtn, "TwitchToolkitConnect".Translate()))
{
ToolkitIRC.NewInstance();
}
}
rectBtn.x = padding;
rectBtn.y += padding + 28f;
if (Widgets.ButtonText(rectBtn, "Name Queue"))
{
Type type = typeof(QueueWindow);
Find.WindowStack.TryRemove(type);
Window window = new QueueWindow();
Find.WindowStack.Add(window);
}
rectBtn.x += btnWidth + padding;
if (Widgets.ButtonText(rectBtn, "Viewers"))
{
Type type = typeof(Window_Viewers);
Find.WindowStack.TryRemove(type);
Window window = new Window_Viewers();
Find.WindowStack.Add(window);
}
rectBtn.x += btnWidth + padding;
if (Widgets.ButtonText(rectBtn, "Debug Fix"))
{
Helper.playerMessages = new List <string>();
Purchase_Handler.viewerNamesDoingVariableCommands = new List <string>();
}
rectBtn.x += btnWidth + padding;
if (Widgets.ButtonText(rectBtn, "Tracker"))
{
Window_Trackers window = new Window_Trackers();
Find.WindowStack.TryRemove(window.GetType());
Find.WindowStack.Add(window);
}
rectBtn.x += btnWidth + padding;
if (Widgets.ButtonText(rectBtn, "Commands"))
{
Window_Commands window = new Window_Commands();
Find.WindowStack.TryRemove(window.GetType());
Find.WindowStack.Add(window);
}
//rectBtn.x += btnWidth + padding;
//if (Widgets.ButtonText(rectBtn, "Socket"))
//{
// Window_SocketClient window = new Window_SocketClient();
// Find.WindowStack.TryRemove(window.GetType());
// Find.WindowStack.Add(window);
//}
//rectBtn.x += btnWidth + padding;
//if (Widgets.ButtonText(rectBtn, "Badges"))
//{
// TwitchBadges.GetBadgeInfo();
//}
var rectMessages = new Rect(padding, rectBtn.height + 36f, inRect.width - (padding * 3), 180f);
if (Toolkit.client != null)
{
Widgets.TextArea(rectMessages, string.Join("\r\n", Toolkit.client.MessageLog), true);
}
btnWidth = inRect.width - (padding / 2);
rectBtn = new Rect(padding, rectMessages.y + rectMessages.height, btnWidth, btnHeight);
Widgets.CheckboxLabeled(rectBtn, "TwitchToolkitEarningCoins".Translate(), ref ToolkitSettings.EarningCoins);
}
void Awake()
{
Debug.Log("TAC Life Support (LifeSupportController) [" + this.GetInstanceID().ToString("X") + "][" + Time.time + "]: Awake");
Instance = this;
knownCrew = new Dictionary<string, CrewMemberInfo>();
knownVessels = new Dictionary<Guid, VesselInfo>();
settings = new Settings();
settingsWindow = new SettingsWindow(settings);
rosterWindow = new RosterWindow();
monitoringWindow = new LifeSupportMonitoringWindow(this, settings, settingsWindow, rosterWindow);
icon = new Icon<LifeSupportController>(new Rect(Screen.width * 0.75f, 0, 32, 32), "icon.png", "LS",
"Click to show the Life Support Monitoring Window", OnIconClicked);
configFilename = IOUtils.GetFilePathFor(this.GetType(), "LifeSupport.cfg");
}
private void Settings(object o)
{
settings = new SettingsWindow(this);
settings.ShowDialog();
}
public void OnChildWindowClosing(Window window)
{
if (window == m_AboutWindow)
{
m_AboutWindow = null;
}
else if (window == m_LicenseWindow)
{
m_LicenseWindow = null;
}
else if (window == m_SettingsWindow)
{
m_SettingsWindow = null;
}
}
// Action on "SettingsButton" click
private void SettingsButton_Click(object sender, RoutedEventArgs e)
{
//StatusMessage = "Settings opened";
settings = new SettingsWindow();
settings.Show();
}
private void BringUpSettingsWindow()
{
if (m_SettingsWindow == null)
{
m_SettingsWindow = new SettingsWindow(DataModel);
}
else
{
m_SettingsWindow.Visibility = Visibility.Visible;
}
m_SettingsWindow.Show();
}
private void ShowSettingsWindow()
{
SettingsWindow sw = new SettingsWindow();
sw.ShowDialog();
}
private void ViewSettingsItem_Click(object sender, RoutedEventArgs e)
{
SettingsViewModel settingsViewModel = new SettingsViewModel();
SettingsWindow settingsWindow = new SettingsWindow(settingsViewModel);
settingsWindow.Owner = this;
settingsWindow.ShowDialog();
}
