using UnityEditor;
using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text.RegularExpressions;
using System.Linq;
using System.IO;
using Perforce.P4;
namespace P4Connect
{
[Serializable]
public class ConfigAsset : ScriptableObject
{
// These are the config values
// We serialize this Class and place it in the P4Connect/Editor Asset Hierarchy
public string ServerURI;
public string Username;
public string Password;
public string Workspace;
public bool UseP4Config;
public string P4ConfigName;
public bool UnityVSSupport;
public bool IncludeProjectFiles;
public bool IncludeSolutionFiles;
public bool ShowPaths;
public bool AskBeforeCheckout;
public bool DisplayStatusIcons;
public string Hostname;
public string Charset;
public string DiffToolPathname;
public bool DisplayP4Timings;
public bool DisplayP4Commands;
public bool CheckStatusForMenus;
public int CheckStatusForMenusMaxItems;
public int ConnectionTimeOut;
public string ProjectRoot;
public bool WarnOnSpecialCharacters;
public bool UseIgnore;
public string IgnoreName;
public bool EnableLog;
public string LogPath;
public bool SaveConfigAsset;
public string IgnoreLines;
// Copy the contents of this ConfigAsset into the P4Connect Config class.
public void CopyAssetToConfig()
{
Config.ServerURI = ServerURI;
Config.Username = Username;
Config.Password = Password;
Config.Workspace = Workspace;
Config.UseP4Config = UseP4Config;
Config.UnityVSSupport = UnityVSSupport;
Config.IncludeProjectFiles = IncludeProjectFiles;
Config.IncludeSolutionFiles = IncludeSolutionFiles;
Config.ShowPaths = ShowPaths;
Config.AskBeforeCheckout = AskBeforeCheckout;
Config.DisplayStatusIcons = DisplayStatusIcons;
Config.Hostname = Hostname;
Config.Charset = Charset;
Config.DiffToolPathname = DiffToolPathname;
Config.DisplayP4Timings = DisplayP4Timings;
Config.DisplayP4Commands = DisplayP4Commands;
Config.CheckStatusForMenus = CheckStatusForMenus;
Config.CheckStatusForMenusMaxItems = CheckStatusForMenusMaxItems;
Config.ConnectionTimeOut = ConnectionTimeOut;
Config.ProjectRoot = ProjectRoot;
Config.WarnOnSpecialCharacters = WarnOnSpecialCharacters;
Config.UseIgnore = UseIgnore;
Config.IgnoreName = IgnoreName;
Config.EnableLog = EnableLog;
Config.LogPath = LogPath;
Config.P4ConfigName = P4ConfigName;
Config.SaveConfigAsset = SaveConfigAsset;
Config.IgnoreLines = IgnoreLines;
}
// Seed a ConfigAsset with data from the Config Class
public void CopyConfigToAsset()
{
ServerURI = Config.ServerURI;
Username = Config.Username;
Password = Config.Password;
Workspace = Config.Workspace;
UseP4Config = Config.UseP4Config;
UnityVSSupport = Config.UnityVSSupport;
IncludeProjectFiles = Config.IncludeProjectFiles;
IncludeSolutionFiles = Config.IncludeSolutionFiles;
ShowPaths = Config.ShowPaths;
AskBeforeCheckout = Config.AskBeforeCheckout;
DisplayStatusIcons = Config.DisplayStatusIcons;
Hostname = Config.Hostname;
Charset = Config.Charset;
DiffToolPathname = Config.DiffToolPathname;
DisplayP4Timings = Config.DisplayP4Timings;
DisplayP4Commands = Config.DisplayP4Commands;
CheckStatusForMenus = Config.CheckStatusForMenus;
CheckStatusForMenusMaxItems = Config.CheckStatusForMenusMaxItems;
ConnectionTimeOut = Config.ConnectionTimeOut;
ProjectRoot = Config.ProjectRoot;
WarnOnSpecialCharacters = Config.WarnOnSpecialCharacters;
UseIgnore = Config.UseIgnore;
IgnoreName = Config.IgnoreName;
EnableLog = Config.EnableLog;
LogPath = Config.LogPath;
P4ConfigName = Config.P4ConfigName;
SaveConfigAsset = Config.SaveConfigAsset;
IgnoreLines = Config.IgnoreLines;
}
}
// This Editor window allows the user to set and store
// Perforce connection settings that will be used to
// Check out files on Save / Move / Delete / etc...
// The connection parameters are saved as Editor Preferences
// which means they go the registry.
public class Config : EditorWindow
{
// Event triggered when the configuration changes
public delegate void OnPrefsChanged();
public static event OnPrefsChanged PrefsChanged;
#region Properties
// Give access to the Server URI
public static string ServerURI { get; set; }
// Give access to the User Name
public static string Username { get; set; }
// Give access to the Password
public static string Password { get; set; }
// Give access to the Workspace Name
public static string Workspace { get; set; }
// Look for p4config files to setup configuration?
public static bool UseP4Config { get; set; }
// Give access to whether we integrate with UnityVS
public static bool UnityVSSupport { get; set; }
// Give access to whether the integration is turned on or not
public static bool PerforceEnabled { get; set; }
// Give access to whether we check out solution files
public static bool IncludeSolutionFiles { get; set; }
// Give access to whether we check out project files
public static bool IncludeProjectFiles { get; set; }
// Give access to whether we print out paths or just filenames
public static bool ShowPaths { get; set; }
// Give access to whether we automatically check out on edit
public static bool AskBeforeCheckout { get; set; }
// Give access to whether we want to display Icons in the Project view
public static bool DisplayStatusIcons { get; set; }
// Whether to override P4Host
public static bool OverrideHostname { get; set; }
// The host name, if different than the local machine
public static string Hostname { get; set; }
// Whether to override P4Charset
public static bool OverrideCharset { get; set; }
// The host name, if different than the local machine
public static string Charset { get; set; }
// The location of the Diff tool
public static string DiffToolPathname { get; set; }
// Whether or not to display timing info for debugging
public static bool DisplayP4Timings { get; set; }
// Whether to display the commands sent to P4
public static bool DisplayP4Commands { get; set; }
// Whether or not to check the status of files before showing the contextual menu
public static bool CheckStatusForMenus { get; set; }
// Whether or not to warn when adding files with special characters
public static bool WarnOnSpecialCharacters { get; set; }
// Whether or not to check the status of files before showing the contextual menu
public static int CheckStatusForMenusMaxItems { get; set; }
// How many files to submit at once
public static int OperationBatchCount { get; set; }
// How long to keep connections open
public static int ConnectionTimeOut { get; set; }
// The location of the project root in relation to the workspace root
public static string ProjectRoot { get; set; }
// Enable the Ignore file
public static bool UseIgnore { get; set; }
// Provide an Ignore file name
public static string IgnoreName { get; set; }
// Enable p4bridge Logging
public static bool EnableLog { get; set; }
// Where to save log output
public static string LogPath { get; set; }
// Provide a P4config filename
public static string P4ConfigName { get; set; }
// Set to enable saving config asset
public static bool SaveConfigAsset { get; set; }
// Additional Ignore Lines
public static string IgnoreLines { get; set; }
static string p4configFile;
static string prevP4ConfigName;
#endregion
static bool FoundConfigAsset;
// Helper property to indicate that P4 can be used
public static bool ValidConfiguration
{
get { return PerforceEnabled && _CurrentState == ConfigurationState.SettingsValid; }
}
public const string P4BridgeDLLName = "p4bridge.dll";
public const string P4BridgeDYLIBName = "libp4bridge.dylib";
public const int MaxPendingItems = 200;
#region Registry Names
// These are the names under which the connection settings are stored in the registry
public const string ServerURIPrefName = "ServerURI";
public const string UserNamePrefName = "UserName";
public const string PasswordPrefName = "Password";
public const string WorkspacePrefName = "Workspace";
public const string P4ConfigPrefName = "UseP4Config";
public const string PerforceEnabledPrefName = "Enabled";
public const string UnityVSSupportPrefName = "UnityVSSupport";
public const string IncludeProjectFilesPrefName = "IncludeProjectFiles";
public const string IncludeSolutionFilesPrefName = "IncludeSolutionFiles";
public const string ShowPathsPrefName = "ShowPaths";
public const string AskBeforeCheckoutPrefName = "AskBeforeCheckout";
public const string DisplayStatusIconsPrefName = "DisplayStatusIcons";
public const string HostnamePrefName = "Hostname";
public const string DiffToolPathnamePrefName = "DiffToolPathname";
public const string DisplayP4TimingsPrefName = "DisplayTimings";
public const string DisplayP4CommandsPrefName = "DisplayCommands";
public const string CheckStatusForMenusPrefName = "CheckStatusForMenus";
public const string CheckStatusForMenusMaxItemsPrefName = "CheckStatusForMenusMaxItems";
public const string OperationBatchCountPrefName = "OperationBatchCount";
public const string ConnectionTimeOutPrefName = "ConnectionTimeOut";
public const string OverrideHostnamePrefName = "OverrideHostname";
public const string WarnOnSpecialCharactersPrefName = "WarnOnSpecialCharacters";
public const string UseIgnorePrefName = "UseIgnore";
public const string IgnoreNamePrefName = "IgnoreName";
public const string EnableLogPrefName = "EnableLog";
public const string LogPathPrefName = "LogPath";
public const string P4ConfigNamePrefName = "p4ConfigName";
public const string SaveConfigAssetPrefName = "SaveConfigAsset";
public const string IgnoreLinesPrefName = "IgnoreLines";
#endregion
// Used to create controls
static GUIContent _RevertSettings = new GUIContent("Revert", "Revert settings to previously saved value");
static GUIContent _SaveSettings = new GUIContent("Save", "Saves the current settings");
static GUILayoutOption _ButtonWidth = GUILayout.MaxWidth(50.0f);
static GUILayoutOption _RevertSaveButtonWidth = GUILayout.MaxWidth(80.0f);
static GUILayoutOption _WideButtonWidth = GUILayout.MaxWidth(100.0f);
static GUILayoutOption _LabelWidth = GUILayout.MaxWidth(300.0f);
// The current state of the configuration, whether it is valid to be used
enum ConfigurationState
{
Unknown = 0,
MetaFilesInvalid,
MetaFilesValid,
P4ConfigValid,
ServerInvalid,
ServerValid,
UsernamePassInvalid,
UsernamePassValid,
WorkspaceInvalid,
WorkspaceValid,
ProjectRootInvalid,
ProjectRootValid,
SettingsValid,
}
// The current state of the configuration, whether it is valid to be used
static ConfigurationState _CurrentState = ConfigurationState.Unknown;
// Toggles the extra options
int _FrameIndex = 0;
bool _SettingsChanged = false;
bool _Repaint = false;
///
/// Set some default configuration values
///
static Config()
{
// Set some default values
ServerURI = "YourServer:1666";
Username = "YourUsername";
Password = "";
Workspace = "Username_Workspace_Machine";
UseP4Config = true;
UseIgnore = true;
UnityVSSupport = false;
PerforceEnabled = false;
IncludeProjectFiles = false;
IncludeSolutionFiles = false;
ShowPaths = false;
AskBeforeCheckout = false;
DisplayStatusIcons = true;
Hostname = "";
Charset = "";
DiffToolPathname = "";
DisplayP4Timings = false;
DisplayP4Commands = false;
CheckStatusForMenus = true;
CheckStatusForMenusMaxItems = 10;
ConnectionTimeOut = 30;
ProjectRoot = "";
WarnOnSpecialCharacters = true;
FoundConfigAsset = false;
UseIgnore = false;
IgnoreName = ".p4ignore";
EnableLog = false;
LogPath = "p4connect.log";
P4ConfigName = ".p4config";
p4configFile = null;
prevP4ConfigName = null;
SaveConfigAsset = false;
IgnoreLines = "";
}
// Add menu item to show the configuration panel
[MenuItem("Edit/Perforce Settings", false, 300)]
public static void ShowWindow()
{
// Show existing window instance. If one doesn't exist, make one.
Config window = EditorWindow.GetWindow("P4 Settings");
window.name = "P4 Settings";
window.title = "P4 Settings";
window.minSize = new UnityEngine.Vector2(500.0f, 500.0f);
}
///
/// Static Constructor, reads connection settings from Prefs at least once
///
public static void Initialize()
{
FoundConfigAsset = readConfigAsset();
if (! FoundConfigAsset)
{
ReadEnvironment(); // get P4 environment variables if they exist
ReadPrefs(); // Get EditorPrefs if they exist
}
CachedSerializationMode = EditorSettings.serializationMode;
_CurrentState = ConfigurationState.Unknown;
CheckSettings(); // Check to see if the settings are good.
}
///
/// Forces the config to be invalid, usually after an error
///
public static void NeedToCheckSettings()
{
_CurrentState = ConfigurationState.Unknown;
Debug.LogWarning("P4Connect - Perforce integration is enabled but inactive. Go to Edit->Perforce Settings to update your settings");
}
///
/// Checks the that settings are valid
///
public static void CheckSettings()
{
if (PerforceEnabled)
{
// We only display a message when something changes
ConfigurationState prevState = _CurrentState;
_CurrentState = ConfigurationState.Unknown;
// Check the config
UpdateConfigState();
// And notify user
if (_CurrentState != prevState)
{
Icons.UpdateDisplay();
if (_CurrentState != ConfigurationState.SettingsValid)
{
Debug.LogWarning("P4Connect - Perforce integration is enabled but inactive. Go to Edit->Perforce Settings to update your settings");
}
else if (prevState != ConfigurationState.SettingsValid)
{
Debug.Log("P4Connect - Perforce Integration is Active");
}
}
if (_CurrentState == ConfigurationState.SettingsValid)
{
SetProjectRootDirectory();
}
}
}
public static void SetProjectRootDirectory()
{
if (Config.ValidConfiguration)
{
Engine.PerformConnectionOperation(con =>
{
var spec = FileSpec.LocalSpec(System.IO.Path.Combine(Main.RootPath, "..."));
var mappings = con.P4Client.GetClientFileMappings(spec);
if (mappings != null && mappings.Count > 0)
{
string clientProjectRoot = mappings[0].ClientPath.Path;
int projectRootOffset = clientProjectRoot.ToLowerInvariant().IndexOf(Config.Workspace.ToLowerInvariant());
if (projectRootOffset != -1)
{
ProjectRoot = clientProjectRoot.Substring(projectRootOffset + Config.Workspace.Length);
ProjectRoot = ProjectRoot.TrimStart(System.IO.Path.DirectorySeparatorChar, '/');
if (ProjectRoot.EndsWith("..."))
ProjectRoot = ProjectRoot.Substring(0, ProjectRoot.Length - 3);
ProjectRoot = ProjectRoot.TrimEnd(System.IO.Path.DirectorySeparatorChar, '/');
ProjectRoot = ProjectRoot.Replace('/', System.IO.Path.DirectorySeparatorChar);
}
else
{
Debug.LogError("P4Connect - Your Project does not appear to be under your workspace root.");
}
}
});
}
}
///
/// Updates the current configuration state after checking all the settings
///
public static void UpdateConfigState()
{
switch (_CurrentState)
{
case ConfigurationState.Unknown:
// The unknown state starts by checking the meta files
goto case ConfigurationState.MetaFilesInvalid;
case ConfigurationState.MetaFilesInvalid:
if (P4Connect.VerifySettings.CheckMetaFiles())
{
// Meta files are valid, move on
_CurrentState = ConfigurationState.MetaFilesValid;
goto case ConfigurationState.MetaFilesValid;
}
else
{
// Stay in this state
_CurrentState = ConfigurationState.MetaFilesInvalid;
break;
}
case ConfigurationState.MetaFilesValid:
goto case ConfigurationState.P4ConfigValid;
case ConfigurationState.P4ConfigValid:
{
_CurrentState = ConfigurationState.ServerInvalid;
goto case ConfigurationState.ServerInvalid;
}
case ConfigurationState.ServerInvalid:
if (P4Connect.VerifySettings.CheckServerURI())
{
// Server is valid, move on
_CurrentState = ConfigurationState.ServerValid;
goto case ConfigurationState.ServerValid;
}
else
{
// Stay here
_CurrentState = ConfigurationState.ServerInvalid;
break;
}
case ConfigurationState.ServerValid:
goto case ConfigurationState.UsernamePassInvalid;
case ConfigurationState.UsernamePassInvalid:
if (P4Connect.VerifySettings.CheckUsernamePassword())
{
// Username / Password is valid, move on
_CurrentState = ConfigurationState.UsernamePassValid;
goto case ConfigurationState.UsernamePassValid;
}
else
{
// Stay here
_CurrentState = ConfigurationState.UsernamePassInvalid;
break;
}
case ConfigurationState.UsernamePassValid:
goto case ConfigurationState.WorkspaceInvalid;
case ConfigurationState.WorkspaceInvalid:
if (P4Connect.VerifySettings.CheckWorkspace())
{
// Workspace is valid
_CurrentState = ConfigurationState.WorkspaceValid;
goto case ConfigurationState.WorkspaceValid;
}
else
{
// Stay here
_CurrentState = ConfigurationState.WorkspaceInvalid;
break;
}
case ConfigurationState.WorkspaceValid:
goto case ConfigurationState.ProjectRootInvalid;
case ConfigurationState.ProjectRootInvalid:
if (P4Connect.VerifySettings.CheckProjectRoot())
{
// Root is valid
_CurrentState = ConfigurationState.ProjectRootValid;
goto case ConfigurationState.ProjectRootValid;
}
else
{
// Stay here
_CurrentState = ConfigurationState.ProjectRootInvalid;
break;
}
case ConfigurationState.ProjectRootValid:
_CurrentState = ConfigurationState.SettingsValid;
goto case ConfigurationState.SettingsValid;
case ConfigurationState.SettingsValid:
break;
}
// Clean up the connection
PerforceConnection.ForceCloseConnection();
}
///
/// Called by Unity when the windows needs to be updated
///
void OnGUI()
{
// This will store whether the user requested to check the settings
bool checkSettings = false;
// Track scroll position in the additional ignore TextArea
Vector2 scroll = new Vector2(0,0);
// Add a global checkbox to turn perforce integration on/off
bool newPerforceEnabled = EditorGUILayout.BeginToggleGroup("Enable Perforce Integration", PerforceEnabled);
if (newPerforceEnabled != PerforceEnabled)
{
PerforceEnabled = newPerforceEnabled;
PendingChanges.UpdateDisplay();
Icons.UpdateDisplay();
if (PerforceEnabled)
Initialize();
_SettingsChanged = true;
}
if (PerforceEnabled)
{
float checkWidth = 16.0f;
float intWidth = 30.0f;
float textWidth = 250.0f;
float secondtextWidth = 200.0f;
float pathWidth = 300.0f;
int maxFrameCount = 2; // seems to be the right number of repaints needed to display something
if (_FrameIndex < maxFrameCount)
{
EditorGUILayout.HelpBox("Please Wait! Checking Perforce Settings. This can take up to 20 seconds...", MessageType.Info);
if (Event.current.type == EventType.Repaint)
{
++_FrameIndex;
_Repaint = true;
}
if (_FrameIndex == maxFrameCount)
{
// Force update the config state at least once
ConfigurationState oldState = _CurrentState;
_CurrentState = ConfigurationState.Unknown;
UpdateConfigState();
if (_CurrentState != oldState)
{
_SettingsChanged = true;
}
}
}
else
{
GUILayout.Label("Connection Settings", EditorStyles.boldLabel);
if (_CurrentState >= ConfigurationState.MetaFilesValid)
{
// Don't let the user change any of the remaining settings unless the DLL is valid
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.BeginVertical();
// The edit field for the server
string newServerURI = EditorGUILayout.TextField("\tServer URI", ServerURI);
if (newServerURI != ServerURI)
{
ServerURI = newServerURI;
_CurrentState = ConfigurationState.MetaFilesValid;
}
EditorGUILayout.EndVertical();
// The button to verify it
bool serverValid = _CurrentState >= ConfigurationState.ServerValid;
EditorGUI.BeginDisabledGroup(serverValid);
{
if (GUILayout.Button(serverValid ? "Valid!" : "Verify", EditorStyles.miniButton, _ButtonWidth))
{
checkSettings = true;
_SettingsChanged = true;
}
}
EditorGUI.EndDisabledGroup();
}
EditorGUILayout.EndHorizontal();
if (_CurrentState == ConfigurationState.ServerInvalid)
{
EditorGUILayout.HelpBox("Invalid Server URI", MessageType.Error);
}
EditorGUI.BeginDisabledGroup(_CurrentState < ConfigurationState.ServerValid);
{
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.BeginVertical();
// The edit field for the username
string newUsername = EditorGUILayout.TextField("\tUsername", Username);
if (newUsername != Username)
{
Username = newUsername;
_CurrentState = ConfigurationState.ServerValid;
}
// The edit field for the password
string newPassword = EditorGUILayout.PasswordField("\tPassword", Password);
if (newPassword != Password)
{
Password = newPassword;
_CurrentState = ConfigurationState.ServerValid;
}
EditorGUILayout.EndVertical();
// And the button to verify it
bool passwordValid = _CurrentState >= ConfigurationState.UsernamePassValid;
EditorGUI.BeginDisabledGroup(passwordValid);
{
if (GUILayout.Button(passwordValid ? "Valid!" : "Verify", EditorStyles.miniButton, _ButtonWidth))
{
checkSettings = true;
_SettingsChanged = true;
}
}
EditorGUI.EndDisabledGroup();
}
EditorGUILayout.EndHorizontal();
if (_CurrentState == ConfigurationState.UsernamePassInvalid)
{
EditorGUILayout.HelpBox("Invalid Username / Password", MessageType.Error);
}
EditorGUI.BeginDisabledGroup(_CurrentState < ConfigurationState.UsernamePassValid);
{
EditorGUILayout.BeginHorizontal();
{
// The edit field for the workspace
string newWorkspace = EditorGUILayout.TextField("\tWorkspace", Workspace);
if (newWorkspace != Workspace)
{
Workspace = newWorkspace;
_CurrentState = ConfigurationState.UsernamePassValid; // Reset state to re-check the workspace
}
// And the check button
bool workspaceValid = _CurrentState >= ConfigurationState.ProjectRootValid;
EditorGUI.BeginDisabledGroup(workspaceValid);
{
if (GUILayout.Button(workspaceValid ? "Valid!" : "Verify", EditorStyles.miniButton, _ButtonWidth))
{
checkSettings = true;
_SettingsChanged = true;
}
}
EditorGUI.EndDisabledGroup();
}
EditorGUILayout.EndHorizontal();
if (_CurrentState == ConfigurationState.WorkspaceInvalid)
{
EditorGUILayout.HelpBox("Invalid Workspace", MessageType.Error);
}
if (_CurrentState == ConfigurationState.ProjectRootInvalid)
{
// The project isn't under the workspace root
string perforcePath = "//" + Workspace + "/...";
string rootPath = P4Connect.Main.RootPath;
EditorGUILayout.HelpBox("Invalid Workspace. The client path:\n" +
"\t" + perforcePath + "\n" +
"maps to this folder:\n" +
"\t" + VerifySettings.LastWorkspaceMapping + "\n" +
"which is not a parent directory of the project's root:\n" +
"\t" + rootPath, MessageType.Error);
}
}
EditorGUI.EndDisabledGroup();
}
EditorGUI.EndDisabledGroup();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tEnable P4Config", GUILayout.Width(textWidth));
bool newUseP4Config = EditorGUILayout.Toggle(UseP4Config, GUILayout.Width(checkWidth));
if (newUseP4Config != UseP4Config)
{
UseP4Config = newUseP4Config;
if (!UseP4Config)
p4configFile = null;
_CurrentState = ConfigurationState.MetaFilesValid;
_SettingsChanged = true;
}
GUILayout.Label("\tName of P4Config File", GUILayout.Width(secondtextWidth));
string newP4ConfigName = EditorGUILayout.TextField(P4ConfigName, GUILayout.Width(120.0f));
if (newP4ConfigName != P4ConfigName)
{
P4ConfigName = newP4ConfigName;
UseP4Config = false;
p4configFile = null;
}
EditorGUILayout.EndHorizontal();
if (UseP4Config)
{
if (p4configFile == null && prevP4ConfigName != P4ConfigName)
{
prevP4ConfigName = P4ConfigName;
p4configFile = FindP4ConfigFile(P4ConfigName);
if (p4configFile != null)
LoadP4ConfigFile(p4configFile);
}
EditorGUILayout.BeginHorizontal();
if (string.IsNullOrEmpty(p4configFile))
{
GUILayout.Label("\t P4 Config file Not Found");
}
else
{
GUILayout.Label("\t Found at: " + Path.GetFullPath(p4configFile)); // Show the path to the config file
}
EditorGUILayout.EndHorizontal();
}
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tEnable P4Ignore", GUILayout.Width(textWidth));
bool newUseIgnore = EditorGUILayout.Toggle(UseIgnore, GUILayout.Width(checkWidth));
if (newUseIgnore != UseIgnore)
{
UseIgnore = newUseIgnore;
_CurrentState = ConfigurationState.MetaFilesValid;
_SettingsChanged = true;
}
GUILayout.Label("\tP4Ignore File", GUILayout.Width(secondtextWidth));
string newIgnoreName = EditorGUILayout.TextField(IgnoreName, GUILayout.Width(300.0f));
if (newIgnoreName != IgnoreName)
{
IgnoreName = newIgnoreName;
UseIgnore = false;
}
if (GUILayout.Button("Browse...", EditorStyles.miniButton, GUILayout.Width(80.0f)))
{
GUI.FocusControl("");
IgnoreName = EditorUtility.OpenFilePanel("Choose P4Ignore File", Utils.GetProjectDirectory(),"");
UseIgnore = true;
}
EditorGUILayout.EndHorizontal();
GUILayout.Label("Interface", EditorStyles.boldLabel);
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tDisplay Status Icons", GUILayout.Width(textWidth));
bool newDisplayIcons = EditorGUILayout.Toggle(DisplayStatusIcons, GUILayout.Width(checkWidth));
if (newDisplayIcons != DisplayStatusIcons)
{
DisplayStatusIcons = newDisplayIcons;
_SettingsChanged = true;
Icons.UpdateDisplay();
PendingChanges.UpdateDisplay();
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tShow File Paths in Console", GUILayout.Width(textWidth));
bool newShowPaths = EditorGUILayout.Toggle(ShowPaths, GUILayout.Width(checkWidth));
if (newShowPaths != ShowPaths)
{
ShowPaths = newShowPaths;
_SettingsChanged = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tDiff Tool Executable", GUILayout.Width(textWidth));
string newDiffToolPathname = EditorGUILayout.TextField("", DiffToolPathname);
if (newDiffToolPathname != DiffToolPathname)
{
DiffToolPathname = newDiffToolPathname;
_SettingsChanged = true;
}
if (GUILayout.Button("Browse...", EditorStyles.miniButton, GUILayout.Width(80.0f)))
{
GUI.FocusControl("");
DiffToolPathname = EditorUtility.OpenFilePanel("Choose Diff Tool Executable", System.Environment.GetFolderPath(System.Environment.SpecialFolder.ProgramFiles), "");
_SettingsChanged = true;
}
EditorGUILayout.EndHorizontal();
GUILayout.Label("Behaviour", EditorStyles.boldLabel);
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tAsk before checkout on edit", GUILayout.Width(textWidth));
bool newAskBeforeCheckout = EditorGUILayout.Toggle(AskBeforeCheckout, GUILayout.Width(checkWidth));
if (newAskBeforeCheckout != AskBeforeCheckout)
{
AskBeforeCheckout = newAskBeforeCheckout;
_SettingsChanged = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tShow warning when adding files with reserved characters (@#*%)", GUILayout.Width(textWidth));
bool newWarnOnSpecialChar = EditorGUILayout.Toggle(WarnOnSpecialCharacters, GUILayout.Width(checkWidth));
if (newWarnOnSpecialChar != WarnOnSpecialCharacters)
{
WarnOnSpecialCharacters = newWarnOnSpecialChar;
_SettingsChanged = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tInclude Solution Files", GUILayout.Width(textWidth));
bool newIncludeSolutionFiles = EditorGUILayout.Toggle(IncludeSolutionFiles, GUILayout.Width(checkWidth));
if (newIncludeSolutionFiles != IncludeSolutionFiles)
{
IncludeSolutionFiles = newIncludeSolutionFiles;
_SettingsChanged = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tInclude Projects Files", GUILayout.Width(textWidth));
bool newIncludeProjectFiles = EditorGUILayout.Toggle(IncludeProjectFiles, GUILayout.Width(checkWidth));
if (newIncludeProjectFiles != IncludeProjectFiles)
{
IncludeProjectFiles = newIncludeProjectFiles;
_SettingsChanged = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tIntegrate with UnityVS", GUILayout.Width(textWidth));
bool newUnityVSSupport = EditorGUILayout.Toggle(UnityVSSupport, GUILayout.Width(checkWidth));
if (newUnityVSSupport != UnityVSSupport)
{
UnityVSSupport = newUnityVSSupport;
_SettingsChanged = true;
}
EditorGUILayout.EndHorizontal();
GUILayout.Label("Advanced", EditorStyles.boldLabel);
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tOverride P4HOST variable", GUILayout.Width(textWidth));
bool newOverrideP4Host = EditorGUILayout.Toggle(OverrideHostname, GUILayout.Width(checkWidth));
if (newOverrideP4Host != OverrideHostname)
{
OverrideHostname = newOverrideP4Host;
_CurrentState = ConfigurationState.MetaFilesValid;
_SettingsChanged = true;
}
//EditorGUI.BeginDisabledGroup(!OverrideHostname);
GUILayout.Label("\tHostname", GUILayout.Width(secondtextWidth));
string newHost = EditorGUILayout.TextField(Hostname, GUILayout.Width(120.0f));
if (newHost != Hostname)
{
Hostname = newHost;
_CurrentState = ConfigurationState.MetaFilesValid;
OverrideHostname = false;
}
//EditorGUI.EndDisabledGroup();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tOverride P4CHARSET variable", GUILayout.Width(textWidth));
bool newOverrideCharset = EditorGUILayout.Toggle(OverrideCharset, GUILayout.Width(checkWidth));
if (newOverrideCharset != OverrideCharset)
{
OverrideCharset = newOverrideCharset;
_CurrentState = ConfigurationState.ServerValid;
_SettingsChanged = true;
}
//EditorGUI.BeginDisabledGroup(!OverrideCharset);
GUILayout.Label("\tCharset", GUILayout.Width(secondtextWidth));
string newCharset = EditorGUILayout.TextField(Charset, GUILayout.Width(120.0f));
if (newCharset != Charset)
{
Charset = newCharset;
_CurrentState = ConfigurationState.ServerValid;
OverrideCharset = false;
}
//EditorGUI.EndDisabledGroup();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tGray out invalid menu options", GUILayout.Width(textWidth));
bool newCheckStatus = EditorGUILayout.Toggle(CheckStatusForMenus, GUILayout.Width(checkWidth));
if (newCheckStatus != CheckStatusForMenus)
{
CheckStatusForMenus = newCheckStatus;
_SettingsChanged = true;
}
EditorGUI.BeginDisabledGroup(!CheckStatusForMenus);
GUILayout.Label("Don't check if more than", GUILayout.Width(secondtextWidth));
int newCheckStatusCount = EditorGUILayout.IntField(CheckStatusForMenusMaxItems, GUILayout.Width(intWidth));
if (newCheckStatusCount != CheckStatusForMenusMaxItems)
{
CheckStatusForMenusMaxItems = newCheckStatusCount;
_SettingsChanged = true;
}
GUILayout.Label("files selected");
GUILayout.FlexibleSpace();
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tClose Perforce connection after", GUILayout.Width(textWidth));
int newTimeOut = EditorGUILayout.IntField(ConnectionTimeOut, GUILayout.Width(intWidth));
if (newTimeOut != ConnectionTimeOut)
{
ConnectionTimeOut = newTimeOut;
_SettingsChanged = true;
}
GUILayout.Label("seconds");
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tDisplay P4 Timings", GUILayout.Width(textWidth));
bool newDisplayTimings = EditorGUILayout.Toggle(DisplayP4Timings, GUILayout.Width(checkWidth));
if (newDisplayTimings != DisplayP4Timings)
{
DisplayP4Timings = newDisplayTimings;
_SettingsChanged = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tEnable Logging", GUILayout.Width(textWidth));
bool newEnableLog = EditorGUILayout.Toggle(EnableLog, GUILayout.Width(checkWidth));
if (newEnableLog != EnableLog)
{
EnableLog = newEnableLog;
if (EnableLog)
Main.InitializeLogging();
_SettingsChanged = true;
}
GUILayout.Label("\tLog File", GUILayout.Width(secondtextWidth));
string newLogPath = EditorGUILayout.TextField(LogPath);
if (newLogPath != LogPath)
{
LogPath = newLogPath;
EnableLog = false;
}
if (GUILayout.Button("Browse...", EditorStyles.miniButton, GUILayout.Width(80.0f)))
{
GUI.FocusControl("");
LogPath = EditorUtility.SaveFilePanel("Save P4Connect Log",
System.Environment.GetFolderPath(System.Environment.SpecialFolder.DesktopDirectory), "p4connect","log");
if (String.IsNullOrEmpty(LogPath))
EnableLog = false;
else
EnableLog = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tUse Configuration Asset", GUILayout.Width(textWidth));
bool newSaveConfigAsset = EditorGUILayout.Toggle(SaveConfigAsset, GUILayout.Width(checkWidth));
if (newSaveConfigAsset != SaveConfigAsset)
{
SaveConfigAsset = newSaveConfigAsset;
_SettingsChanged = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
GUILayout.Label("\tAdditional Ignore Lines", GUILayout.Width(textWidth));
scroll = EditorGUILayout.BeginScrollView(scroll, GUILayout.Width(pathWidth + 10.0f), GUILayout.MaxHeight(50.0f));
string newIgnoreLines = EditorGUILayout.TextArea(IgnoreLines, GUILayout.MinHeight(16.0f), GUILayout.Width(pathWidth));
if (newIgnoreLines != IgnoreLines)
{
IgnoreLines = newIgnoreLines;
_SettingsChanged = true;
}
EditorGUILayout.EndScrollView();
EditorGUILayout.EndHorizontal();
}
else
{
EditorGUILayout.HelpBox("You must set the Editor Version Control to \"Meta Files\" under Edit->Project Settings->Editor", MessageType.Info);
if (VerifySettings.CheckMetaFiles())
{
_SettingsChanged = true;
checkSettings = true;
}
}
}
if (checkSettings)
{
ConfigurationState prevState = _CurrentState;
_CurrentState = ConfigurationState.Unknown;
// Check the config
CheckSettings();
// And notify user
if (_CurrentState != prevState)
{
Icons.UpdateDisplay();
PendingChanges.UpdateDisplay();
}
}
}
EditorGUILayout.EndToggleGroup();
// Info message
GUILayout.FlexibleSpace();
if (PerforceEnabled && _CurrentState != ConfigurationState.SettingsValid)
{
EditorGUILayout.HelpBox("Perforce Integration is inactive. Please Verify your Settings!", MessageType.Warning);
}
else if (_SettingsChanged)
{
if (PerforceEnabled)
{
EditorGUILayout.HelpBox("Perforce Integration is active.", MessageType.Info);
}
else
{
EditorGUILayout.HelpBox("Perforce Integration is turned off.", MessageType.Info);
}
if (Config.SaveConfigAsset )
{
writeConfigAsset(); // This will update the config asset!
}
else
{
WritePrefs();
}
_SettingsChanged = false;
//Debug.Log("_CurrentState now: " + _CurrentState.ToString());
}
EditorGUILayout.BeginHorizontal();
GUILayout.Label("Project: " + Utils.GetProjectDirectory());
GUILayout.FlexibleSpace();
GUILayout.Label("P4Connect " + Version.p4ConnectVersion + " " + Version.build, EditorStyles.miniLabel);
if (GUILayout.Button("Visit Website", EditorStyles.miniButton))
{
System.Diagnostics.Process.Start("http://www.perforce.com/perforce/doc.current/manuals/p4connectguide/index.html");
}
EditorGUILayout.EndHorizontal();
}
void OnSelectionChange()
{
// UnityEngine.Object cursel = Selection.activeObject;
// if (cursel == )
}
void OnInspectorUpdate()
{
if (_Repaint)
{
_Repaint = false;
Repaint();
}
}
// Check for the "well known" Perforce environment variables, use them for the default configuration.
public static void ReadEnvironment()
{
//Debug.Log("ReadEnvironment()");
string value;
value = Environment.GetEnvironmentVariable("P4CONFIG");
if (value != null)
Config.P4ConfigName = value;
value = Environment.GetEnvironmentVariable("P4PORT");
if (value != null)
Config.ServerURI = value;
value = Environment.GetEnvironmentVariable("P4USER");
if (value != null)
Config.Username = value;
value = Environment.GetEnvironmentVariable("P4PASSWD");
if (value != null)
Config.Password = value;
value = Environment.GetEnvironmentVariable("P4CLIENT");
if (value != null)
Config.Workspace = value;
value = Environment.GetEnvironmentVariable("P4HOST");
if (value != null)
Config.Hostname = value;
value = Environment.GetEnvironmentVariable("P4IGNORE");
if (value != null)
Config.IgnoreName = value;
}
#region EditorPreferences
// Utility method to read connection prefs from the registry
public static void ReadPrefs()
{
//Debug.Log("ReadPrefs()");
// Check if the keys exist, and if so, read the values out
// Otherwise, leave the existing values
if (HasStringPrefNotEmpty(ServerURIPrefName))
ServerURI = GetPrefString(ServerURIPrefName);
if (HasStringPrefNotEmpty(UserNamePrefName))
Username = GetPrefString(UserNamePrefName);
if (HasStringPrefNotEmpty(PasswordPrefName))
Password = Secure.DecryptString(GetPrefString(PasswordPrefName));
if (HasStringPrefNotEmpty(WorkspacePrefName))
Workspace = GetPrefString(WorkspacePrefName);
if (HasPref(P4ConfigPrefName))
UseP4Config = GetPrefBool(P4ConfigPrefName);
if (HasPref(UnityVSSupportPrefName))
UnityVSSupport = GetPrefBool(UnityVSSupportPrefName);
if (HasPref(IncludeProjectFilesPrefName))
IncludeProjectFiles = GetPrefBool(IncludeProjectFilesPrefName);
if (HasPref(IncludeSolutionFilesPrefName))
IncludeSolutionFiles = GetPrefBool(IncludeSolutionFilesPrefName);
if (HasPref(ShowPathsPrefName))
ShowPaths = GetPrefBool(ShowPathsPrefName);
if (HasPref(AskBeforeCheckoutPrefName))
AskBeforeCheckout = GetPrefBool(AskBeforeCheckoutPrefName);
if (HasPref(DisplayStatusIconsPrefName))
DisplayStatusIcons = GetPrefBool(DisplayStatusIconsPrefName);
if (HasStringPrefNotEmpty(HostnamePrefName))
Hostname = GetPrefString(HostnamePrefName);
if (HasStringPrefNotEmpty(DiffToolPathnamePrefName))
DiffToolPathname = GetPrefString(DiffToolPathnamePrefName);
if (HasPref(DisplayP4TimingsPrefName))
DisplayP4Timings = GetPrefBool(DisplayP4TimingsPrefName);
if (HasPref(DisplayP4CommandsPrefName))
DisplayP4Commands = GetPrefBool(DisplayP4CommandsPrefName);
if (HasPref(CheckStatusForMenusPrefName))
CheckStatusForMenus = GetPrefBool(CheckStatusForMenusPrefName);
if (HasPref(CheckStatusForMenusMaxItemsPrefName))
CheckStatusForMenusMaxItems = GetPrefInt(CheckStatusForMenusMaxItemsPrefName);
if (HasPref(OperationBatchCountPrefName))
OperationBatchCount = GetPrefInt(OperationBatchCountPrefName);
if (HasPref(ConnectionTimeOutPrefName))
ConnectionTimeOut = GetPrefInt(ConnectionTimeOutPrefName);
if (HasPref(OverrideHostnamePrefName))
OverrideHostname = GetPrefBool(OverrideHostnamePrefName);
if (HasPref(WarnOnSpecialCharactersPrefName))
WarnOnSpecialCharacters = GetPrefBool(WarnOnSpecialCharactersPrefName);
if (HasPref(UseIgnorePrefName))
UseIgnore = GetPrefBool(UseIgnorePrefName);
if (HasStringPrefNotEmpty(IgnoreNamePrefName))
IgnoreName = GetPrefString(IgnoreNamePrefName);
if (HasPref(EnableLogPrefName))
EnableLog = GetPrefBool(EnableLogPrefName);
if (HasStringPrefNotEmpty(P4ConfigNamePrefName))
P4ConfigName = GetPrefString(P4ConfigNamePrefName);
if (HasStringPrefNotEmpty(IgnoreLinesPrefName))
IgnoreLines = GetPrefString(IgnoreLinesPrefName);
// Notify users that prefs changed
if (PrefsChanged != null)
PrefsChanged();
}
// Utility method to write our the connection prefs to the registry
public static void WritePrefs()
{
SetPrefString(ServerURIPrefName, ServerURI);
SetPrefString(UserNamePrefName, Username);
// if (! String.IsNullOrEmpty(Password))
// SetPrefString(PasswordPrefName, Secure.EncryptString(Password));
System.Console.WriteLine("After EncryptString");
SetPrefString(WorkspacePrefName, Workspace);
SetPrefBool(P4ConfigPrefName, UseP4Config);
SetPrefBool(UnityVSSupportPrefName, UnityVSSupport);
SetPrefBool(IncludeProjectFilesPrefName, IncludeProjectFiles);
SetPrefBool(IncludeSolutionFilesPrefName, IncludeSolutionFiles);
SetPrefBool(ShowPathsPrefName, ShowPaths);
SetPrefBool(AskBeforeCheckoutPrefName, AskBeforeCheckout);
SetPrefBool(DisplayStatusIconsPrefName, DisplayStatusIcons);
SetPrefString(HostnamePrefName, Hostname);
SetPrefString(DiffToolPathnamePrefName, DiffToolPathname);
SetPrefBool(DisplayP4TimingsPrefName, DisplayP4Timings);
SetPrefBool(DisplayP4CommandsPrefName, DisplayP4Commands);
SetPrefBool(CheckStatusForMenusPrefName, CheckStatusForMenus);
SetPrefInt(CheckStatusForMenusMaxItemsPrefName, CheckStatusForMenusMaxItems);
SetPrefInt(OperationBatchCountPrefName, OperationBatchCount);
SetPrefInt(ConnectionTimeOutPrefName, ConnectionTimeOut);
SetPrefBool(OverrideHostnamePrefName, OverrideHostname);
SetPrefBool(WarnOnSpecialCharactersPrefName, WarnOnSpecialCharacters);
SetPrefBool(UseIgnorePrefName, UseIgnore);
SetPrefString(IgnoreNamePrefName,IgnoreName);
SetPrefBool(EnableLogPrefName,EnableLog);
SetPrefString(LogPathPrefName,LogPath);
SetPrefString(P4ConfigNamePrefName, P4ConfigName);
SetPrefString(IgnoreLinesPrefName, IgnoreLines);
//System.Console.WriteLine("done writing prefs");
}
static string GetFullPrefName(string aPrefName)
{
// System.Console.WriteLine("P4Connect_" + Main.ProjectName + "_" + aPrefName);
return "P4Connect_" + Main.ProjectName + "_" + aPrefName;
}
static bool HasPref(string aPrefName)
{
return EditorPrefs.HasKey(GetFullPrefName(aPrefName));
}
static bool HasStringPrefNotEmpty(string aPrefName)
{
return (! String.IsNullOrEmpty(EditorPrefs.GetString(GetFullPrefName(aPrefName))));
}
static void SetPrefString(string aPrefName, string aPref)
{
EditorPrefs.SetString(GetFullPrefName(aPrefName), aPref);
}
static void SetPrefInt(string aPrefName, int aPref)
{
EditorPrefs.SetInt(GetFullPrefName(aPrefName), aPref);
}
static void SetPrefBool(string aPrefName, bool aPref)
{
EditorPrefs.SetBool(GetFullPrefName(aPrefName), aPref);
}
static string GetPrefString(string aPrefName)
{
return EditorPrefs.GetString(GetFullPrefName(aPrefName));
}
static int GetPrefInt(string aPrefName)
{
return EditorPrefs.GetInt(GetFullPrefName(aPrefName));
}
static bool GetPrefBool(string aPrefName)
{
return EditorPrefs.GetBool(GetFullPrefName(aPrefName));
}
// [MenuItem("Edit/Delete Project EditorPrefs", false, 300)]
static void DeleteAllEditorPrefs()
{
Debug.Log("DeletePrefs()");
// Delete All keys for this project
EditorPrefs.DeleteKey(ServerURIPrefName);
EditorPrefs.DeleteKey(UserNamePrefName);
EditorPrefs.DeleteKey(PasswordPrefName);
EditorPrefs.DeleteKey(WorkspacePrefName);
EditorPrefs.DeleteKey(P4ConfigPrefName);
EditorPrefs.DeleteKey(UnityVSSupportPrefName);
EditorPrefs.DeleteKey(IncludeProjectFilesPrefName);
EditorPrefs.DeleteKey(IncludeSolutionFilesPrefName);
EditorPrefs.DeleteKey(ShowPathsPrefName);
EditorPrefs.DeleteKey(AskBeforeCheckoutPrefName);
EditorPrefs.DeleteKey(DisplayStatusIconsPrefName);
EditorPrefs.DeleteKey(HostnamePrefName);
EditorPrefs.DeleteKey(DiffToolPathnamePrefName);
EditorPrefs.DeleteKey(DisplayP4TimingsPrefName);
EditorPrefs.DeleteKey(DisplayP4CommandsPrefName);
EditorPrefs.DeleteKey(CheckStatusForMenusPrefName);
EditorPrefs.DeleteKey(CheckStatusForMenusMaxItemsPrefName);
EditorPrefs.DeleteKey(OperationBatchCountPrefName);
EditorPrefs.DeleteKey(ConnectionTimeOutPrefName);
EditorPrefs.DeleteKey(OverrideHostnamePrefName);
EditorPrefs.DeleteKey(WarnOnSpecialCharactersPrefName);
EditorPrefs.DeleteKey(UseIgnorePrefName);
EditorPrefs.DeleteKey(IgnoreNamePrefName);
EditorPrefs.DeleteKey(EnableLogPrefName);
EditorPrefs.DeleteKey(P4ConfigNamePrefName);
EditorPrefs.DeleteKey(IgnoreLinesPrefName);
}
#endregion
public static SerializationMode CachedSerializationMode
{
get;
private set;
}
#region P4CONFIG
public static string FindP4ConfigFile(string config)
{
string directoryName;
if (! String.IsNullOrEmpty(config))
{
string path = Application.dataPath;
while (path != null)
{
directoryName = Path.GetDirectoryName(path);
if (!String.IsNullOrEmpty(directoryName))
{
string[] files = System.IO.Directory.GetFiles(directoryName, config);
if (files.Count() > 0)
{
return files[0];
}
}
path = directoryName;
}
}
return null;
}
public static void LoadP4ConfigFile(string path)
{
string line;
char[] equalsChars = { '=' };
System.IO.StreamReader file = new System.IO.StreamReader(path);
while ((line = file.ReadLine()) != null)
{
string[] segments = line.Split(equalsChars);
if (segments.Length >= 2)
{
string key = segments[0];
string val = segments[1];
// Debug.Log("Key: " + key);
// Debug.Log("Value: " + val);
switch (segments[0])
{
case "P4PORT":
{
ServerURI = val;
}
break;
case "P4USER":
{
Username = val;
}
break;
case "P4CLIENT":
{
Workspace = val;
}
break;
case "P4PASSWD":
{
Password = val;
}
break;
}
}
}
file.Close();
}
#endregion
#region ConfigAsset
static string configAssetPath = "Assets/P4Connect/Editor/Config.asset";
public static void writeConfigAsset()
{
ConfigAsset asset = ScriptableObject.CreateInstance();
asset.CopyConfigToAsset();
AssetDatabase.CreateAsset(asset, configAssetPath);
AssetDatabase.SaveAssets();
}
public static bool readConfigAsset()
{
ConfigAsset asset = (ConfigAsset)AssetDatabase.LoadAssetAtPath(configAssetPath, typeof(ConfigAsset));
if (asset != null)
{
asset.CopyAssetToConfig();
return true;
}
else
{
return false;
}
}
[CustomEditor(typeof(ConfigAsset))]
public class ConfigAssetPropertiesEditor : Editor
{
public override void OnInspectorGUI()
{
GUI.enabled = false;
DrawDefaultInspector();
GUI.enabled = true;
}
}
#endregion
}
}