private void Commit() { Signature signature = GitManager.Signature; try { if (!GitExternalManager.TakeCommit(commitMessage)) { GitManager.Repository.Commit(commitMessage, signature, signature, new CommitOptions() { AllowEmptyCommit = settings.emptyCommit, AmendPreviousCommit = settings.amendCommit, PrettifyMessage = settings.prettify }); GitHistoryWindow.GetWindow(true); } GitManager.Update(); } catch (Exception e) { Debug.LogException(e); } finally { GUI.FocusControl(""); commitMessage = string.Empty; } }
internal static void InvalidRepoGUI() { EditorGUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); GUILayout.Box(GitGUI.GetTempContent("Not a GIT Repository"), "NotificationBackground"); GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); EditorGUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); //initialization tips EditorGUILayout.HelpBox("If you have an existing remote repository and want to clone it, you will have to do so outside of the editor.", MessageType.Info); GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); GUILayout.FlexibleSpace(); EditorGUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); if (GUILayout.Button(GitGUI.GetTempContent("Create"), "LargeButton", GUILayout.Height(32), GUILayout.Width(128))) { if (EditorUtility.DisplayDialog("Initialize Repository", "Are you sure you want to initialize a Repository for your project", "Yes", "Cancel")) { GitManager.InitilizeRepository(); GUIUtility.ExitGUI(); return; } } GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); EditorGUILayout.Space(); }
public GitCheckoutWindowPopup(GitManager gitManager, Branch branch, ILogger logger, GitCallbacks gitCallbacks) { this.gitManager = gitManager; this.branch = branch; this.logger = logger; this.gitCallbacks = gitCallbacks; }
protected void OnMergeComplete(MergeResult result, string mergeType) { switch (result.Status) { case MergeStatus.UpToDate: GitHistoryWindow.GetWindow(true).ShowNotification(new GUIContent(string.Format("Everything is Up to date. Nothing to {0}.", mergeType))); break; case MergeStatus.FastForward: GitHistoryWindow.GetWindow(true).ShowNotification(new GUIContent(mergeType + " Complete with Fast Forwarding.")); break; case MergeStatus.NonFastForward: GitDiffWindow.GetWindow(true).ShowNotification(new GUIContent("Do a merge commit in order to push changes.")); GitDiffWindow.GetWindow(false).commitMessage = GitManager.Repository.Info.Message; Debug.Log(mergeType + " Complete without Fast Forwarding."); break; case MergeStatus.Conflicts: GUIContent content = EditorGUIUtility.IconContent("console.warnicon"); content.text = "There are merge conflicts!"; GitDiffWindow.GetWindow(true).ShowNotification(content); GitDiffWindow.GetWindow(false).commitMessage = GitManager.Repository.Info.Message; break; } GitManager.Update(); Debug.LogFormat("{0} Status: {1}", mergeType, result.Status); }
private void DoDiffStatusContex(FileStatus fileStatus, GenericMenu menu) { menu.AddItem(new GUIContent("Select All"), false, SelectFilteredCallback, fileStatus); if (GitManager.CanStage(fileStatus)) { menu.AddItem(new GUIContent("Add All"), false, () => { GitManager.Repository.Stage(statusList.Where(s => s.State.IsFlagSet(fileStatus)).SelectMany(s => GitManager.GetPathWithMeta(s.Path))); GitManager.Update(); }); } else { menu.AddDisabledItem(new GUIContent("Add All")); } if (GitManager.CanUnstage(fileStatus)) { menu.AddItem(new GUIContent("Remove All"), false, () => { GitManager.Repository.Unstage(statusList.Where(s => s.State.IsFlagSet(fileStatus)).SelectMany(s => GitManager.GetPathWithMeta(s.Path))); GitManager.Update(); }); } else { menu.AddDisabledItem(new GUIContent("Remove All")); } }
public GitDiffWindowCommitRenderer(GitSettingsJson gitSettings, GitManager gitManager, GitOverlay gitOverlay, GitInitializer initializer) { this.gitSettings = gitSettings; this.gitManager = gitManager; this.gitOverlay = gitOverlay; this.initializer = initializer; }
public override void OnGUI(Rect rect) { EditorGUILayout.Space(); resetMode = (ResetMode)EditorGUILayout.EnumPopup(GitGUI.GetTempContent("Reset Type"), resetMode); switch (resetMode) { case ResetMode.Soft: EditorGUILayout.HelpBox("Leave working tree and index untouched", MessageType.Info); break; case ResetMode.Mixed: EditorGUILayout.HelpBox("Leave working tree untouched,reset index (Default)", MessageType.Info); break; case ResetMode.Hard: EditorGUILayout.HelpBox("Reset working tree and index (Will delete all files)", MessageType.Error); break; } GUILayout.FlexibleSpace(); if (GUILayout.Button("Reset")) { if (EditorUtility.DisplayDialog("Reset", "Are you sure you want to reset to the selected commit", "Reset", "Cancel")) { GitProfilerProxy.BeginSample("Git Reset Popup", editorWindow); GitManager.Repository.Reset(resetMode, commit, checkoutOptions); GitManager.MarkDirty(true); editorWindow.Close(); GitProfilerProxy.EndSample(); AssetDatabase.Refresh(); } } EditorGUILayout.Space(); }
private void Construct(GitManager gitManager, GitOverlay gitOverlay, ILogger logger, GitAnimation gitAnimation) { this.gitManager = gitManager; this.gitOverlay = gitOverlay; this.logger = logger; this.gitAnimation = gitAnimation; }
private void OnWizardCreate() { try { using (var repository = new Repository(GitManager.RepoPath)) { repository.Network.Push(repository.Branches[branchNames[selectedBranch]], pushOptions); GitManager.Update(); var window = GitHistoryWindow.GetWindow(true); window.ShowNotification(new GUIContent("Push Complete")); } } catch (Exception e) { if (e is NonFastForwardException) { GUIContent content = EditorGUIUtility.IconContent("console.warnicon"); content.text = "Could not push changes to remote. Merge changes with remote before pushing."; GetWindow <GitHistoryWindow>().ShowNotification(content); } Debug.LogException(e); } finally { EditorUtility.ClearProgressBar(); } }
private void Construct(GitManager gitManager, GitReflectionHelper reflectionHelper, UniGitData data, ILogger logger, GitSettingsJson gitSettings, GitCallbacks gitCallbacks, GitInitializer initializer, GitSettingsManager settingsManager, UniGitPaths paths, IGitResourceManager resourceManager) { this.resourceManager = resourceManager; this.paths = paths; this.settingsManager = settingsManager; this.logger = logger; this.gitSettings = gitSettings; this.initializer = initializer; if (gitManager == null) { logger.Log(LogType.Error, "Git manager cannot be null."); return; } if (this.gitCallbacks != null) { Unsubscribe(this.gitCallbacks); } this.data = data; this.gitManager = gitManager; this.gitManager.AddWatcher(this); this.reflectionHelper = reflectionHelper; Subscribe(gitCallbacks); }
public GitLfsManager(GitManager gitManager, GitCallbacks gitCallbacks, ILogger logger, GitSettingsJson gitSettings) { this.gitManager = gitManager; this.gitCallbacks = gitCallbacks; this.logger = logger; this.gitSettings = gitSettings; gitCallbacks.UpdateRepository += OnUpdateRepository; gitManager.AddSettingsAffector(this); try { version = GitHelper.RunExeOutput(gitManager.GetCurrentRepoPath(), "git-lfs", "version", null); isInstalled = true; } catch (Exception) { isInstalled = false; return; } UpdateInitilized(); if (Initilized) { RegisterFilter(); Update(); } }
public StatusTreeClass(GitSettingsJson gitSettings, GitManager gitManager, bool cullNonAssetPaths, UniGitPaths paths) { this.paths = paths; this.gitManager = gitManager; this.cullNonAssetPaths = cullNonAssetPaths; this.gitSettings = gitSettings; }
private static void Rebuild(InjectionHelper injectionHelper) { GitCallbacks = injectionHelper.GetInstance <GitCallbacks>(); var settingsManager = injectionHelper.GetInstance <GitSettingsManager>(); settingsManager.LoadGitSettings(); //delayed called must be used for serialized properties to be loaded EditorApplication.delayCall += () => { settingsManager.LoadOldSettingsFile(); }; GitManager = injectionHelper.GetInstance <GitManager>(); injectionHelper.GetInstance <GitReflectionHelper>(); GitSettings = injectionHelper.GetInstance <GitSettingsJson>(); GitCallbacks.OnLogEntry += OnLogEntry; GitCallbacks.OnBeforeAssemblyReload += OnBeforeAssemblyReload; injectionHelper.CreateNonLazy(); injectionHelper.InjectStatic(typeof(GitProjectContextMenus)); injectionHelper.InjectStatic(typeof(GitUnityMenu)); }
private static void Initilize() { if (EditorUtility.DisplayDialog("Initialize Repository", "Are you sure you want to initialize a Repository for your project", "Yes", "Cancel")) { GitManager.InitilizeRepository(); } }
public GitAutoFetcher(GitManager gitManager, GitCredentialsManager credentialsManager, GitCallbacks gitCallbacks) { this.gitManager = gitManager; this.credentialsManager = credentialsManager; this.gitCallbacks = gitCallbacks; gitCallbacks.EditorUpdate += OnEditorUpdate; needsFetch = !EditorApplication.isPlayingOrWillChangePlaymode && !EditorApplication.isCompiling && !EditorApplication.isUpdating; }
internal static void SetCommitMessage(GitInitializer initializer, GitManager gitManager, GitSettingsJson gitSettings, string commitMessage) { if (gitSettings.ReadFromFile) { SaveCommitMessageToFile(initializer, gitSettings, commitMessage); } gitManager.Prefs.SetString(CommitMessageKey, commitMessage); }
private static bool RemoveSelectedValidate() { if (gitManager == null || !initializer.IsValidRepo) { return(false); } return(Selection.assetGUIDs.Select(AssetDatabase.GUIDToAssetPath).Select(p => gitManager.ToLocalPath(p)).SelectMany(gitManager.GetPathWithMeta) .Any(g => GitManager.CanUnstage(gitManager.Repository.RetrieveStatus(g)))); }
private static bool RemoveSelectedValidate() { if (gitManager == null || !gitManager.IsValidRepo) { return(false); } string[] paths = Selection.assetGUIDs.Select(g => string.IsNullOrEmpty(Path.GetExtension(AssetDatabase.GUIDToAssetPath(g))) ? AssetDatabase.GUIDToAssetPath(g) + ".meta" : AssetDatabase.GUIDToAssetPath(g)).SelectMany(GitManager.GetPathWithMeta).ToArray(); return(paths.Any(g => GitManager.CanUnstage(gitManager.Repository.RetrieveStatus(g)))); }
public GitDiffElementContextFactory(GitManager gitManager, GitConflictsHandler conflictsHandler, GitOverlay gitOverlay, GitExternalManager externalManager, GitCallbacks gitCallbacks) { this.gitManager = gitManager; this.conflictsHandler = conflictsHandler; this.gitOverlay = gitOverlay; this.externalManager = externalManager; this.gitCallbacks = gitCallbacks; }
public override void OnGUI(Rect rect) { EditorGUILayout.Space(); float msgHeight = commitMessageStyle.CalcHeight(new GUIContent(commit.Message), rect.width); EditorGUILayout.LabelField(new GUIContent(commit.Message), commitMessageStyle, GUILayout.Height(msgHeight)); scroll = EditorGUILayout.BeginScrollView(scroll); EditorGUILayout.Space(); if (changes != null) { foreach (var change in changes) { //EditorGUILayout.BeginHorizontal(); //GUILayout.Label(change.Status.ToString(), "AssetLabel"); EditorGUILayout.BeginHorizontal("ProjectBrowserHeaderBgTop"); GUILayout.Label(new GUIContent(GitManager.GetDiffTypeIcon(change.Status, true)), GUILayout.Width(16)); GUILayout.Label(new GUIContent("(" + change.Status + ")"), "AboutWIndowLicenseLabel"); GUILayout.Space(8); foreach (var chunk in change.Path.Split('\\')) { GUILayout.Label(new GUIContent(chunk), "GUIEditor.BreadcrumbMid"); } //GUILayout.Label(new GUIContent(" (" + change.Status + ") " + change.Path)); EditorGUILayout.EndHorizontal(); Rect r = GUILayoutUtility.GetLastRect(); if (Event.current.type == EventType.ContextClick) { GenericMenu menu = new GenericMenu(); if (commit.Parents.Count() == 1) { menu.AddItem(new GUIContent("Difference with previous commit"), false, () => { Commit parent = commit.Parents.Single(); GitManager.ShowDiff(change.Path, parent, commit); }); } else { menu.AddDisabledItem(new GUIContent(new GUIContent("Difference with previous commit"))); } menu.AddItem(new GUIContent("Difference with HEAD"), false, () => { GitManager.ShowDiff(change.Path, commit, GitManager.Repository.Head.Tip); }); menu.ShowAsContext(); } //EditorGUILayout.EndHorizontal(); } } else { DrawTreeEntry(commitTree, 0); } EditorGUILayout.Space(); EditorGUILayout.EndScrollView(); }
public GitSubModulesPopup(UniGitData data, GitOverlay gitOverlay, GitManager gitManager) { this.data = data; this.gitOverlay = gitOverlay; this.gitManager = gitManager; moduleStyle = new GUIStyle("ProjectBrowserHeaderBgTop") { wordWrap = true, fixedHeight = 0, alignment = TextAnchor.MiddleLeft }; }
public GitExternalManager(GitManager gitManager, ICollection <IExternalAdapter> adapters) { var injectionHelper = new InjectionHelper(); injectionHelper.Bind <GitManager>().FromInstance(gitManager); injectionHelper.Bind <GitExternalManager>().FromInstance(this); this.gitManager = gitManager; this.adapters = adapters.OrderBy(GetAdapterPriority).ToArray(); adapterNames = adapters.Select(a => new GUIContent(GetAdapterName(a))).ToArray(); }
public GitCreateBranchWindow(Commit commit, [UniGitInjectOptional] Action onCreated, GitManager gitManager, ILogger logger) { this.gitManager = gitManager; this.commit = commit; this.onCreated = onCreated; this.logger = logger; }
private void Build(IEnumerable <GitStatusEntry> status) { foreach (var entry in status) { currentPath = entry.Path; currentPathArray = entry.Path.Split('\\'); currentStatus = !gitSettings.ShowEmptyFolders && GitManager.IsEmptyFolderMeta(currentPath) ? FileStatus.Ignored : entry.Status; AddRecursive(0, entries); } }
private static void Revet() { GitManager.Repository.CheckoutPaths("HEAD", Selection.assetGUIDs.Select(e => AssetDatabase.GUIDToAssetPath(e)).SelectMany(e => GitManager.GetPathWithMeta(e)), new CheckoutOptions() { CheckoutModifiers = CheckoutModifiers.Force, OnCheckoutProgress = OnRevertProgress }); EditorUtility.ClearProgressBar(); GitManager.Update(); AssetDatabase.Refresh(); }
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths) { if (EditorPrefs.GetBool("UniGit_DisablePostprocess")) { return; } if (GitManager.Repository != null) { if (GitManager.Settings != null && GitManager.Settings.AutoStage) { if (importedAssets != null && importedAssets.Length > 0) { string[] importedAssetsToStage = importedAssets.Where(a => !GitManager.IsEmptyFolder(a)).SelectMany(g => GitManager.GetPathWithMeta(g)).Where(g => GitManager.CanStage(GitManager.Repository.RetrieveStatus(g))).ToArray(); if (importedAssetsToStage.Length > 0) { GitManager.Repository.Stage(importedAssetsToStage); GitManager.MarkDirty(importedAssetsToStage); } } if (movedAssets != null && movedAssets.Length > 0) { string[] movedAssetsFinal = movedAssets.Where(a => !GitManager.IsEmptyFolder(a)).SelectMany(g => GitManager.GetPathWithMeta(g)).Where(g => GitManager.CanStage(GitManager.Repository.RetrieveStatus(g))).ToArray(); if (movedAssetsFinal.Length > 0) { GitManager.Repository.Stage(movedAssetsFinal); GitManager.MarkDirty(movedAssetsFinal); } } } //automatic deletion of previously moved asset is necessary even if AutoStage is off if (movedFromAssetPaths != null && movedFromAssetPaths.Length > 0) { string[] movedFromAssetPathsFinal = movedFromAssetPaths.SelectMany(g => GitManager.GetPathWithMeta(g)).Where(g => GitManager.CanUnstage(GitManager.Repository.RetrieveStatus(g))).ToArray(); if (movedFromAssetPathsFinal.Length > 0) { GitManager.Repository.Unstage(movedFromAssetPathsFinal); GitManager.MarkDirty(movedFromAssetPathsFinal); } } //automatic deletion is necessary even if AutoStage is off if (deletedAssets != null && deletedAssets.Length > 0) { string[] deletedAssetsFinal = deletedAssets.SelectMany(g => GitManager.GetPathWithMeta(g)).Where(g => GitManager.CanUnstage(GitManager.Repository.RetrieveStatus(g))).ToArray(); if (deletedAssetsFinal.Length > 0) { GitManager.Repository.Unstage(deletedAssetsFinal); GitManager.MarkDirty(deletedAssetsFinal); } } } }
private void GoToPush() { if (GitExternalManager.TakePush()) { GitManager.MarkDirty(); } else { ScriptableWizard.DisplayWizard <GitPushWizard>("Push", "Push").Init(selectedBranch.LoadBranch()); } }
protected virtual void OnEnable() { titleContent.image = GitManager.GetGitStatusIcon(); EditorApplication.update -= OnEditorUpdateInternal; EditorApplication.update += OnEditorUpdateInternal; GitManager.updateRepository -= OnGitManagerUpdateInternal; GitManager.updateRepository += OnGitManagerUpdateInternal; GitManager.onRepositoryLoad -= OnRepositoryLoad; GitManager.onRepositoryLoad += OnRepositoryLoad; }
private void DoDiffElementContex(GenericMenu editMenu) { StatusListEntry[] entries = statusList.Where(e => e.Selected).ToArray(); FileStatus selectedFlags = entries.Select(e => e.State).CombineFlags(); GUIContent addContent = new GUIContent("Stage"); if (GitManager.CanStage(selectedFlags)) { editMenu.AddItem(addContent, false, AddSelectedCallback); } else { editMenu.AddDisabledItem(addContent); } GUIContent removeContent = new GUIContent("Unstage"); if (GitManager.CanUnstage(selectedFlags)) { editMenu.AddItem(removeContent, false, RemoveSelectedCallback); } else { editMenu.AddDisabledItem(removeContent); } editMenu.AddSeparator(""); if (entries.Length == 1) { string path = entries[0].Path; if (selectedFlags.IsFlagSet(FileStatus.Conflicted)) { if (GitConflictsHandler.CanResolveConflictsWithTool(path)) { editMenu.AddItem(new GUIContent("Resolve Conflicts"), false, ResolveConflictsCallback, path); } else { editMenu.AddDisabledItem(new GUIContent("Resolve Conflicts")); } editMenu.AddItem(new GUIContent("Resolve (Using Ours)"), false, ResolveConflictsOursCallback, entries[0].Path); editMenu.AddItem(new GUIContent("Resolve (Using Theirs)"), false, ResolveConflictsTheirsCallback, entries[0].Path); } else { editMenu.AddItem(new GUIContent("Difference"), false, SeeDifferenceSelectedCallback, entries[0].Path); editMenu.AddItem(new GUIContent("Difference with previous version"), false, SeeDifferencePrevSelectedCallback, entries[0].Path); } } editMenu.AddSeparator(""); editMenu.AddItem(new GUIContent("Revert"), false, RevertSelectedCallback); editMenu.AddSeparator(""); editMenu.AddItem(new GUIContent("Reload"), false, ReloadCallback); }
private void BlameAuto(StatusListEntry entry) { if (entry.MetaChange.IsFlagSet(MetaChangeEnum.Object)) { gitManager.ShowBlameWizard(entry.LocalPath, externalManager); } else { gitManager.ShowBlameWizard(GitManager.MetaPathFromAsset(entry.LocalPath), externalManager); } }