ToolbarWrapper.cs: Changed to VOID namespace.
ToolbarWrapper.cs: Changed to VOID namespace.

  using System.Reflection;
  using System.Runtime.CompilerServices;
  using System.Runtime.InteropServices;
 
  // Allgemeine Informationen über eine Assembly werden über die folgenden
  // Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern,
  // die mit einer Assembly verknüpft sind.
  [assembly: AssemblyTitle("Toolbar Wrapper for Kerbal Space Program")]
  [assembly: AssemblyDescription("")]
  [assembly: AssemblyConfiguration("")]
  [assembly: AssemblyCompany("")]
  [assembly: AssemblyProduct("ToolbarWrapper")]
  [assembly: AssemblyCopyright("Copyright © 2013-2014 Maik Schreiber")]
  [assembly: AssemblyTrademark("")]
  [assembly: AssemblyCulture("")]
 
  // Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar
  // für COM-Komponenten. Wenn Sie auf einen Typ in dieser Assembly von
  // COM zugreifen müssen, legen Sie das ComVisible-Attribut für diesen Typ auf "true" fest.
  [assembly: ComVisible(false)]
 
  // Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
  [assembly: Guid("bfd95a60-6335-4a59-a29e-438d806d8f2d")]
 
  // Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten:
  //
  // Hauptversion
  // Nebenversion
  // Buildnummer
  // Revision
  //
  // Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern
  // übernehmen, indem Sie "*" eingeben:
  // [assembly: AssemblyVersion("1.0.*")]
  [assembly: AssemblyVersion("1.0.0.0")]
  [assembly: AssemblyFileVersion("1.0.0.0")]
 
  /*
  Copyright (c) 2013-2014, Maik Schreiber
  All rights reserved.
 
  Redistribution and use in source and binary forms, with or without modification,
  are permitted provided that the following conditions are met:
 
  1. Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
 
  2. Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
 
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Reflection;
  using System.Text;
  using UnityEngine;
 
 
  namespace VOID {
 
 
 
  /**********************************************************\
  * --- DO NOT EDIT BELOW THIS COMMENT --- *
  * *
  * This file contains classes and interfaces to use the *
  * Toolbar Plugin without creating a hard dependency on it. *
  * *
  * There is nothing in this file that needs to be edited *
  * by hand. *
  * *
  * --- DO NOT EDIT BELOW THIS COMMENT --- *
  \**********************************************************/
 
 
 
  /// <summary>
  /// The global tool bar manager.
  /// </summary>
  public partial class ToolbarManager : IToolbarManager {
  /// <summary>
  /// Whether the Toolbar Plugin is available.
  /// </summary>
  public static bool ToolbarAvailable {
  get {
  if (toolbarAvailable == null) {
  toolbarAvailable = Instance != null;
  }
  return (bool) toolbarAvailable;
  }
  }
 
  /// <summary>
  /// The global tool bar manager instance.
  /// </summary>
  public static IToolbarManager Instance {
  get {
  if ((toolbarAvailable != false) && (instance_ == null)) {
  Type type = AssemblyLoader.loadedAssemblies
  .SelectMany(a => a.assembly.GetExportedTypes())
  .SingleOrDefault(t => t.FullName == "Toolbar.ToolbarManager");
  if (type != null) {
  object realToolbarManager = type.GetProperty("Instance", BindingFlags.Public | BindingFlags.Static).GetValue(null, null);
  instance_ = new ToolbarManager(realToolbarManager);
  }
  }
  return instance_;
  }
  }
  }
 
  #region interfaces
 
  /// <summary>
  /// A toolbar manager.
  /// </summary>
  public interface IToolbarManager {
  /// <summary>
  /// Adds a new button.
  /// </summary>
  /// <remarks>
  /// To replace an existing button, just add a new button using the old button's namespace and ID.
  /// Note that the new button will inherit the screen position of the old button.
  /// </remarks>
  /// <param name="ns">The new button's namespace. This is usually the plugin's name. Must not include special characters like '.'</param>
  /// <param name="id">The new button's ID. This ID must be unique across all buttons in the namespace. Must not include special characters like '.'</param>
  /// <returns>The button created.</returns>
  IButton add(string ns, string id);
  }
 
  /// <summary>
  /// Represents a clickable button.
  /// </summary>
  public interface IButton {
  /// <summary>
  /// The text displayed on the button. Set to null to hide text.
  /// </summary>
  /// <remarks>
  /// The text can be changed at any time to modify the button's appearance. Note that since this will also
  /// modify the button's size, this feature should be used sparingly, if at all.
  /// </remarks>
  /// <seealso cref="TexturePath"/>
  string Text {
  set;
  get;
  }
 
  /// <summary>
  /// The color the button text is displayed with. Defaults to Color.white.
  /// </summary>
  /// <remarks>
  /// The text color can be changed at any time to modify the button's appearance.
  /// </remarks>
  Color TextColor {
  set;
  get;
  }
 
  /// <summary>
  /// The path of a texture file to display an icon on the button. Set to null to hide icon.
  /// </summary>
  /// <remarks>
  /// <para>
  /// A texture path on a button will have precedence over text. That is, if both text and texture path
  /// have been set on a button, the button will show the texture, not the text.
  /// </para>
  /// <para>
  /// The texture size must not exceed 24x24 pixels.
  /// </para>
  /// <para>
  /// The texture path must be relative to the "GameData" directory, and must not specify a file name suffix.
  /// Valid example: MyAddon/Textures/icon_mybutton
  /// </para>
  /// <para>
  /// The texture path can be changed at any time to modify the button's appearance.
  /// </para>
  /// </remarks>
  /// <seealso cref="Text"/>
  string TexturePath {
  set;
  get;
  }
 
  /// <summary>
  /// The button's tool tip text. Set to null if no tool tip is desired.
  /// </summary>
  /// <remarks>
  /// Tool Tip Text Should Always Use Headline Style Like This.
  /// </remarks>
  string ToolTip {
  set;
  get;
  }
 
  /// <summary>
  /// Whether this button is currently visible or not. Can be used in addition to or as a replacement for <see cref="Visibility"/>.
  /// </summary>
  /// <remarks>
  /// Setting this property to true does not affect the player's ability to hide the button using the configuration.
  /// Conversely, setting this property to false does not enable the player to show the button using the configuration.
  /// </remarks>
  bool Visible {
  set;
  get;
  }
 
  /// <summary>
  /// Determines this button's visibility. Can be used in addition to or as a replacement for <see cref="Visible"/>.
  /// </summary>
  /// <remarks>
  /// The return value from IVisibility.Visible is subject to the same rules as outlined for
  /// <see cref="Visible"/>.
  /// </remarks>
  IVisibility Visibility {
  set;
  get;
  }
 
  /// <summary>
  /// Whether this button is currently effectively visible or not. This is a combination of
  /// <see cref="Visible"/> and <see cref="Visibility"/>.
  /// </summary>
  /// <remarks>
  /// Note that the toolbar is not visible in certain game scenes, for example the loading screens. This property
  /// does not reflect button invisibility in those scenes. In addition, this property does not reflect the
  /// player's configuration of the button's visibility.
  /// </remarks>
  bool EffectivelyVisible {
  get;
  }
 
  /// <summary>
  /// Whether this button is currently enabled (clickable) or not. This does not affect the player's ability to
  /// position the button on their toolbar.
  /// </summary>
  bool Enabled {
  set;
  get;
  }
 
  /// <summary>
  /// Whether this button is currently "important." Set to false to return to normal button behaviour.
  /// </summary>
  /// <remarks>
  /// <para>
  /// This can be used to temporarily force the button to be shown on screen regardless of the toolbar being
  /// currently in auto-hidden mode. For example, a button that signals the arrival of a private message in
  /// a chat room could mark itself as "important" as long as the message has not been read.
  /// </para>
  /// <para>
  /// Setting this property does not change the appearance of the button. Use <see cref="TexturePath"/> to
  /// change the button's icon.
  /// </para>
  /// <para>
  /// Setting this property to true does not affect the player's ability to hide the button using the
  /// configuration.
  /// </para>
  /// <para>
  /// This feature should be used only sparingly, if at all, since it forces the button to be displayed on
  /// screen even when it normally wouldn't.
  /// </para>
  /// </remarks>
  bool Important {
  set;
  get;
  }
 
  /// <summary>
  /// Event handler that can be registered with to receive "on click" events.
  /// </summary>
  /// <example>
  /// <code>
  /// IButton button = ...
  /// button.OnClick += (e) => {
  /// Debug.Log("button clicked, mouseButton: " + e.MouseButton);
  /// };
  /// </code>
  /// </example>
  event ClickHandler OnClick;
 
  /// <summary>
  /// Event handler that can be registered with to receive "on mouse enter" events.
  /// </summary>
  /// <example>
  /// <code>
  /// IButton button = ...
  /// button.OnMouseEnter += (e) => {
  /// Debug.Log("mouse entered button");
  /// };
  /// </code>
  /// </example>
  event MouseEnterHandler OnMouseEnter;
 
  /// <summary>
  /// Event handler that can be registered with to receive "on mouse leave" events.
  /// </summary>
  /// <example>
  /// <code>
  /// IButton button = ...
  /// button.OnMouseLeave += (e) => {
  /// Debug.Log("mouse left button");
  /// };
  /// </code>
  /// </example>
  event MouseLeaveHandler OnMouseLeave;
 
  /// <summary>
  /// Permanently destroys this button so that it is no longer displayed.
  /// Should be used when a plugin is stopped to remove leftover buttons.
  /// </summary>
  void Destroy();
  }
 
  #endregion
 
  #region events
 
  /// <summary>
  /// Event describing a click on a button.
  /// </summary>
  public partial class ClickEvent : EventArgs {
  /// <summary>
  /// The button that has been clicked.
  /// </summary>
  public readonly IButton Button;
 
  /// <summary>
  /// The mouse button which the button was clicked with.
  /// </summary>
  /// <remarks>
  /// Is 0 for left mouse button, 1 for right mouse button, and 2 for middle mouse button.
  /// </remarks>
  public readonly int MouseButton;
  }
 
  /// <summary>
  /// An event handler that is invoked whenever a button has been clicked.
  /// </summary>
  /// <param name="e">An event describing the button click.</param>
  public delegate void ClickHandler(ClickEvent e);
 
  /// <summary>
  /// Event describing the mouse pointer moving about a button.
  /// </summary>
  public abstract partial class MouseMoveEvent {
  /// <summary>
  /// The button in question.
  /// </summary>
  public readonly IButton button;
  }
 
  /// <summary>
  /// Event describing the mouse pointer entering a button's area.
  /// </summary>
  public partial class MouseEnterEvent : MouseMoveEvent {
  }
 
  /// <summary>
  /// Event describing the mouse pointer leaving a button's area.
  /// </summary>
  public partial class MouseLeaveEvent : MouseMoveEvent {
  }
 
  /// <summary>
  /// An event handler that is invoked whenever the mouse pointer enters a button's area.
  /// </summary>
  /// <param name="e">An event describing the mouse pointer entering.</param>
  public delegate void MouseEnterHandler(MouseEnterEvent e);
 
  /// <summary>
  /// An event handler that is invoked whenever the mouse pointer leaves a button's area.
  /// </summary>
  /// <param name="e">An event describing the mouse pointer leaving.</param>
  public delegate void MouseLeaveHandler(MouseLeaveEvent e);
 
  #endregion
 
  #region visibility
 
  /// <summary>
  /// Determines visibility of a button.
  /// </summary>
  /// <seealso cref="IButton.Visibility"/>
  public interface IVisibility {
  /// <summary>
  /// Whether a button is currently visible or not.
  /// </summary>
  /// <seealso cref="IButton.Visible"/>
  bool Visible {
  get;
  }
  }
 
  /// <summary>
  /// Determines visibility of a button in relation to the currently running game scene.
  /// </summary>
  /// <example>
  /// <code>
  /// IButton button = ...
  /// button.Visibility = new GameScenesVisibility(GameScenes.EDITOR, GameScenes.SPH);
  /// </code>
  /// </example>
  /// <seealso cref="IButton.Visibility"/>
  public class GameScenesVisibility : IVisibility {
  private GameScenes[] gameScenes;
 
  public bool Visible {
  get {
  return (bool) visibleProperty.GetValue(realGameScenesVisibility, null);
  }
  }
 
  private object realGameScenesVisibility;
  private PropertyInfo visibleProperty;
 
  public GameScenesVisibility(params GameScenes[] gameScenes) {
  Type gameScenesVisibilityType = AssemblyLoader.loadedAssemblies
  .SelectMany(a => a.assembly.GetExportedTypes())
  .SingleOrDefault(t => t.FullName == "Toolbar.GameScenesVisibility");
  realGameScenesVisibility = Activator.CreateInstance(gameScenesVisibilityType, new object[] { gameScenes });
  visibleProperty = gameScenesVisibilityType.GetProperty("Visible", BindingFlags.Public | BindingFlags.Instance);
  this.gameScenes = gameScenes;
  }
  }
 
  #endregion
 
  #region private implementations
 
  public partial class ToolbarManager : IToolbarManager {
  private static bool? toolbarAvailable = null;
  private static IToolbarManager instance_;
 
  private object realToolbarManager;
  private MethodInfo addMethod;
  private Dictionary<object, IButton> buttons = new Dictionary<object, IButton>();
  private Type iButtonType;
  private Type functionVisibilityType;
 
  private ToolbarManager(object realToolbarManager) {
  this.realToolbarManager = realToolbarManager;
 
  Type iToolbarManagerType = AssemblyLoader.loadedAssemblies
  .SelectMany(a => a.assembly.GetExportedTypes())
  .SingleOrDefault(t => t.FullName == "Toolbar.IToolbarManager");
  addMethod = iToolbarManagerType.GetMethod("add", BindingFlags.Public | BindingFlags.Instance);
 
  iButtonType = AssemblyLoader.loadedAssemblies
  .SelectMany(a => a.assembly.GetExportedTypes())
  .SingleOrDefault(t => t.FullName == "Toolbar.IButton");
  functionVisibilityType = AssemblyLoader.loadedAssemblies
  .SelectMany(a => a.assembly.GetExportedTypes())
  .SingleOrDefault(t => t.FullName == "Toolbar.FunctionVisibility");
  }
 
  public IButton add(string ns, string id) {
  object realButton = addMethod.Invoke(realToolbarManager, new object[] { ns, id });
  IButton button = new Button(realButton, iButtonType, functionVisibilityType);
  buttons.Add(realButton, button);
  return button;
  }
  }
 
  internal class Button : IButton {
  private object realButton;
  private PropertyInfo textProperty;
  private PropertyInfo textColorProperty;
  private PropertyInfo texturePathProperty;
  private PropertyInfo toolTipProperty;
  private PropertyInfo visibleProperty;
  private PropertyInfo visibilityProperty;
  private Type functionVisibilityType;
  private PropertyInfo effectivelyVisibleProperty;
  private PropertyInfo enabledProperty;
  private PropertyInfo importantProperty;
  private EventInfo onClickEvent;
  private Delegate realClickHandler;
  private EventInfo onMouseEnterEvent;
  private Delegate realMouseEnterHandler;
  private EventInfo onMouseLeaveEvent;
  private Delegate realMouseLeaveHandler;
  private MethodInfo destroyMethod;
 
  internal Button(object realButton, Type iButtonType, Type functionVisibilityType) {
  this.realButton = realButton;
  this.functionVisibilityType = functionVisibilityType;
 
  textProperty = iButtonType.GetProperty("Text", BindingFlags.Public | BindingFlags.Instance);
  textColorProperty = iButtonType.GetProperty("TextColor", BindingFlags.Public | BindingFlags.Instance);
  texturePathProperty = iButtonType.GetProperty("TexturePath", BindingFlags.Public | BindingFlags.Instance);
  toolTipProperty = iButtonType.GetProperty("ToolTip", BindingFlags.Public | BindingFlags.Instance);
  visibleProperty = iButtonType.GetProperty("Visible", BindingFlags.Public | BindingFlags.Instance);
  visibilityProperty = iButtonType.GetProperty("Visibility", BindingFlags.Public | BindingFlags.Instance);
  effectivelyVisibleProperty = iButtonType.GetProperty("EffectivelyVisible", BindingFlags.Public | BindingFlags.Instance);
  enabledProperty = iButtonType.GetProperty("Enabled", BindingFlags.Public | BindingFlags.Instance);
  importantProperty = iButtonType.GetProperty("Important", BindingFlags.Public | BindingFlags.Instance);
  onClickEvent = iButtonType.GetEvent("OnClick", BindingFlags.Public | BindingFlags.Instance);
  onMouseEnterEvent = iButtonType.GetEvent("OnMouseEnter", BindingFlags.Public | BindingFlags.Instance);
  onMouseLeaveEvent = iButtonType.GetEvent("OnMouseLeave", BindingFlags.Public | BindingFlags.Instance);
  destroyMethod = iButtonType.GetMethod("Destroy", BindingFlags.Public | BindingFlags.Instance);
 
  realClickHandler = attachEventHandler(onClickEvent, "clicked", realButton);
  realMouseEnterHandler = attachEventHandler(onMouseEnterEvent, "mouseEntered", realButton);
  realMouseLeaveHandler = attachEventHandler(onMouseLeaveEvent, "mouseLeft", realButton);
  }
 
  private Delegate attachEventHandler(EventInfo @event, string methodName, object realButton) {
  MethodInfo method = GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
  Delegate d = Delegate.CreateDelegate(@event.EventHandlerType, this, method);
  @event.GetAddMethod().Invoke(realButton, new object[] { d });
  return d;
  }
 
  public string Text {
  set {
  textProperty.SetValue(realButton, value, null);
  }
  get {
  return (string) textProperty.GetValue(realButton, null);
  }
  }
 
  public Color TextColor {
  set {
  textColorProperty.SetValue(realButton, value, null);
  }
  get {
  return (Color) textColorProperty.GetValue(realButton, null);
  }
  }
 
  public string TexturePath {
  set {
  texturePathProperty.SetValue(realButton, value, null);
  }
  get {
  return (string) texturePathProperty.GetValue(realButton, null);
  }
  }
 
  public string ToolTip {
  set {
  toolTipProperty.SetValue(realButton, value, null);
  }
  get {
  return (string) toolTipProperty.GetValue(realButton, null);
  }
  }
 
  public bool Visible {
  set {
  visibleProperty.SetValue(realButton, value, null);
  }
  get {
  return (bool) visibleProperty.GetValue(realButton, null);
  }
  }
 
  public IVisibility Visibility {
  set {
  object functionVisibility = Activator.CreateInstance(functionVisibilityType, new object[] { new Func<bool>(() => value.Visible) });
  visibilityProperty.SetValue(realButton, functionVisibility, null);
  visibility_ = value;
  }
  get {
  return visibility_;
  }
  }
  private IVisibility visibility_;
 
  public bool EffectivelyVisible {
  get {
  return (bool) effectivelyVisibleProperty.GetValue(realButton, null);
  }
  }
 
  public bool Enabled {
  set {
  enabledProperty.SetValue(realButton, value, null);
  }
  get {
  return (bool) enabledProperty.GetValue(realButton, null);
  }
  }
 
  public bool Important {
  set {
  importantProperty.SetValue(realButton, value, null);
  }
  get {
  return (bool) importantProperty.GetValue(realButton, null);
  }
  }
 
  public event ClickHandler OnClick;
 
  private void clicked(object realEvent) {
  if (OnClick != null) {
  OnClick(new ClickEvent(realEvent, this));
  }
  }
 
  public event MouseEnterHandler OnMouseEnter;
 
  private void mouseEntered(object realEvent) {
  if (OnMouseEnter != null) {
  OnMouseEnter(new MouseEnterEvent(this));
  }
  }
 
  public event MouseLeaveHandler OnMouseLeave;
 
  private void mouseLeft(object realEvent) {
  if (OnMouseLeave != null) {
  OnMouseLeave(new MouseLeaveEvent(this));
  }
  }
 
  public void Destroy() {
  detachEventHandler(onClickEvent, realClickHandler, realButton);
  detachEventHandler(onMouseEnterEvent, realMouseEnterHandler, realButton);
  detachEventHandler(onMouseLeaveEvent, realMouseLeaveHandler, realButton);
 
  destroyMethod.Invoke(realButton, null);
  }
 
  private void detachEventHandler(EventInfo @event, Delegate d, object realButton) {
  @event.GetRemoveMethod().Invoke(realButton, new object[] { d });
  }
 
  private Delegate createDelegate(Type eventHandlerType, string methodName) {
  return Delegate.CreateDelegate(GetType(), GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance));
  }
  }
 
  public partial class ClickEvent : EventArgs {
  internal ClickEvent(object realEvent, IButton button) {
  Type type = realEvent.GetType();
  Button = button;
  MouseButton = (int) type.GetField("MouseButton", BindingFlags.Public | BindingFlags.Instance).GetValue(realEvent);
  }
  }
 
  public abstract partial class MouseMoveEvent : EventArgs {
  internal MouseMoveEvent(IButton button) {
  this.button = button;
  }
  }
 
  public partial class MouseEnterEvent : MouseMoveEvent {
  internal MouseEnterEvent(IButton button)
  : base(button) {
  }
  }
 
  public partial class MouseLeaveEvent : MouseMoveEvent {
  internal MouseLeaveEvent(IButton button)
  : base(button) {
  }
  }
 
  #endregion
  }
 
  <?xml version="1.0" encoding="utf-8"?>
  <Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  <PropertyGroup>
  <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  <ProjectGuid>{E258AB2C-E2BB-4ACA-B902-C98582041F69}</ProjectGuid>
  <OutputType>Library</OutputType>
  <AppDesignerFolder>Properties</AppDesignerFolder>
  <RootNamespace>ToolbarWrapper</RootNamespace>
  <AssemblyName>ToolbarWrapper</AssemblyName>
  <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
  <FileAlignment>512</FileAlignment>
  <TargetFrameworkProfile />
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
  <DebugSymbols>true</DebugSymbols>
  <DebugType>full</DebugType>
  <Optimize>false</Optimize>
  <OutputPath>bin\Debug\</OutputPath>
  <DefineConstants>DEBUG;TRACE</DefineConstants>
  <ErrorReport>prompt</ErrorReport>
  <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
  <DebugType>pdbonly</DebugType>
  <Optimize>true</Optimize>
  <OutputPath>bin\Release\</OutputPath>
  <DefineConstants>TRACE</DefineConstants>
  <ErrorReport>prompt</ErrorReport>
  <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
  <Reference Include="Assembly-CSharp">
  <HintPath>..\..\..\..\Programme\KSP_23_dev\KSP_Data\Managed\Assembly-CSharp.dll</HintPath>
  </Reference>
  <Reference Include="System" />
  <Reference Include="System.Core" />
  <Reference Include="System.Xml.Linq" />
  <Reference Include="System.Data.DataSetExtensions" />
  <Reference Include="System.Data" />
  <Reference Include="System.Xml" />
  <Reference Include="UnityEngine">
  <HintPath>..\..\..\..\Programme\KSP_23_dev\KSP_Data\Managed\UnityEngine.dll</HintPath>
  </Reference>
  </ItemGroup>
  <ItemGroup>
  <Compile Include="Properties\AssemblyInfo.cs" />
  <Compile Include="ToolbarWrapper.cs" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
  Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
  </Project>
// //
// VOID_Core.cs // VOID_Core.cs
// //
// Author: // Author:
// toadicus <> // toadicus <>
// //
// Copyright (c) 2013 toadicus // Copyright (c) 2013 toadicus
// //
// This program is free software: you can redistribute it and/or modify // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or // the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version. // (at your option) any later version.
// //
// This program is distributed in the hope that it will be useful, // This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of // but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details. // GNU General Public License for more details.
// //
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using KSP; using KSP;
using UnityEngine; using UnityEngine;
using Engineer.VesselSimulator; using Engineer.VesselSimulator;
   
namespace VOID namespace VOID
{ {
public class VOID_Core : VOID_Module, IVOID_Module public class VOID_Core : VOID_Module, IVOID_Module
{ {
/* /*
* Static Members * Static Members
* */ * */
protected static bool _initialized = false; protected static bool _initialized = false;
   
public static bool Initialized public static bool Initialized
{ {
get get
{ {
return _initialized; return _initialized;
} }
} }
   
protected static VOID_Core _instance; protected static VOID_Core _instance;
   
public static VOID_Core Instance public static VOID_Core Instance
{ {
get get
{ {
if (_instance == null) if (_instance == null)
{ {
_instance = new VOID_Core(); _instance = new VOID_Core();
_initialized = true; _initialized = true;
} }
return _instance; return _instance;
} }
} }
   
public static void Reset() public static void Reset()
{ {
_instance.StopGUI(); _instance.StopGUI();
_instance = null; _instance = null;
_initialized = false; _initialized = false;
} }
   
public static double Constant_G = 6.674e-11; public static double Constant_G = 6.674e-11;
/* /*
* Fields * Fields
* */ * */
protected string VoidName = "VOID"; protected string VoidName = "VOID";
protected string VoidVersion = "0.9.20"; protected string VoidVersion = "0.9.20";
   
protected bool _factoryReset = false; protected bool _factoryReset = false;
   
[AVOID_SaveValue("configValue")] [AVOID_SaveValue("configValue")]
protected VOID_SaveValue<int> configVersion = 1; protected VOID_SaveValue<int> configVersion = 1;
   
protected List<IVOID_Module> _modules = new List<IVOID_Module>(); protected List<IVOID_Module> _modules = new List<IVOID_Module>();
protected bool _modulesLoaded = false; protected bool _modulesLoaded = false;
   
[AVOID_SaveValue("mainWindowPos")] [AVOID_SaveValue("mainWindowPos")]
protected VOID_SaveValue<Rect> mainWindowPos = new Rect(475, 575, 10f, 10f); protected VOID_SaveValue<Rect> mainWindowPos = new Rect(475, 575, 10f, 10f);
[AVOID_SaveValue("mainGuiMinimized")] [AVOID_SaveValue("mainGuiMinimized")]
protected VOID_SaveValue<bool> mainGuiMinimized = false; protected VOID_SaveValue<bool> mainGuiMinimized = false;
   
[AVOID_SaveValue("configWindowPos")] [AVOID_SaveValue("configWindowPos")]
protected VOID_SaveValue<Rect> configWindowPos = new Rect(825, 625, 10f, 10f); protected VOID_SaveValue<Rect> configWindowPos = new Rect(825, 625, 10f, 10f);
[AVOID_SaveValue("configWindowMinimized")] [AVOID_SaveValue("configWindowMinimized")]
   
protected VOID_SaveValue<bool> configWindowMinimized = true; protected VOID_SaveValue<bool> configWindowMinimized = true;
[AVOID_SaveValue("VOIDIconPos")] [AVOID_SaveValue("VOIDIconPos")]
protected VOID_SaveValue<Rect> VOIDIconPos = new Rect(Screen.width / 2 - 200, Screen.height - 32, 32f, 32f); protected VOID_SaveValue<Rect> VOIDIconPos = new Rect(Screen.width / 2 - 200, Screen.height - 32, 32f, 32f);
   
protected Texture2D VOIDIconTexture; protected Texture2D VOIDIconTexture;
protected string VOIDIconOnActivePath; protected string VOIDIconOnActivePath;
protected string VOIDIconOnInactivePath; protected string VOIDIconOnInactivePath;
protected string VOIDIconOffActivePath; protected string VOIDIconOffActivePath;
protected string VOIDIconOffInactivePath; protected string VOIDIconOffInactivePath;
   
protected bool VOIDIconLocked = true; protected bool VOIDIconLocked = true;
   
protected GUIStyle iconStyle; protected GUIStyle iconStyle;
   
protected int windowBaseID = -96518722; protected int windowBaseID = -96518722;
protected int _windowID = 0; protected int _windowID = 0;
   
protected bool GUIStylesLoaded = false; protected bool GUIStylesLoaded = false;
protected Dictionary<string, GUIStyle> _LabelStyles = new Dictionary<string, GUIStyle>(); protected Dictionary<string, GUIStyle> _LabelStyles = new Dictionary<string, GUIStyle>();
   
[AVOID_SaveValue("togglePower")] [AVOID_SaveValue("togglePower")]
public VOID_SaveValue<bool> togglePower = true; public VOID_SaveValue<bool> togglePower = true;
public bool powerAvailable = true; public bool powerAvailable = true;
   
[AVOID_SaveValue("consumeResource")] [AVOID_SaveValue("consumeResource")]
protected VOID_SaveValue<bool> consumeResource = false; protected VOID_SaveValue<bool> consumeResource = false;
   
[AVOID_SaveValue("resourceName")] [AVOID_SaveValue("resourceName")]
protected VOID_SaveValue<string> resourceName = "ElectricCharge"; protected VOID_SaveValue<string> resourceName = "ElectricCharge";
   
[AVOID_SaveValue("resourceRate")] [AVOID_SaveValue("resourceRate")]
protected VOID_SaveValue<float> resourceRate = 0.2f; protected VOID_SaveValue<float> resourceRate = 0.2f;
   
[AVOID_SaveValue("updatePeriod")] [AVOID_SaveValue("updatePeriod")]
protected VOID_SaveValue<double> _updatePeriod = 1001f / 15000f; protected VOID_SaveValue<double> _updatePeriod = 1001f / 15000f;
protected float _updateTimer = 0f; protected float _updateTimer = 0f;
protected string stringFrequency; protected string stringFrequency;
   
// Vessel Type Housekeeping // Vessel Type Housekeeping
protected List<VesselType> _allVesselTypes = new List<VesselType>(); protected List<VesselType> _allVesselTypes = new List<VesselType>();
protected bool vesselTypesLoaded = false; protected bool vesselTypesLoaded = false;
public float saveTimer = 0; public float saveTimer = 0;
   
protected string defaultSkin = "KSP window 2"; protected string defaultSkin = "KSP window 2";
[AVOID_SaveValue("defaultSkin")] [AVOID_SaveValue("defaultSkin")]
protected VOID_SaveValue<string> _skinName; protected VOID_SaveValue<string> _skinName;
protected Dictionary<string, GUISkin> skin_list; protected Dictionary<string, GUISkin> skin_list;
protected List<string> skinNames; protected List<string> skinNames;
protected string[] forbiddenSkins = protected string[] forbiddenSkins =
{ {
"PlaqueDialogSkin", "PlaqueDialogSkin",
"FlagBrowserSkin", "FlagBrowserSkin",
"SSUITextAreaDefault", "SSUITextAreaDefault",
"ExperimentsDialogSkin", "ExperimentsDialogSkin",
"ExpRecoveryDialogSkin", "ExpRecoveryDialogSkin",
"KSP window 5", "KSP window 5",
"KSP window 6", "KSP window 6",
"PartTooltipSkin" "PartTooltipSkin"
}; };
protected bool skinsLoaded = false; protected bool skinsLoaded = false;
   
public bool configDirty; public bool configDirty;
   
[AVOID_SaveValue("UseBlizzyToolbar")] [AVOID_SaveValue("UseBlizzyToolbar")]
protected VOID_SaveValue<bool> _UseToolbarManager; protected VOID_SaveValue<bool> _UseToolbarManager;
protected bool ToolbarManagerLoaded; protected bool ToolbarManagerLoaded;
internal ToolbarButtonWrapper ToolbarButton; internal ToolbarButtonWrapper ToolbarButton;
   
/* /*
* Properties * Properties
* */ * */
public bool factoryReset public bool factoryReset
{ {
get get
{ {
return this._factoryReset; return this._factoryReset;
} }
} }
   
public List<IVOID_Module> Modules public List<IVOID_Module> Modules
{ {
get get
{ {
return this._modules; return this._modules;
} }
} }
   
public GUISkin Skin public GUISkin Skin
{ {
get get
{ {
if (!this.skinsLoaded || this._skinName == null) if (!this.skinsLoaded || this._skinName == null)
{ {
return AssetBase.GetGUISkin(this.defaultSkin); return AssetBase.GetGUISkin(this.defaultSkin);
} }
return this.skin_list[this._skinName]; return this.skin_list[this._skinName];
} }
} }
   
public int windowID public int windowID
{ {
get get
{ {
if (this._windowID == 0) if (this._windowID == 0)
{ {
this._windowID = this.windowBaseID; this._windowID = this.windowBaseID;
} }
return this._windowID++; return this._windowID++;
} }
} }
   
public Dictionary<string, GUIStyle> LabelStyles public Dictionary<string, GUIStyle> LabelStyles
{ {
get get
{ {
return this._LabelStyles; return this._LabelStyles;
} }
} }
   
public List<CelestialBody> allBodies public List<CelestialBody> allBodies
{ {
get get
{ {
return FlightGlobals.Bodies; return FlightGlobals.Bodies;
} }
} }
   
public List<VesselType> allVesselTypes public List<VesselType> allVesselTypes
{ {
get get
{ {
return this._allVesselTypes; return this._allVesselTypes;
} }
} }
   
public float updateTimer public float updateTimer
{ {
get get
{ {
return this._updateTimer; return this._updateTimer;
} }
} }
   
public double updatePeriod public double updatePeriod
{ {
get get
{ {
return this._updatePeriod; return this._updatePeriod;
} }
} }
   
protected IconState powerState protected IconState powerState
{ {
get get
{ {
if (this.togglePower && this.powerAvailable) if (this.togglePower && this.powerAvailable)
{ {
return IconState.PowerOn; return IconState.PowerOn;
} }
else else
{ {
return IconState.PowerOff; return IconState.PowerOff;
} }
   
} }
} }
   
protected IconState activeState protected IconState activeState
{ {
get get
{ {
if (this.mainGuiMinimized) if (this.mainGuiMinimized)
{ {
return IconState.Inactive; return IconState.Inactive;
} }
else else
{ {
return IconState.Active; return IconState.Active;
} }
   
} }
} }
   
protected bool UseToolbarManager protected bool UseToolbarManager
{ {
get get
{ {
return _UseToolbarManager; return _UseToolbarManager;
} }
set set
{ {
if (this._UseToolbarManager == value) if (this._UseToolbarManager == value)
{ {
return; return;
} }
   
if (value == false && this.ToolbarManagerLoaded && this.ToolbarButton != null) if (value == false && this.ToolbarManagerLoaded && this.ToolbarButton != null)
{ {
this.ToolbarButton.Destroy(); this.ToolbarButton.Destroy();
this.ToolbarButton = null; this.ToolbarButton = null;
} }
if (value == true && this.ToolbarManagerLoaded && this.ToolbarButton == null) if (value == true && this.ToolbarManagerLoaded && this.ToolbarButton == null)
{ {
this.InitializeToolbarButton(); this.InitializeToolbarButton();
} }
   
this.SetIconTexture(this.powerState | this.activeState); this.SetIconTexture(this.powerState | this.activeState);
   
_UseToolbarManager.value = value; _UseToolbarManager.value = value;
} }
} }
   
/* /*
* Methods * Methods
* */ * */
protected VOID_Core() protected VOID_Core()
{ {
this._Name = "VOID Core"; this._Name = "VOID Core";
   
this._Active.value = true; this._Active.value = true;
   
this._skinName = this.defaultSkin; this._skinName = this.defaultSkin;
   
this.VOIDIconOnActivePath = "VOID/Textures/void_icon_light_glow"; this.VOIDIconOnActivePath = "VOID/Textures/void_icon_light_glow";
this.VOIDIconOnInactivePath = "VOID/Textures/void_icon_dark_glow"; this.VOIDIconOnInactivePath = "VOID/Textures/void_icon_dark_glow";
this.VOIDIconOffActivePath = "VOID/Textures/void_icon_light"; this.VOIDIconOffActivePath = "VOID/Textures/void_icon_light";
this.VOIDIconOffInactivePath = "VOID/Textures/void_icon_dark"; this.VOIDIconOffInactivePath = "VOID/Textures/void_icon_dark";
   
this.UseToolbarManager = false; this.UseToolbarManager = false;
this.ToolbarManagerLoaded = false; this.ToolbarManagerLoaded = false;
   
this.LoadConfig(); this.LoadConfig();
   
this.SetIconTexture(this.powerState | this.activeState); this.SetIconTexture(this.powerState | this.activeState);
} }
   
protected void LoadModulesOfType<T>() protected void LoadModulesOfType<T>()
{ {
var types = AssemblyLoader.loadedAssemblies var types = AssemblyLoader.loadedAssemblies
.Select(a => a.assembly.GetExportedTypes()) .Select(a => a.assembly.GetExportedTypes())
.SelectMany(t => t) .SelectMany(t => t)
.Where(v => typeof(T).IsAssignableFrom(v) .Where(v => typeof(T).IsAssignableFrom(v)
&& !(v.IsInterface || v.IsAbstract) && && !(v.IsInterface || v.IsAbstract) &&
!typeof(VOID_Core).IsAssignableFrom(v) !typeof(VOID_Core).IsAssignableFrom(v)
); );
   
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: Found {1} modules to check.", "{0}: Found {1} modules to check.",
this.GetType().Name, this.GetType().Name,
types.Count() types.Count()
)); ));
foreach (var voidType in types) foreach (var voidType in types)
{ {
if (!HighLogic.LoadedSceneIsEditor && if (!HighLogic.LoadedSceneIsEditor &&
typeof(IVOID_EditorModule).IsAssignableFrom(voidType)) typeof(IVOID_EditorModule).IsAssignableFrom(voidType))
{ {
continue; continue;
} }
   
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: found Type {1}", "{0}: found Type {1}",
this.GetType().Name, this.GetType().Name,
voidType.Name voidType.Name
)); ));
   
this.LoadModule(voidType); this.LoadModule(voidType);
} }
   
this._modulesLoaded = true; this._modulesLoaded = true;
   
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: Loaded {1} modules.", "{0}: Loaded {1} modules.",
this.GetType().Name, this.GetType().Name,
this.Modules.Count this.Modules.Count
)); ));
} }
   
protected void LoadModule(Type T) protected void LoadModule(Type T)
{ {
var existingModules = this._modules.Where(mod => mod.GetType().Name == T.Name); var existingModules = this._modules.Where(mod => mod.GetType().Name == T.Name);
if (existingModules.Any()) if (existingModules.Any())
{ {
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: refusing to load {1}: already loaded", "{0}: refusing to load {1}: already loaded",
this.GetType().Name, this.GetType().Name,
T.Name T.Name
)); ));
return; return;
} }
IVOID_Module module = Activator.CreateInstance(T) as IVOID_Module; IVOID_Module module = Activator.CreateInstance(T) as IVOID_Module;
module.LoadConfig(); module.LoadConfig();
this._modules.Add(module); this._modules.Add(module);
   
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: loaded module {1}.", "{0}: loaded module {1}.",
this.GetType().Name, this.GetType().Name,
T.Name T.Name
)); ));
} }
   
protected void LoadSkins() protected void LoadSkins()
{ {
Tools.PostDebugMessage("AssetBase has skins: \n" + Tools.PostDebugMessage("AssetBase has skins: \n" +
string.Join("\n\t", string.Join("\n\t",
Resources.FindObjectsOfTypeAll(typeof(GUISkin)) Resources.FindObjectsOfTypeAll(typeof(GUISkin))
.Select(s => s.ToString()) .Select(s => s.ToString())
.ToArray() .ToArray()
) )
); );
   
this.skin_list = Resources.FindObjectsOfTypeAll(typeof(GUISkin)) this.skin_list = Resources.FindObjectsOfTypeAll(typeof(GUISkin))
.Where(s => !this.forbiddenSkins.Contains(s.name)) .Where(s => !this.forbiddenSkins.Contains(s.name))
.Select(s => s as GUISkin) .Select(s => s as GUISkin)
.GroupBy(s => s.name) .GroupBy(s => s.name)
.Select(g => g.First()) .Select(g => g.First())
.ToDictionary(s => s.name); .ToDictionary(s => s.name);
   
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: loaded {1} GUISkins.", "{0}: loaded {1} GUISkins.",
this.GetType().Name, this.GetType().Name,
this.skin_list.Count this.skin_list.Count
)); ));
   
this.skinNames = this.skin_list.Keys.ToList(); this.skinNames = this.skin_list.Keys.ToList();
this.skinNames.Sort(); this.skinNames.Sort();
   
if (this._skinName == null || !this.skinNames.Contains(this._skinName)) if (this._skinName == null || !this.skinNames.Contains(this._skinName))
{ {
this._skinName = this.defaultSkin; this._skinName = this.defaultSkin;
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: resetting _skinIdx to default.", "{0}: resetting _skinIdx to default.",
this.GetType().Name this.GetType().Name
)); ));
} }
   
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: _skinIdx = {1}.", "{0}: _skinIdx = {1}.",
this.GetType().Name, this.GetType().Name,
this._skinName.ToString() this._skinName.ToString()
)); ));
   
this.skinsLoaded = true; this.skinsLoaded = true;
} }
   
protected void LoadGUIStyles() protected void LoadGUIStyles()
{ {
this.LabelStyles["link"] = new GUIStyle(GUI.skin.label); this.LabelStyles["link"] = new GUIStyle(GUI.skin.label);
this.LabelStyles["link"].fontStyle = FontStyle.Bold; this.LabelStyles["link"].fontStyle = FontStyle.Bold;
   
this.LabelStyles["center"] = new GUIStyle(GUI.skin.label); this.LabelStyles["center"] = new GUIStyle(GUI.skin.label);
this.LabelStyles["center"].normal.textColor = Color.white; this.LabelStyles["center"].normal.textColor = Color.white;
this.LabelStyles["center"].alignment = TextAnchor.UpperCenter; this.LabelStyles["center"].alignment = TextAnchor.UpperCenter;
   
this.LabelStyles["center_bold"] = new GUIStyle(GUI.skin.label); this.LabelStyles["center_bold"] = new GUIStyle(GUI.skin.label);
this.LabelStyles["center_bold"].normal.textColor = Color.white; this.LabelStyles["center_bold"].normal.textColor = Color.white;
this.LabelStyles["center_bold"].alignment = TextAnchor.UpperCenter; this.LabelStyles["center_bold"].alignment = TextAnchor.UpperCenter;
this.LabelStyles["center_bold"].fontStyle = FontStyle.Bold; this.LabelStyles["center_bold"].fontStyle = FontStyle.Bold;
   
this.LabelStyles["right"] = new GUIStyle(GUI.skin.label); this.LabelStyles["right"] = new GUIStyle(GUI.skin.label);
this.LabelStyles["right"].normal.textColor = Color.white; this.LabelStyles["right"].normal.textColor = Color.white;
this.LabelStyles["right"].alignment = TextAnchor.UpperRight; this.LabelStyles["right"].alignment = TextAnchor.UpperRight;
   
this.LabelStyles["red"] = new GUIStyle(GUI.skin.label); this.LabelStyles["red"] = new GUIStyle(GUI.skin.label);
this.LabelStyles["red"].normal.textColor = Color.red; this.LabelStyles["red"].normal.textColor = Color.red;
this.LabelStyles["red"].alignment = TextAnchor.MiddleCenter; this.LabelStyles["red"].alignment = TextAnchor.MiddleCenter;
   
this.iconStyle = new GUIStyle(GUI.skin.button); this.iconStyle = new GUIStyle(GUI.skin.button);
this.iconStyle.padding = new RectOffset(0, 0, 0, 0); this.iconStyle.padding = new RectOffset(0, 0, 0, 0);
// this.iconStyle.margin = new RectOffset(0, 0, 0, 0); // this.iconStyle.margin = new RectOffset(0, 0, 0, 0);
// this.iconStyle.contentOffset = new Vector2(0, 0); // this.iconStyle.contentOffset = new Vector2(0, 0);
this.iconStyle.overflow = new RectOffset(0, 0, 0, 0); this.iconStyle.overflow = new RectOffset(0, 0, 0, 0);
// this.iconStyle.border = new RectOffset(0, 0, 0, 0); // this.iconStyle.border = new RectOffset(0, 0, 0, 0);
   
this.GUIStylesLoaded = true; this.GUIStylesLoaded = true;
} }
   
protected void LoadVesselTypes() protected void LoadVesselTypes()
{ {
this._allVesselTypes = Enum.GetValues(typeof(VesselType)).OfType<VesselType>().ToList(); this._allVesselTypes = Enum.GetValues(typeof(VesselType)).OfType<VesselType>().ToList();
this.vesselTypesLoaded = true; this.vesselTypesLoaded = true;
} }
   
protected void LoadBeforeUpdate() protected void LoadBeforeUpdate()
{ {
if (!this.vesselTypesLoaded) if (!this.vesselTypesLoaded)
{ {
this.LoadVesselTypes(); this.LoadVesselTypes();
} }
} }
   
protected void LoadToolbarManager() protected void LoadToolbarManager()
{ {
this.ToolbarManagerLoaded = ToolbarButtonWrapper.ToolbarManagerPresent; this.ToolbarManagerLoaded = ToolbarButtonWrapper.ToolbarManagerPresent;
   
if (this.ToolbarManagerLoaded) if (this.ToolbarManagerLoaded)
{ {
this.InitializeToolbarButton(); this.InitializeToolbarButton();
} }
} }
   
protected void InitializeToolbarButton() protected void InitializeToolbarButton()
{ {
this.ToolbarButton = ToolbarButtonWrapper.TryWrapToolbarButton(this.GetType().Name, "coreToggle"); this.ToolbarButton = ToolbarButtonWrapper.TryWrapToolbarButton(this.GetType().Name, "coreToggle");
this.ToolbarButton.Text = this.VoidName; this.ToolbarButton.Text = this.VoidName;
this.ToolbarButton.TexturePath = this.VOIDIconOffActivePath; this.ToolbarButton.TexturePath = this.VOIDIconOffActivePath;
if (this is VOID_EditorCore) if (this is VOID_EditorCore)
{ {
this.ToolbarButton.SetButtonVisibility(new GameScenes[] { GameScenes.EDITOR }); this.ToolbarButton.SetButtonVisibility(new GameScenes[] { GameScenes.EDITOR });
} }
else else
{ {
this.ToolbarButton.SetButtonVisibility(new GameScenes[] { GameScenes.FLIGHT }); this.ToolbarButton.SetButtonVisibility(new GameScenes[] { GameScenes.FLIGHT });
} }
this.ToolbarButton.AddButtonClickHandler( this.ToolbarButton.AddButtonClickHandler(
(e) => (e) =>
{ {
this.mainGuiMinimized = !this.mainGuiMinimized; this.mainGuiMinimized = !this.mainGuiMinimized;
this.SetIconTexture(this.powerState | this.activeState); this.SetIconTexture(this.powerState | this.activeState);
} }
); );
} }
   
public void VOIDMainWindow(int _) public void VOIDMainWindow(int _)
{ {
GUILayout.BeginVertical(); GUILayout.BeginVertical();
if (this.powerAvailable || HighLogic.LoadedSceneIsEditor) if (this.powerAvailable || HighLogic.LoadedSceneIsEditor)
{ {
if (!HighLogic.LoadedSceneIsEditor) if (!HighLogic.LoadedSceneIsEditor)
{ {
string str = "ON"; string str = "ON";
if (togglePower) if (togglePower)
str = "OFF"; str = "OFF";
if (GUILayout.Button("Power " + str)) if (GUILayout.Button("Power " + str))
{ {
togglePower.value = !togglePower; togglePower.value = !togglePower;
this.SetIconTexture(this.powerState | this.activeState); this.SetIconTexture(this.powerState | this.activeState);
} }
} }
   
if (togglePower || HighLogic.LoadedSceneIsEditor) if (togglePower || HighLogic.LoadedSceneIsEditor)
{ {
foreach (IVOID_Module module in this.Modules) foreach (IVOID_Module module in this.Modules)
{ {
module.toggleActive = GUILayout.Toggle(module.toggleActive, module.Name); module.toggleActive = GUILayout.Toggle(module.toggleActive, module.Name);
} }
} }
} }
else else
{ {
GUILayout.Label("-- POWER LOST --", this.LabelStyles["red"]); GUILayout.Label("-- POWER LOST --", this.LabelStyles["red"]);
} }
   
this.configWindowMinimized.value = !GUILayout.Toggle(!this.configWindowMinimized, "Configuration"); this.configWindowMinimized.value = !GUILayout.Toggle(!this.configWindowMinimized, "Configuration");
   
GUILayout.EndVertical(); GUILayout.EndVertical();
GUI.DragWindow(); GUI.DragWindow();
} }
   
public void VOIDConfigWindow(int _) public void VOIDConfigWindow(int _)
{ {
GUILayout.BeginVertical(); GUILayout.BeginVertical();
   
this.DrawConfigurables(); this.DrawConfigurables();
   
GUILayout.EndVertical(); GUILayout.EndVertical();
GUI.DragWindow(); GUI.DragWindow();
} }
   
public override void DrawConfigurables() public override void DrawConfigurables()
{ {
int skinIdx; int skinIdx;
   
GUIContent _content; GUIContent _content;
   
if (HighLogic.LoadedSceneIsFlight) if (HighLogic.LoadedSceneIsFlight)
{ {
this.consumeResource.value = GUILayout.Toggle(this.consumeResource, "Consume Resources"); this.consumeResource.value = GUILayout.Toggle(this.consumeResource, "Consume Resources");
   
this.VOIDIconLocked = GUILayout.Toggle(this.VOIDIconLocked, "Lock Icon Position"); this.VOIDIconLocked = GUILayout.Toggle(this.VOIDIconLocked, "Lock Icon Position");
} }
   
this.UseToolbarManager = GUILayout.Toggle(this.UseToolbarManager, "Use Blizzy's Toolbar If Available"); this.UseToolbarManager = GUILayout.Toggle(this.UseToolbarManager, "Use Blizzy's Toolbar If Available");
   
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
   
GUILayout.Label("Skin:", GUILayout.ExpandWidth(false)); GUILayout.Label("Skin:", GUILayout.ExpandWidth(false));
   
_content = new GUIContent(); _content = new GUIContent();
   
if (skinNames.Contains(this._skinName)) if (skinNames.Contains(this._skinName))
{ {
skinIdx = skinNames.IndexOf(this._skinName); skinIdx = skinNames.IndexOf(this._skinName);
} }
else if (skinNames.Contains(this.defaultSkin)) else if (skinNames.Contains(this.defaultSkin))
{ {
skinIdx = skinNames.IndexOf(this.defaultSkin); skinIdx = skinNames.IndexOf(this.defaultSkin);
} }
else else
{ {
skinIdx = 0; skinIdx = 0;
} }
   
_content.text = "◄"; _content.text = "◄";
_content.tooltip = "Select previous skin"; _content.tooltip = "Select previous skin";
if (GUILayout.Button(_content, GUILayout.ExpandWidth(true))) if (GUILayout.Button(_content, GUILayout.ExpandWidth(true)))
{ {
this.GUIStylesLoaded = false; this.GUIStylesLoaded = false;
skinIdx--; skinIdx--;
if (skinIdx < 0) if (skinIdx < 0)
skinIdx = skinNames.Count - 1; skinIdx = skinNames.Count - 1;
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: new this._skinIdx = {1} :: skin_list.Count = {2}", "{0}: new this._skinIdx = {1} :: skin_list.Count = {2}",
this.GetType().Name, this.GetType().Name,
this._skinName, this._skinName,
this.skin_list.Count this.skin_list.Count
)); ));
} }
   
_content.text = this.Skin.name; _content.text = this.Skin.name;
_content.tooltip = "Current skin"; _content.tooltip = "Current skin";
GUILayout.Label(_content, this.LabelStyles["center"], GUILayout.ExpandWidth(true)); GUILayout.Label(_content, this.LabelStyles["center"], GUILayout.ExpandWidth(true));
   
_content.text = "►"; _content.text = "►";
_content.tooltip = "Select next skin"; _content.tooltip = "Select next skin";
if (GUILayout.Button(_content, GUILayout.ExpandWidth(true))) if (GUILayout.Button(_content, GUILayout.ExpandWidth(true)))
{ {
this.GUIStylesLoaded = false; this.GUIStylesLoaded = false;
skinIdx++; skinIdx++;
if (skinIdx >= skinNames.Count) if (skinIdx >= skinNames.Count)
skinIdx = 0; skinIdx = 0;
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: new this._skinIdx = {1} :: skin_list.Count = {2}", "{0}: new this._skinIdx = {1} :: skin_list.Count = {2}",
this.GetType().Name, this.GetType().Name,
this._skinName, this._skinName,
this.skin_list.Count this.skin_list.Count
)); ));
} }
   
if (this._skinName != skinNames[skinIdx]) if (this._skinName != skinNames[skinIdx])
{ {
this._skinName = skinNames[skinIdx]; this._skinName = skinNames[skinIdx];
} }
   
GUILayout.EndHorizontal(); GUILayout.EndHorizontal();
   
GUILayout.BeginHorizontal(); GUILayout.BeginHorizontal();
GUILayout.Label("Update Rate (Hz):"); GUILayout.Label("Update Rate (Hz):");
if (this.stringFrequency == null) if (this.stringFrequency == null)
{ {
this.stringFrequency = (1f / this.updatePeriod).ToString(); this.stringFrequency = (1f / this.updatePeriod).ToString();
} }
this.stringFrequency = GUILayout.TextField(this.stringFrequency.ToString(), 5, GUILayout.ExpandWidth(true)); this.stringFrequency = GUILayout.TextField(this.stringFrequency.ToString(), 5, GUILayout.ExpandWidth(true));
// GUILayout.FlexibleSpace(); // GUILayout.FlexibleSpace();
if (GUILayout.Button("Apply")) if (GUILayout.Button("Apply"))
{ {
double updateFreq = 1f / this.updatePeriod; double updateFreq = 1f / this.updatePeriod;
double.TryParse(stringFrequency, out updateFreq); double.TryParse(stringFrequency, out updateFreq);
this._updatePeriod = 1 / updateFreq; this._updatePeriod = 1 / updateFreq;
} }
GUILayout.EndHorizontal(); GUILayout.EndHorizontal();
   
foreach (IVOID_Module mod in this.Modules) foreach (IVOID_Module mod in this.Modules)
{ {
mod.DrawConfigurables(); mod.DrawConfigurables();
} }
   
this._factoryReset = GUILayout.Toggle(this._factoryReset, "Factory Reset"); this._factoryReset = GUILayout.Toggle(this._factoryReset, "Factory Reset");
} }
   
public override void DrawGUI() public override void DrawGUI()
{ {
this._windowID = this.windowBaseID; this._windowID = this.windowBaseID;
   
if (!this._modulesLoaded) if (!this._modulesLoaded)
{ {
this.LoadModulesOfType<IVOID_Module>(); this.LoadModulesOfType<IVOID_Module>();
} }
   
if (this.UseToolbarManager && !this.ToolbarManagerLoaded) if (this.UseToolbarManager && !this.ToolbarManagerLoaded)
{ {
this.LoadToolbarManager(); this.LoadToolbarManager();
} }
   
if (!this.skinsLoaded) if (!this.skinsLoaded)
{ {
this.LoadSkins(); this.LoadSkins();
} }
   
GUI.skin = this.Skin; GUI.skin = this.Skin;
   
if (!this.GUIStylesLoaded) if (!this.GUIStylesLoaded)
{ {
this.LoadGUIStyles(); this.LoadGUIStyles();
} }
   
if (!(this.UseToolbarManager && this.ToolbarManagerLoaded)) if (!(this.UseToolbarManager && this.ToolbarManagerLoaded))
{ {
if (GUI.Button(VOIDIconPos, VOIDIconTexture, this.iconStyle) && this.VOIDIconLocked) if (GUI.Button(VOIDIconPos, VOIDIconTexture, this.iconStyle) && this.VOIDIconLocked)
{ {
this.mainGuiMinimized.value = !this.mainGuiMinimized; this.mainGuiMinimized.value = !this.mainGuiMinimized;
this.SetIconTexture(this.powerState | this.activeState); this.SetIconTexture(this.powerState | this.activeState);
} }
} }
   
if (!this.mainGuiMinimized) if (!this.mainGuiMinimized)
{ {
   
Rect _mainWindowPos = this.mainWindowPos; Rect _mainWindowPos = this.mainWindowPos;
   
_mainWindowPos = GUILayout.Window( _mainWindowPos = GUILayout.Window(
this.windowID, this.windowID,
_mainWindowPos, _mainWindowPos,
this.VOIDMainWindow, this.VOIDMainWindow,
string.Join(" ", new string[] { this.VoidName, this.VoidVersion }), string.Join(" ", new string[] { this.VoidName, this.VoidVersion }),
GUILayout.Width(250), GUILayout.Width(250),
GUILayout.Height(50) GUILayout.Height(50)
); );
   
_mainWindowPos = Tools.ClampRectToScreen(_mainWindowPos); _mainWindowPos = Tools.ClampRectToScreen(_mainWindowPos);
   
if (_mainWindowPos != this.mainWindowPos) if (_mainWindowPos != this.mainWindowPos)
{ {
this.mainWindowPos = _mainWindowPos; this.mainWindowPos = _mainWindowPos;
} }
} }
   
if (!this.configWindowMinimized && !this.mainGuiMinimized) if (!this.configWindowMinimized && !this.mainGuiMinimized)
{ {
Rect _configWindowPos = this.configWindowPos; Rect _configWindowPos = this.configWindowPos;
   
_configWindowPos = GUILayout.Window( _configWindowPos = GUILayout.Window(
this.windowID, this.windowID,
_configWindowPos, _configWindowPos,
this.VOIDConfigWindow, this.VOIDConfigWindow,
string.Join(" ", new string[] { this.VoidName, "Configuration" }), string.Join(" ", new string[] { this.VoidName, "Configuration" }),
GUILayout.Width(250), GUILayout.Width(250),
GUILayout.Height(50) GUILayout.Height(50)
); );
   
_configWindowPos = Tools.ClampRectToScreen(_configWindowPos); _configWindowPos = Tools.ClampRectToScreen(_configWindowPos);
   
if (_configWindowPos != this.configWindowPos) if (_configWindowPos != this.configWindowPos)
{ {
this.configWindowPos = _configWindowPos; this.configWindowPos = _configWindowPos;
} }
} }
} }
   
public void OnGUI() public void OnGUI()
{ {
if (Event.current.type == EventType.Repaint) if (Event.current.type == EventType.Repaint)
{ {
return; return;
} }
   
/* /*
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"Event.current.type: {0}" + "Event.current.type: {0}" +
"\nthis.VOIDIconLocked: {1}" + "\nthis.VOIDIconLocked: {1}" +
"\nEvent.current.mousePosition: {2}" + "\nEvent.current.mousePosition: {2}" +
"\nVOIDIconPos: ({3}, {4}),({5}, {6})", "\nVOIDIconPos: ({3}, {4}),({5}, {6})",
Event.current.type, Event.current.type,
this.VOIDIconLocked, this.VOIDIconLocked,
Event.current.mousePosition, Event.current.mousePosition,
this.VOIDIconPos.value.xMin, this.VOIDIconPos.value.xMin,
this.VOIDIconPos.value.yMin, this.VOIDIconPos.value.yMin,
this.VOIDIconPos.value.xMax, this.VOIDIconPos.value.xMax,
this.VOIDIconPos.value.yMax this.VOIDIconPos.value.yMax
)); ));
*/ */
   
if (!this.VOIDIconLocked && if (!this.VOIDIconLocked &&
VOIDIconPos.value.Contains(Event.current.mousePosition) VOIDIconPos.value.Contains(Event.current.mousePosition)
&& Event.current.type == EventType.mouseDrag) && Event.current.type == EventType.mouseDrag)
{ {
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"Event.current.type: {0}" + "Event.current.type: {0}" +
"\ndelta.x: {1}; delta.y: {2}", "\ndelta.x: {1}; delta.y: {2}",
Event.current.type, Event.current.type,
Event.current.delta.x, Event.current.delta.x,
Event.current.delta.y Event.current.delta.y
)); ));
   
Rect tmp = new Rect(VOIDIconPos); Rect tmp = new Rect(VOIDIconPos);
   
tmp.x = Event.current.mousePosition.x - tmp.width / 2; tmp.x = Event.current.mousePosition.x - tmp.width / 2;
tmp.y = Event.current.mousePosition.y - tmp.height / 2; tmp.y = Event.current.mousePosition.y - tmp.height / 2;
   
if (tmp.x > Screen.width - tmp.width) if (tmp.x > Screen.width - tmp.width)
{ {
tmp.x = Screen.width - tmp.width; tmp.x = Screen.width - tmp.width;
} }
   
if (tmp.y > Screen.height - tmp.height) if (tmp.y > Screen.height - tmp.height)
{ {
tmp.y = Screen.height - tmp.height; tmp.y = Screen.height - tmp.height;
} }
   
VOIDIconPos = tmp; VOIDIconPos = tmp;
} }
} }
   
public void Update() public void Update()
{ {
this.LoadBeforeUpdate(); this.LoadBeforeUpdate();
   
if (this.vessel != null) if (this.vessel != null)
{ {
SimManager.Instance.Gravity = VOID_Core.Instance.vessel.mainBody.gravParameter / SimManager.Instance.Gravity = VOID_Core.Instance.vessel.mainBody.gravParameter /
Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2); Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2);
SimManager.Instance.TryStartSimulation(); SimManager.Instance.TryStartSimulation();
} }
   
if (!this.guiRunning) if (!this.guiRunning)
{ {
this.StartGUI(); this.StartGUI();
} }
   
if (!HighLogic.LoadedSceneIsFlight && this.guiRunning) if (!HighLogic.LoadedSceneIsFlight && this.guiRunning)
{ {
this.StopGUI(); this.StopGUI();
} }
   
foreach (IVOID_Module module in this.Modules) foreach (IVOID_Module module in this.Modules)
{ {
if (!module.guiRunning && module.toggleActive) if (!module.guiRunning && module.toggleActive)
{ {
module.StartGUI(); module.StartGUI();
} }
if (module.guiRunning && !module.toggleActive || if (module.guiRunning && !module.toggleActive ||
!this.togglePower || !this.togglePower ||
!HighLogic.LoadedSceneIsFlight || !HighLogic.LoadedSceneIsFlight ||
this.factoryReset) this.factoryReset)
{ {
module.StopGUI(); module.StopGUI();
} }
   
if (module is IVOID_BehaviorModule) if (module is IVOID_BehaviorModule)
{ {
((IVOID_BehaviorModule)module).Update(); ((IVOID_BehaviorModule)module).Update();
} }
} }
   
this.CheckAndSave(); this.CheckAndSave();
this._updateTimer += Time.deltaTime; this._updateTimer += Time.deltaTime;
} }
   
public void FixedUpdate() public void FixedUpdate()
{ {
bool newPowerState = this.powerAvailable; bool newPowerState = this.powerAvailable;
   
if (this.consumeResource && if (this.togglePower && this.consumeResource &&
this.vessel.vesselType != VesselType.EVA && this.vessel.vesselType != VesselType.EVA &&
TimeWarp.deltaTime != 0) TimeWarp.deltaTime != 0)
{ {
float powerReceived = this.vessel.rootPart.RequestResource(this.resourceName, float powerReceived = this.vessel.rootPart.RequestResource(
this.resourceRate * TimeWarp.fixedDeltaTime); this.resourceName,
  this.resourceRate * TimeWarp.fixedDeltaTime
  );
   
if (powerReceived > 0) if (powerReceived > 0)
{ {
newPowerState = true; newPowerState = true;
} }
else else
{ {
newPowerState = false; newPowerState = false;
} }
   
if (this.powerAvailable != newPowerState) if (this.powerAvailable != newPowerState)
{ {
this.powerAvailable = newPowerState; this.powerAvailable = newPowerState;
this.SetIconTexture(this.powerState | this.activeState); this.SetIconTexture(this.powerState | this.activeState);
} }
} }
   
foreach (IVOID_BehaviorModule module in foreach (IVOID_BehaviorModule module in
this._modules.OfType<IVOID_BehaviorModule>().Where(m => !m.GetType().IsAbstract)) this._modules.OfType<IVOID_BehaviorModule>().Where(m => !m.GetType().IsAbstract))
{ {
module.FixedUpdate(); module.FixedUpdate();
} }
} }
   
public void ResetGUI() public void ResetGUI()
{ {
this.StopGUI(); this.StopGUI();
   
foreach (IVOID_Module module in this.Modules) foreach (IVOID_Module module in this.Modules)
{ {
module.StopGUI(); module.StopGUI();
module.StartGUI(); module.StartGUI();
} }
   
this.StartGUI(); this.StartGUI();
} }
   
protected void SetIconTexture(IconState state) protected void SetIconTexture(IconState state)
{ {
switch (state) switch (state)
{ {
case (IconState.PowerOff | IconState.Inactive): case (IconState.PowerOff | IconState.Inactive):
this.SetIconTexture(this.VOIDIconOffInactivePath); this.SetIconTexture(this.VOIDIconOffInactivePath);
break; break;
case (IconState.PowerOff | IconState.Active): case (IconState.PowerOff | IconState.Active):
this.SetIconTexture(this.VOIDIconOffActivePath); this.SetIconTexture(this.VOIDIconOffActivePath);
break; break;
case (IconState.PowerOn | IconState.Inactive): case (IconState.PowerOn | IconState.Inactive):
this.SetIconTexture(this.VOIDIconOnInactivePath); this.SetIconTexture(this.VOIDIconOnInactivePath);
break; break;
case (IconState.PowerOn | IconState.Active): case (IconState.PowerOn | IconState.Active):
this.SetIconTexture(this.VOIDIconOnActivePath); this.SetIconTexture(this.VOIDIconOnActivePath);
break; break;
default: default:
throw new NotImplementedException(); throw new NotImplementedException();
} }
} }
   
protected void SetIconTexture(string texturePath) protected void SetIconTexture(string texturePath)
{ {
if (this.UseToolbarManager && this.ToolbarButton != null) if (this.UseToolbarManager && this.ToolbarButton != null)
{ {
this.ToolbarButton.TexturePath = texturePath; this.ToolbarButton.TexturePath = texturePath;
} }
else else
{ {
this.VOIDIconTexture = GameDatabase.Instance.GetTexture(texturePath, false); this.VOIDIconTexture = GameDatabase.Instance.GetTexture(texturePath, false);
} }
} }
   
protected void CheckAndSave() protected void CheckAndSave()
{ {
this.saveTimer += Time.deltaTime; this.saveTimer += Time.deltaTime;
   
if (this.saveTimer > 2f) if (this.saveTimer > 2f)
{ {
if (!this.configDirty) if (!this.configDirty)
{ {
return; return;
} }
   
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: Time to save, checking if configDirty: {1}", "{0}: Time to save, checking if configDirty: {1}",
this.GetType().Name, this.GetType().Name,
this.configDirty this.configDirty
)); ));
   
this.SaveConfig(); this.SaveConfig();
this.saveTimer = 0; this.saveTimer = 0;
} }
} }
   
public override void LoadConfig() public override void LoadConfig()
{ {
base.LoadConfig(); base.LoadConfig();
   
foreach (IVOID_Module module in this.Modules) foreach (IVOID_Module module in this.Modules)
{ {
module.LoadConfig(); module.LoadConfig();
} }
} }
   
public void SaveConfig() public void SaveConfig()
{ {
var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core>(); var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core>();
config.load(); config.load();
   
this._SaveToConfig(config); this._SaveToConfig(config);
   
foreach (IVOID_Module module in this.Modules) foreach (IVOID_Module module in this.Modules)
{ {
module._SaveToConfig(config); module._SaveToConfig(config);
} }
   
config.save(); config.save();
   
this.configDirty = false; this.configDirty = false;
} }
   
protected enum IconState protected enum IconState
{ {
PowerOff = 1, PowerOff = 1,
PowerOn = 2, PowerOn = 2,
Inactive = 4, Inactive = 4,
Active = 8 Active = 8
} }
} }
} }