/*

* This file is part of gitg

*

* Copyright (C) 2012 - Jesse van den Kieboom

*

* gitg is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

*

* gitg is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with gitg. If not, see <http://www.gnu.org/licenses/>.

*/

namespace GitgCommit

{

public class Activity : Object, GitgExt.UIElement, GitgExt.Activity

{

// Do this to pull in config.h before glib.h (for gettext...)

private const string version = Gitg.Config.VERSION;

private Paned? d_main;

private bool d_reloading;

private bool d_has_staged;

private ulong d_externally_changed_id;

private bool d_ignore_external_changes;

private Gitg.WhenMapped? d_reload_when_mapped;

private enum UiType

{

DIFF,

SUBMODULE_HISTORY,

SUBMODULE_DIFF

}

private enum IndexType

{

STAGED,

UNSTAGED

}

public GitgExt.Application? application { owned get; construct set; }

public Activity(GitgExt.Application application)

{

Object(application: application);

}

public string id

{

owned get { return "/org/gnome/gitg/Activities/Commit"; }

}

public Gitg.Repository repository

{

set

{

reload();

notify_property("enabled");

}

}

construct

{

application.bind_property("repository", this,

"repository", BindingFlags.DEFAULT);

d_externally_changed_id = application.repository_changed_externally.connect(repository_changed_externally);

}

public bool enabled

{

get

{

return application.repository != null && !application.repository.is_bare;

}

}

public override void dispose()

{

if (d_externally_changed_id != 0)

{

application.disconnect(d_externally_changed_id);

d_externally_changed_id = 0;

}

base.dispose();

}

private void repository_changed_externally(GitgExt.ExternalChangeHint hint)

{

if (!d_ignore_external_changes)

{

if (d_main != null && (hint & GitgExt.ExternalChangeHint.INDEX) != 0)

{

d_reload_when_mapped = new Gitg.WhenMapped(d_main);

d_reload_when_mapped.update(() => {

reload();

}, this);

}

}

d_ignore_external_changes = false;

}

public string display_name

{

owned get { return C_("Activity", "Commit"); }

}

public string description

{

owned get { return _("Create new commits and manage the staging area"); }

}

public string? icon

{

owned get { return "document-save-symbolic"; }

}

public Gtk.Widget? widget

{

owned get

{

if (d_main == null)

{

build_ui();

}

return d_main;

}

}

public bool is_default_for(string action)

{

return action == "commit";

}

public bool on_key_pressed (Gdk.EventKey event) {

var mmask = Gtk.accelerator_get_default_mod_mask();

if ((mmask & event.state) == Gdk.ModifierType.CONTROL_MASK)

{

if ((event.keyval == Gdk.Key.Return || event.keyval == Gdk.Key.KP_Enter))

{

on_commit_clicked ();

return true;

}

}

return false;

}

private delegate void StageUnstageCallback(Sidebar.Item item);

private delegate void StageUnstageSubmoduleCommitCallback(Gitg.Commit commit);

private delegate void UpdateDiffCallback();

private UpdateDiffCallback? d_update_diff_callback;

private bool d_submodule_history_select_first;

private Gitg.StageStatusSubmodule? d_current_submodule;

private Gitg.Repository? d_current_submodule_repository;

private StageUnstageSubmoduleCommitCallback d_stage_unstage_submodule_commit_callback;

private void show_unstaged_diff(Gitg.StageStatusItem[] items)

{

if (items.length == 1 && items[0] is Gitg.StageStatusSubmodule)

{

show_submodule_history((Gitg.StageStatusSubmodule)items[0], IndexType.UNSTAGED);

}

else

{

show_ui(UiType.DIFF);

show_unstaged_diff_intern(application.repository, d_main.diff_view, items, true);

}

}

private void set_unstaged_diff_update_callback(Gitg.Repository repository,

Gitg.DiffView view,

owned Gitg.StageStatusItem[]? items,

bool patchable)

{

d_update_diff_callback = () => {

show_unstaged_diff_intern(repository, view, items, patchable);

};

}

private void show_unstaged_diff_intern(Gitg.Repository repository,

Gitg.DiffView view,

Gitg.StageStatusItem[]? items,

bool patchable)

{

var stage = repository.stage;

stage.diff_workdir_all.begin(items, view.options, (obj, res) => {

try

{

var d = stage.diff_workdir_all.end(res);

view.unstaged = patchable;

view.staged = false;

d_main.button_stage.label = _("_Stage selection");

d_main.button_stage.visible = patchable;

d_main.button_discard.visible = true;

view.new_is_workdir = true;

view.diff = d;

}

catch

{

// TODO: show error in diff

view.diff = null;

}

});

set_unstaged_diff_update_callback(repository, view, items, patchable);

}

private void stage_submodule_at(Gitg.Commit commit)

{

stage_submodule.begin(d_current_submodule, commit, (obj, res) => {

stage_submodule.end(res);

d_ignore_external_changes = true;

reload();

});

}

private async bool stage_submodule(Gitg.StageStatusSubmodule sub, Gitg.Commit? commit)

{

var stage = application.repository.stage;

if ((sub.flags & Ggit.SubmoduleStatus.WD_DELETED) != 0)

{

try

{

yield stage.delete_path(sub.path);

}

catch (Error e)

{

var msg = _("Failed to stage the removal of submodule “%s”").printf(sub.path);

application.show_infobar(msg, e.message, Gtk.MessageType.ERROR);

return false;

}

}

else

{

Gitg.Repository repo;

try

{

repo = sub.submodule.open() as Gitg.Repository;

}

catch (Error e)

{

var msg = _("Failed to open the repository of submodule “%s” while trying to stage").printf(sub.path);

application.show_infobar(msg, e.message, Gtk.MessageType.ERROR);

return false;

}

Ggit.Commit sub_commit = commit;

if (sub_commit == null)

{

try

{

sub_commit = repo.lookup<Gitg.Commit>(sub.submodule.get_workdir_id());

}

catch (Error e)

{

var msg = _("Failed to lookup the working directory commit of submodule “%s” while trying to stage").printf(sub.path);

application.show_infobar(msg, e.message, Gtk.MessageType.ERROR);

return false;

}

}

try

{

yield stage.stage_commit(sub.path, sub_commit);

}

catch (Error e)

{

var msg = _("Failed to stage the submodule “%s”").printf(sub.path);

application.show_infobar(msg, e.message, Gtk.MessageType.ERROR);

return false;

}

}

return true;

}

private async bool stage_file(Gitg.StageStatusFile file)

{

var stage = application.repository.stage;

if ((file.flags & Ggit.StatusFlags.WORKING_TREE_DELETED) != 0)

{

try

{

yield stage.delete_path(file.path);

}

catch (Error e)

{

var msg = _("Failed to stage the removal of file “%s”").printf(file.path);

application.show_infobar(msg, e.message, Gtk.MessageType.ERROR);

return false;

}

}

else

{

try

{

yield stage.stage_path(file.path);

}

catch (Error e)

{

var msg = _("Failed to stage the file “%s”").printf(file.path);

application.show_infobar(msg, e.message, Gtk.MessageType.ERROR);

return false;

}

}

return true;

}

private async void stage_items(owned Gitg.StageStatusItem[] items)

{

foreach (var item in items)

{

var ok = true;

if (item is Gitg.StageStatusFile)

{

d_ignore_external_changes = true;

ok = yield stage_file((Gitg.StageStatusFile)item);

}

else if (item is Gitg.StageStatusSubmodule)

{

d_ignore_external_changes = true;

ok = yield stage_submodule((Gitg.StageStatusSubmodule)item, null);

}

else

{

assert_not_reached();

}

if (!ok)

{

break;

}

}

reload();

}

private void show_ui(UiType type)

{

d_main.submodule_history_view.set_visible(type == UiType.SUBMODULE_HISTORY);

d_main.submodule_diff_view.set_visible(type == UiType.SUBMODULE_DIFF);

d_main.diff_view.set_visible(type == UiType.DIFF);

if (type != UiType.DIFF)

{

d_main.diff_view.diff = null;

}

if (type != UiType.SUBMODULE_DIFF)

{

var view = d_main.submodule_diff_view;

view.info.submodule = null;

view.diff_view_staged.diff = null;

view.diff_view_unstaged.diff = null;

}

if (type != UiType.SUBMODULE_HISTORY)

{

var view = d_main.submodule_history_view;

var model = ((Gitg.CommitModel)view.commit_list_view.model);

if (model != null)

{

model.repository = null;

}

view.diff_view.diff = null;

d_current_submodule = null;

d_current_submodule_repository = null;

}

}

private void on_unstaged_activated(Gitg.StageStatusItem[] items)

{

stage_items.begin(items, (obj, res) => {

stage_items.end(res);

});

}

private void show_submodule_diff(Gitg.StageStatusSubmodule sub)

{

show_ui(UiType.SUBMODULE_DIFF);

var view = d_main.submodule_diff_view;

view.info.submodule = sub.submodule;

Gitg.Repository repo;

try

{

repo = sub.submodule.open() as Gitg.Repository;

}

catch (Error e)

{

view.diff_view_staged.diff = null;

view.diff_view_unstaged.diff = null;

return;

}

show_staged_diff_intern(repo, view.diff_view_staged, null, false);

show_unstaged_diff_intern(repo, view.diff_view_unstaged, null, false);

}

private void submodule_history_selection_changed(Gitg.Commit? commit)

{

var view = d_main.submodule_history_view;

if (commit == null)

{

view.diff_view.diff = null;

return;

}

if (d_current_submodule_repository == null)

{

return;

}

var repo = d_current_submodule_repository;

var commit_tree = commit.get_tree();

var head = d_current_submodule.submodule.get_head_id();

Ggit.Tree? head_tree = null;

if (head != null)

{

Ggit.Commit head_commit;

try

{

head_commit = repo.lookup<Gitg.Commit>(head);

}

catch (Error e)

{

// TODO: show error to user

stderr.printf("Failed to get head commit: %s\n", e.message);

return;

}

head_tree = head_commit.get_tree();

}

Ggit.Diff diff;

try

{

diff = new Ggit.Diff.tree_to_tree(repo, head_tree, commit_tree, view.diff_view.options);

}

catch (Error e)

{

// TODO: show error to user

stderr.printf("Failed to get diff: %s\n", e.message);

return;

}

view.diff_view.new_is_workdir = false;

view.diff_view.diff = diff;

view.diff_view.commit = commit;

}

private void show_submodule_history(Gitg.StageStatusSubmodule sub,

IndexType type)

{

show_ui(UiType.SUBMODULE_HISTORY);

d_current_submodule = null;

d_current_submodule_repository = null;

Gitg.Repository repo;

var submodule = sub.submodule;

try

{

repo = submodule.open() as Gitg.Repository;

}

catch (Error e)

{

// TODO: show to user

stderr.printf("Failed to open submodule repository: %s\n", e.message);

return;

}

d_current_submodule = sub;

d_current_submodule_repository = repo;

var view = d_main.submodule_history_view;

var model = (Gitg.CommitModel)view.commit_list_view.model;

if (model == null)

{

model = new Gitg.CommitModel(repo);

view.commit_list_view.model = model;

}

else

{

model.repository = repo;

}

if (type == IndexType.STAGED)

{

model.set_include(new Ggit.OId[] { submodule.get_index_id() });

var head_id = submodule.get_head_id();

if (head_id != null)

{

model.set_exclude(new Ggit.OId[] { head_id });

}

else

{

model.set_exclude(new Ggit.OId[0]);

}

d_stage_unstage_submodule_commit_callback = (commit) => {

unstage_submodule_at(commit);

};

}

else

{

var index_id = submodule.get_index_id();

model.set_include(new Ggit.OId[] { submodule.get_workdir_id() });

if (index_id != null)

{

model.set_exclude(new Ggit.OId[] { index_id });

}

else

{

model.set_exclude(new Ggit.OId[0]);

}

d_stage_unstage_submodule_commit_callback = (commit) => {

stage_submodule_at(commit);

};

}

d_submodule_history_select_first = true;

model.reload();

}

private void set_staged_diff_update_callback(Gitg.Repository repository,

Gitg.DiffView view,

owned Gitg.StageStatusItem[]? items,

bool patchable)

{

d_update_diff_callback = () => {

show_staged_diff_intern(repository, view, items, patchable);

};

}

private void show_staged_diff_intern(Gitg.Repository repository,

Gitg.DiffView view,

Gitg.StageStatusItem[]? items,

bool patchable)

{

var stage = repository.stage;

stage.diff_index_all.begin(items, view.options, (obj, res) => {

try

{

var d = stage.diff_index_all.end(res);

view.unstaged = false;

view.staged = patchable;

d_main.button_stage.label = _("_Unstage selection");

d_main.button_stage.visible = patchable;

d_main.button_discard.visible = false;

view.new_is_workdir = false;

view.diff = d;

}

catch

{

// TODO: error reporting

view.diff = null;

}

});

set_staged_diff_update_callback(repository, view, items, patchable);

}

private void show_staged_diff(Gitg.StageStatusItem[] items)

{

if (items.length == 1 && items[0] is Gitg.StageStatusSubmodule)

{

show_submodule_history((Gitg.StageStatusSubmodule)items[0], IndexType.STAGED);

}

else

{

show_ui(UiType.DIFF);

show_staged_diff_intern(application.repository, d_main.diff_view, items, true);

}

}

private async bool unstage_item(Gitg.StageStatusItem item, bool isnew, string removal_msg, string unstage_msg)

{

var stage = application.repository.stage;

if (isnew)

{

try

{

yield stage.delete_path(item.path);

}

catch (Error e)

{

application.show_infobar(removal_msg, e.message, Gtk.MessageType.ERROR);

return false;

}

}

else

{

try

{

yield stage.unstage_path(item.path);

}

catch (Error e)

{

application.show_infobar(unstage_msg, e.message, Gtk.MessageType.ERROR);

return false;

}

}

return true;

}

private async bool unstage_file(Gitg.StageStatusFile file)

{

return yield unstage_item(file,

(file.flags & Ggit.StatusFlags.INDEX_NEW) != 0,

_("Failed to unstage the removal of file “%s”").printf(file.path),

_("Failed to unstage the file “%s”").printf(file.path));

}

private async bool unstage_submodule(Gitg.StageStatusSubmodule sub)

{

return yield unstage_item(sub,

(sub.flags & Ggit.SubmoduleStatus.INDEX_ADDED) != 0,

_("Failed to unstage the removal of submodule “%s”").printf(sub.path),

_("Failed to unstage the submodule “%s”").printf(sub.path));

}

private void unstage_submodule_at(Gitg.Commit commit)

{

var parents = commit.get_parents();

if (parents.size != 0)

{

d_ignore_external_changes = true;

stage_submodule_at(parents[0] as Gitg.Commit);

}

else

{

d_ignore_external_changes = true;

unstage_submodule.begin(d_current_submodule, (obj, res) => {

unstage_submodule.end(res);

reload();

});

}

}

private async void unstage_items(owned Gitg.StageStatusItem[] items)

{

foreach (var item in items)

{

var ok = true;

if (item is Gitg.StageStatusFile)

{

d_ignore_external_changes = true;

ok = yield unstage_file((Gitg.StageStatusFile)item);

}

else if (item is Gitg.StageStatusSubmodule)

{

d_ignore_external_changes = true;

ok = yield unstage_submodule((Gitg.StageStatusSubmodule)item);

}

else

{

assert_not_reached();

}

if (!ok)

{

break;

}

}

reload();

}

private void on_staged_activated(Gitg.StageStatusItem[] items)

{

unstage_items.begin(items, (obj, res) => {

unstage_items.end(res);

});

}

private Sidebar.Item[] append_items(Gitg.SidebarStore model,

Gitg.StageStatusItem[] items,

Sidebar.Item.Type type,

Gee.HashSet<string>? selected_paths,

StageUnstageCallback? callback)

{

var ret = new Sidebar.Item[0];

var sorted = new Gee.ArrayList<Gitg.StageStatusItem>.wrap(items);

sorted.sort((a, b) => {

return a.path.casefold().collate(b.path.casefold());

});

string filter_filename_text = d_main.commit_files_search_entry.text;

foreach (var item in sorted)

{

var sitem = new Sidebar.Item(item, type);

bool filter_passed = filter_filename_text in item.path;

if (selected_paths != null && selected_paths.contains(item.path) && filter_passed)

{

ret += sitem;

}

sitem.activated.connect((numclick) => {

callback(sitem);

});

if (filter_passed) model.append(sitem);

}

return ret;

}

private void reload()

{

d_reload_when_mapped = null;

var repository = application.repository;

if (repository == null || d_reloading)

{

return;

}

d_reloading = true;

var sb = d_main.sidebar;

var model = sb.model;

Sidebar.Item.Type selected_type;

Gitg.StageStatusItem[] selected_items;

selected_items = items_for_items(sb.get_selected_items<Gitg.SidebarItem>(),

out selected_type);

var selected_paths = new Gee.HashSet<string>();

foreach (var item in selected_items)

{

selected_paths.add(item.path);

}

if (d_main.diff_view.use_gravatar)

{

// Preload author avatar

try

{

var author = get_signature("AUTHOR");

var ac = Gitg.AvatarCache.default();

ac.load.begin(author.get_email(), 50, null, (obj, res) => {

ac.load.end(res);

});

} catch {}

}

var stage = repository.stage;

var opts = Ggit.StatusOption.INCLUDE_UNTRACKED |

Ggit.StatusOption.RECURSE_UNTRACKED_DIRS |

Ggit.StatusOption.SORT_CASE_INSENSITIVELY |

Ggit.StatusOption.EXCLUDE_SUBMODULES |

Ggit.StatusOption.DISABLE_PATHSPEC_MATCH;

var show = Ggit.StatusShow.INDEX_AND_WORKDIR;

var options = new Ggit.StatusOptions(opts, show, null);

var enumerator = stage.file_status(options);

enumerator.next_items.begin(-1, (obj, res) => {

var items = enumerator.next_items.end(res);

var staged = new Gitg.StageStatusItem[items.length];

staged.length = 0;

var unstaged = new Gitg.StageStatusItem[items.length];

unstaged.length = 0;

var untracked = new Gitg.StageStatusItem[items.length];

untracked.length = 0;

var dirty = new Gitg.StageStatusItem[items.length];

dirty.length = 0;

bool hassub = false;

foreach (var item in items)

{

if (item.is_staged)

{

staged += item;

}

if (item.is_unstaged)

{

unstaged += item;

}

if (item.is_untracked)

{

untracked += item;

}

var sub = item as Gitg.StageStatusSubmodule;

if (sub != null)

{

hassub = true;

if (sub.is_dirty)

{

dirty += item;

}

}

}

model.clear();

d_main.diff_view.diff = null;

var current_staged = new Sidebar.Item[0];

var current_unstaged = new Sidebar.Item[0];

var current_untracked = new Sidebar.Item[0];

var current_submodules = new Sidebar.Item[0];

// Populate staged items

var staged_header = model.begin_header(_("Staged"), (uint)Sidebar.Item.Type.STAGED);

staged_header.activated.connect((numclick) => {

on_unstage_selected_items();

});

if (staged.length == 0)

{

model.append_dummy(_("No staged files"));

}

else

{

current_staged = append_items(model,

staged,

Sidebar.Item.Type.STAGED,

selected_paths,

(item) => {

if (d_main.sidebar.is_selected(item))

{

on_unstage_selected_items();

}

else

{

on_staged_activated(new Gitg.StageStatusItem[] {item.item});

}

});

}

model.end_header();

// Populate unstaged items

var unstaged_header = model.begin_header(_("Unstaged"), (uint)Sidebar.Item.Type.UNSTAGED);

unstaged_header.activated.connect((numclick) => {

on_stage_selected_items();

});

if (unstaged.length == 0)

{

model.append_dummy(_("No unstaged files"));

}

else

{

current_unstaged = append_items(model,

unstaged,

Sidebar.Item.Type.UNSTAGED,

selected_paths,

(item) => {

if (d_main.sidebar.is_selected(item))

{

on_stage_selected_items();

}

else

{

on_unstaged_activated(new Gitg.StageStatusItem[] {item.item});

}

});

}

model.end_header();

// Populate untracked items

model.begin_header(_("Untracked"), (uint)Sidebar.Item.Type.UNTRACKED);

if (untracked.length == 0)

{

model.append_dummy(_("No untracked files"));

}

else

{

current_untracked = append_items(model,

untracked,

Sidebar.Item.Type.UNTRACKED,

selected_paths,

(item) => {

if (d_main.sidebar.is_selected(item))

{

on_stage_selected_items();

}

else

{

on_unstaged_activated(new Gitg.StageStatusItem[] {item.item});

}

});

}

model.end_header();

// Populate submodule items

if (hassub)

{

model.begin_header(_("Submodule"), (uint)Sidebar.Item.Type.SUBMODULE);

if (dirty.length == 0)

{

model.append_dummy(_("No dirty submodules"));

}

else

{

current_submodules = append_items(model,

dirty,

Sidebar.Item.Type.SUBMODULE,

selected_paths,

(item) => {

if (d_main.sidebar.is_selected(item))

{

on_stage_selected_items();

}

else

{

on_unstaged_activated(new Gitg.StageStatusItem[] {item.item});

}

});

}

model.end_header();

}

d_main.sidebar.expand_all();