public static void TaskEventNotifier(ITaskList taskList)
{
if(taskList != null)
{
((ITaskListWithEvents)taskList).Add += new AddTaskEventHandler(ConsoleTaskEventNotifier_Add);
}
}
void OnTaskListToggled(object sender, Gtk.ToggledArgs args)
{
Logger.Debug("OnTaskListToggled");
Gtk.TreeIter iter;
Gtk.TreePath path = new Gtk.TreePath(args.Path);
if (!taskListsTree.Model.GetIter(out iter, path))
{
return; // Do nothing
}
ITaskList taskList = taskListsTree.Model.GetValue(iter, 0) as ITaskList;
if (taskList == null)
{
return;
}
//if (taskListsToHide == null)
// taskListsToHide = BuildNewTaskListList ();
if (taskListsToHide.Contains(taskList.Name))
{
taskListsToHide.Remove(taskList.Name);
}
else
{
taskListsToHide.Add(taskList.Name);
}
application.Preferences.SetStringList(PreferencesKeys.HideInAllTaskList,
taskListsToHide);
}
public ToDoListPresenter(IToDoListView view, ITaskList taskList, IExecutor executor)
{
this.view = view;
this.executor = executor;
this.taskList = taskList;
WireUpEvents();
}
private void ToggleCellDataFunc(Gtk.TreeViewColumn column,
Gtk.CellRenderer cell,
Gtk.TreeModel model,
Gtk.TreeIter iter)
{
Gtk.CellRendererToggle crt = cell as Gtk.CellRendererToggle;
ITaskList taskList = model.GetValue(iter, 0) as ITaskList;
if (taskList == null)
{
crt.Active = true;
return;
}
// If the setting is null or empty, show all taskLists
if (taskListsToHide == null || taskListsToHide.Count == 0)
{
crt.Active = true;
return;
}
// Check to see if the taskList is specified in the list
if (taskListsToHide.Contains(taskList.Name))
{
crt.Active = false;
return;
}
crt.Active = true;
}
public TaskDetailsView(ITaskList taskList)
{
InitializeComponent();
_viewModel = new TaskDetailsViewModel(this, taskList);
DataContext = ViewModel;
}
static TaskListManager()
{
_projects = new Dictionary <Guid, TaskListManager>();
_gate = new object();
_taskList = XSharpProjectPackage.XInstance.TaskList;
_manager = _taskList.TableControl.Manager;
_provider = new TaskListProvider(_manager);
}
public void Save(string fileName, ITaskList list)
{
FileStream writerFileStream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(writerFileStream, list);
writerFileStream.Close();
}
/// <summary>
/// Refilter the hard way by discovering the taskList to filter on
/// </summary>
private void Refilter()
{
ITaskList cat = GetSelectedTaskList();
if (cat != null)
{
Refilter(cat);
}
}
protected override void OnNavigatedTo(NavigationEventArgs args)
{
App.Events.ActiveTaskChanged += this.OnActiveTaskChanged;
this.TaskListViewModel = App.State.TaskList;
this.TaskListView.SelectedItem = App.State.ActiveTask;
this.Session.Model = App.State.ActiveSession;
}
public void Save(string fileName, ITaskList list)
{
if (string.Equals(fileName, "Exception"))
{
throw new ArgumentException();
}
SavedFile = fileName;
}
public CommentTaskTokenSerializer(
SVsServiceProvider serviceProvider, IOptionService optionService)
{
_optionService = optionService;
_taskList = serviceProvider.GetService(typeof(SVsTaskList)) as ITaskList;
_lastCommentTokenCache = GetTaskTokenList(_taskList);
// The SVsTaskList may not be available (e.g. during "devenv /build")
if (_taskList != null)
{
_taskList.PropertyChanged += OnPropertyChanged;
}
}
public CommentTaskTokenSerializer(
VisualStudioWorkspaceImpl workspace)
{
_optionService = workspace.Services.GetService <IOptionService>();
_taskList = workspace.GetVsService <SVsTaskList, ITaskList>();
_lastCommentTokenCache = GetTaskTokenList(_taskList);
// The SVsTaskList may not be available (e.g. during "devenv /build")
if (_taskList != null)
{
_taskList.PropertyChanged += OnPropertyChanged;
}
}
public CommentTaskTokenSerializer(
SVsServiceProvider serviceProvider, IOptionService optionService)
{
_optionService = optionService;
_taskList = serviceProvider.GetService(typeof(SVsTaskList)) as ITaskList;
_lastCommentTokenCache = GetTaskTokenList(_taskList);
// The SVsTaskList may not be available (e.g. during "devenv /build")
if (_taskList != null)
{
_taskList.PropertyChanged += OnPropertyChanged;
}
}
public CommentTaskTokenSerializer(
VisualStudioWorkspaceImpl workspace)
{
_optionService = workspace.Services.GetService<IOptionService>();
_taskList = workspace.GetVsService<SVsTaskList, ITaskList>();
_lastCommentTokenCache = GetTaskTokenList(_taskList);
// The SVsTaskList may not be available (e.g. during "devenv /build")
if (_taskList != null)
{
_taskList.PropertyChanged += OnPropertyChanged;
}
}
protected ITaskList GetSelectedTaskList()
{
ITaskList foundTaskList = null;
string cat = Application.Preferences.Get(
PreferencesKeys.SelectedTaskListKey);
if (cat != null)
{
var model = Application.BackendManager.TaskLists;
foundTaskList = model.FirstOrDefault(c => c.Name == cat);
}
return(foundTaskList);
}
// XSharpLanguageService _langService = null;
#region Overridden Implementation
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override async System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
// Give the codemodel a way to talk to the VS Shell
oShellLink = new XSharpShellLink();
XSettings.ShellLink = oShellLink;
this.RegisterToolWindows();
XSharpProjectPackage.instance = this;
this.SolutionListeners.Add(new SolutionEvents(this));
await base.InitializeAsync(cancellationToken, progress);
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
// The project selector helps to choose between MPF and CPS projects
//_projectSelector = new XSharpProjectSelector();
//await _projectSelector.InitAsync(this);
this.settings = new XPackageSettings(this);
VS.Events.BuildEvents.ProjectConfigurationChanged += BuildEvents_ProjectConfigurationChanged;
this.RegisterProjectFactory(new XSharpProjectFactory(this));
// Indicate how to open the different source files : SourceCode or Designer ??
this.RegisterEditorFactory(new XSharpEditorFactory(this));
this.RegisterProjectFactory(new XSharpWPFProjectFactory(this));
// editors for the binaries
base.RegisterEditorFactory(new VOFormEditorFactory(this));
base.RegisterEditorFactory(new VOMenuEditorFactory(this));
base.RegisterEditorFactory(new VODBServerEditorFactory(this));
base.RegisterEditorFactory(new VOFieldSpecEditorFactory(this));
//this._documentWatcher = new XSharpDocumentWatcher(this);
_errorList = await VS.GetRequiredServiceAsync <SVsErrorList, IErrorList>();
_taskList = await VS.GetRequiredServiceAsync <SVsTaskList, ITaskList>();
var shell = await VS.GetRequiredServiceAsync <SVsShell, IVsShell>();
if (shell != null)
{
shell.AdviseShellPropertyChanges(this, out shellCookie);
}
_langservice = await GetServiceAsync(typeof(XSharpLanguageService)) as XSharpLanguageService;
await this.RegisterCommandsAsync();
await GetEditorOptionsAsync();
}
private void TextCellDataFunc(Gtk.TreeViewColumn treeColumn,
Gtk.CellRenderer renderer, Gtk.TreeModel model,
Gtk.TreeIter iter)
{
Gtk.CellRendererText crt = renderer as Gtk.CellRendererText;
crt.Ellipsize = Pango.EllipsizeMode.End;
ITaskList taskList = model.GetValue(iter, 0) as ITaskList;
if (taskList == null)
{
crt.Text = string.Empty;
return;
}
crt.Text = GLib.Markup.EscapeText(taskList.Name);
}
/// <summary>
/// This returns the currently selected taskList.
/// TODO: This should really be moved as a method Application or
/// or something.
/// </summary>
/// <returns>
/// A <see cref="ITaskList"/>
/// </returns>
private ITaskList GetSelectedTaskList()
{
// TODO: Move this code into some function in the backend/somewhere
// with the signature of GetTaskListForName (string catName):ITaskList
string selectedTaskListName =
Application.Preferences.Get(PreferencesKeys.SelectedTaskListKey);
ITaskList taskList = null;
if (selectedTaskListName != null)
{
var model = Application.BackendManager.TaskLists;
taskList = model.FirstOrDefault(c => c != null && c.Name == selectedTaskListName);
}
return(taskList);
}
protected override void OnNavigatedTo(NavigationEventArgs args)
{
this.TaskListViewModel = App.State.TaskList;
this.SelectedTaskOnOpen = App.State.ActiveTask;
if (this.SelectedTaskOnOpen == null)
{
this.SelectedTaskColorBrush = new SolidColorBrush(Colors.White);
this.TaskHeaderPanel.Visibility = Visibility.Collapsed;
this.TaskInfoPanel.Visibility = Visibility.Collapsed;
}
else
{
this.SelectedTaskColorBrush = new SolidColorBrush(App.Settings.GetTaskColor(this.SelectedTaskOnOpen));
}
this.DeleteRequestor.IsEnabled = false;
}
public CommentTaskTokenSerializer(
VisualStudioWorkspace workspace,
[Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider)
{
_workspace = workspace;
// The SVsTaskList may not be available or doesn't actually implement ITaskList
// in the "devenv /build" scenario
_taskList = serviceProvider.GetService(typeof(SVsTaskList)) as ITaskList;
// GetTaskTokenList is safe in the face of nulls
_lastCommentTokenCache = GetTaskTokenList(_taskList);
if (_taskList != null)
{
_taskList.PropertyChanged += OnPropertyChanged;
}
}
private static string GetTaskTokenList(ITaskList taskList)
{
var commentTokens = taskList?.CommentTokens;
if (commentTokens == null || commentTokens.Count == 0)
{
return string.Empty;
}
var result = new List<string>();
foreach (var commentToken in commentTokens)
{
if (string.IsNullOrWhiteSpace(commentToken.Text))
{
continue;
}
result.Add($"{commentToken.Text}:{((int)commentToken.Priority).ToString()}");
}
return string.Join("|", result);
}
public void Save(ITaskList list, UserInputParser input)
{
string saveFileName = _fileName;
while (string.IsNullOrWhiteSpace(saveFileName))
{
Console.WriteLine("Please enter the filename that you would like to save to:");
saveFileName = input.GetString();
}
try
{
_storage.Save(saveFileName, list);
_fileName = saveFileName;
Console.WriteLine(string.Format("Task List saved to {0}.", saveFileName));
}
catch (Exception e)
{
Console.WriteLine(string.Format("Unable to save task data. {0}", e.Message));
}
}
private static string GetTaskTokenList(ITaskList taskList)
{
var commentTokens = taskList?.CommentTokens;
if (commentTokens == null || commentTokens.Count == 0)
{
return(string.Empty);
}
var result = new List <string>();
foreach (var commentToken in commentTokens)
{
if (string.IsNullOrWhiteSpace(commentToken.Text))
{
continue;
}
result.Add($"{commentToken.Text}:{((int)commentToken.Priority).ToString()}");
}
return(string.Join("|", result));
}
public CompletedTaskGroup(string groupName, DateTime rangeStart,
DateTime rangeEnd, ICollection <ITask> tasks, GtkApplicationBase application)
: base(groupName, rangeStart, rangeEnd, new CompletedTasksSortModel(tasks), application)
{
var preferences = application.Preferences;
// Only hide this group, when ShowCompletedTasks is unset in prefs.
// If it's set, don't hide this group when it's empty because then the range
// slider won't appear and the user won't be able to customize the range.
HideWhenEmpty = !preferences.GetBool(PreferencesKeys.ShowCompletedTasksKey);
// track changes in prefs for ShowCompletedTasks setting
preferences.SettingChanged += (prefs, key) => {
switch (key)
{
case PreferencesKeys.ShowCompletedTasksKey:
HideWhenEmpty = !prefs.GetBool(PreferencesKeys.ShowCompletedTasksKey);
// refresh ui
var cat = GetSelectedTaskList();
if (cat != null)
{
Refilter(cat);
}
break;
case PreferencesKeys.SelectedTaskListKey:
selectedTaskList = GetSelectedTaskList();
Refilter(selectedTaskList);
break;
}
};
CreateRangeSlider();
UpdateDateRanges();
}
private ITask CreateTask(string taskText, ITaskList taskList)
{
var task = taskList.CreateTask (taskText);
if (task == null) {
Logger.Debug ("Error creating a new task!");
// Show error status
status = Catalog.GetString ("Error creating a new task");
TaskWindow.ShowStatus (status);
} else {
// Show successful status
status = Catalog.GetString ("Task created successfully");
TaskWindow.ShowStatus (status);
// Clear out the entry
addTaskEntry.Text = string.Empty;
addTaskEntry.GrabFocus ();
}
return task;
}
// TODO: Move this method into a property of ITaskList.TaskCount
private int GetTaskCountInTaskList(ITaskList taskList)
{
// This is disgustingly inefficient, but, oh well
int count = 0;
var model = application.BackendManager.Tasks;
count = model.Count (t => t != null &&
t.State == TaskState.Active &&
taskList.Contains (t));
return count;
}
/// <summary>
/// Deletes the task list.
/// </summary>
/// <returns><c>true</c>, if task list was deleted, <c>false</c> otherwise.</returns>
/// <param name="list">The task list to delete.</param>
public bool DeleteTaskList(ITaskList list)
{
return taskLists.Remove (list);
}
public TasksController(ITaskList tasks)
{
this.tasks = tasks;
}
/// <summary>
/// Create a new task in Tasque using the given taskListName and name.
/// </summary>
/// <param name="taskListName">
/// A <see cref="System.String"/>. The name of an existing taskList.
/// Matches are not case-sensitive.
/// </param>
/// <param name="taskName">
/// A <see cref="System.String"/>. The name of the task to be created.
/// </param>
/// <param name="enterEditMode">
/// A <see cref="System.Boolean"/>. Specify true if the TaskWindow
/// should be shown, the new task scrolled to, and have it be put into
/// edit mode immediately.
/// </param>
/// <param name="parseDate">
/// A <see cref="System.Boolean"/>. Specify true if the
/// date should be parsed out of the taskName (in case
/// Preferences.ParseDateEnabledKey is true as well).
/// </param>
/// <returns>
/// A unique <see cref="System.String"/> which can be used to reference
/// the task later.
/// </returns>
public string CreateTask(string taskListName, string taskName,
bool enterEditMode, bool parseDate)
{
var model = application.BackendManager.TaskLists;
//
// Validate the input parameters. Don't allow null or empty strings
// be passed-in.
//
if (taskListName == null || taskListName.Trim() == string.Empty ||
taskName == null || taskName.Trim() == string.Empty)
{
return(string.Empty);
}
//
// Look for the specified taskList
//
if (model.Count == 0)
{
return(string.Empty);
}
ITaskList taskList = model.FirstOrDefault(c => c.Name.ToLower() == taskListName.ToLower());
if (taskList == null)
{
return(string.Empty);
}
// If enabled, attempt to parse due date information
// out of the taskName.
DateTime taskDueDate = DateTime.MinValue;
if (parseDate && application.Preferences.GetBool(PreferencesKeys.ParseDateEnabledKey))
{
TaskParser.Instance.TryParse(
taskName,
out taskName,
out taskDueDate);
}
ITask task = null;
try {
task = taskList.CreateTask(taskName);
taskList.Add(task);
if (taskDueDate != DateTime.MinValue)
{
task.DueDate = taskDueDate;
}
} catch (Exception e) {
Logger.Error("Exception calling Application.Backend.CreateTask from RemoteControl: {0}", e.Message);
return(string.Empty);
}
if (task == null)
{
return(string.Empty);
}
if (enterEditMode)
{
// TaskWindow.SelectAndEdit (task, application);
}
#if ENABLE_NOTIFY_SHARP
// Use notify-sharp to alert the user that a new task has been
// created successfully.
application.ShowAppNotification(
Catalog.GetString("New task created."), // summary
Catalog.GetString(taskName)); // body
#endif
return(task.Id);
}
public void Refilter(ITaskList selectedTaskList)
{
taskView.Refilter (selectedTaskList);
}
public ToDoListView(ITaskList taskList)
{
InitializeComponent();
this.taskList = taskList;
WireUpEvents();
}
public TaskView(Gtk.TreeModel model, IPreferences preferences)
{
if (preferences == null)
{
throw new ArgumentNullException("preferences");
}
TreeView = new TreeView();
#if GTK_2_12
// set up the timing for the tooltips
TreeView.Settings.SetLongProperty("gtk-tooltip-browse-mode-timeout", 0, "Tasque:TaskTreeView");
TreeView.Settings.SetLongProperty("gtk-tooltip-browse-timeout", 750, "Tasque:TaskTreeView");
TreeView.Settings.SetLongProperty("gtk-tooltip-timeout", 750, "Tasque:TaskTreeView");
ConnectEvents();
#endif
// TODO: Modify the behavior of the TreeView so that it doesn't show
// the highlighted row. Then, also tie in with the mouse hovering
// so that as you hover the mouse around, it will automatically
// select the row that the mouse is hovered over. By doing this,
// we should be able to not require the user to click on a task
// to select it and THEN have to click on the column item they want
// to modify.
filterTaskList = null;
modelFilter = new Gtk.TreeModelFilter(model, null);
modelFilter.VisibleFunc = FilterFunc;
modelFilter.RowInserted += OnRowInsertedHandler;
modelFilter.RowDeleted += OnRowDeletedHandler;
Refilter();
//Model = modelFilter
TreeView.Selection.Mode = Gtk.SelectionMode.Single;
TreeView.RulesHint = false;
TreeView.HeadersVisible = false;
TreeView.HoverSelection = true;
// TODO: Figure out how to turn off selection highlight
columns = new List <ITaskColumn> ();
var nodeList = AddinManager.GetExtensionNodes(typeof(ITaskColumn)).Cast <TaskColNode> ();
var nodes = new List <TaskColNode> (nodeList);
foreach (var node in nodes)
{
AddColumn(node, nodes);
}
rowEditingDictionary = new ConcurrentDictionary <ITaskColumn, TaskRowEditingEventArgs> ();
columns.Sort((x, y) => x.DefaultPosition.CompareTo(y.DefaultPosition));
foreach (var col in columns)
{
col.Initialize(Model, this, preferences);
col.CellEditingStarted += (sender, e) => {
if (rowEditingDictionary.IsEmpty)
{
IsTaskBeingEdited = true;
}
if (!rowEditingDictionary.Any(v => v.Value.ITask == e.ITask))
{
if (RowEditingStarted != null)
{
RowEditingStarted(this, e);
}
}
rowEditingDictionary.TryAdd((ITaskColumn)sender, e);
};
col.CellEditingFinished += (sender, e) => {
TaskRowEditingEventArgs args;
rowEditingDictionary.TryRemove((ITaskColumn)sender, out args);
if (!rowEditingDictionary.Any(v => v.Value.ITask == e.ITask))
{
if (RowEditingFinished != null)
{
RowEditingFinished(this, e);
}
}
if (rowEditingDictionary.IsEmpty)
{
IsTaskBeingEdited = false;
}
};
TreeView.AppendColumn(col.TreeViewColumn);
}
}
public void Refilter(ITaskList selectedTaskList)
{
this.filterTaskList = selectedTaskList;
TreeView.Model = modelFilter;
modelFilter.Refilter();
}
public TaskListMenuItem(ITaskList taskList)
: base(taskList.Name)
{
cat = taskList;
}
public void Refilter(ITaskList selectedTaskList)
{
taskView.Refilter(selectedTaskList);
}
// XSharpLanguageService _langService = null;
#region Overridden Implementation
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override async System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress)
{
// Suspend walking until Solution is opened.
base.SolutionListeners.Add(new ModelScannerEvents(this));
await base.InitializeAsync(cancellationToken, progress);
await JoinableTaskFactory.SwitchToMainThreadAsync();
_uiThread = new UIThread();
XSharpProjectPackage.instance = this;
XSharpModel.XSolution.OutputWindow = this;
this.RegisterProjectFactory(new XSharpProjectFactory(this));
this.settings = new XPackageSettings(this);
validateVulcanEditors();
this.RegisterDebuggerEvents();
// Indicate how to open the different source files : SourceCode or Designer ??
this.RegisterEditorFactory(new XSharpEditorFactory(this));
this.RegisterProjectFactory(new XSharpWPFProjectFactory(this));
// editors for the binaries
base.RegisterEditorFactory(new VOFormEditorFactory(this));
base.RegisterEditorFactory(new VOMenuEditorFactory(this));
base.RegisterEditorFactory(new VODBServerEditorFactory(this));
base.RegisterEditorFactory(new VOFieldSpecEditorFactory(this));
XSharp.Project.XSharpMenuItems.Initialize(this);
// Register a timer to call our language service during
// idle periods.
IOleComponentManager mgr = await GetServiceAsync(typeof(SOleComponentManager)) as IOleComponentManager;
if (m_componentID == 0 && mgr != null)
{
OLECRINFO[] crinfo = new OLECRINFO[1];
crinfo[0].cbSize = (uint)Marshal.SizeOf(typeof(OLECRINFO));
crinfo[0].grfcrf = (uint)_OLECRF.olecrfNeedIdleTime |
(uint)_OLECRF.olecrfNeedPeriodicIdleTime;
crinfo[0].grfcadvf = (uint)_OLECADVF.olecadvfModal |
(uint)_OLECADVF.olecadvfRedrawOff |
(uint)_OLECADVF.olecadvfWarningsOff;
crinfo[0].uIdleTimeInterval = 1000;
int hr = mgr.FRegisterComponent(this, crinfo, out m_componentID);
}
// Initialize Custom Menu Items
// register property changed event handler
var shell = await this.GetServiceAsync(typeof(SVsShell)) as IVsShell;
Assumes.Present(shell);
shell.AdviseShellPropertyChanges(this, out shellCookie);
//
// ObjectBrowser : Add the LibraryManager service as a Service provided by that container
IServiceContainer container = this as IServiceContainer;
ServiceCreatorCallback callback = new ServiceCreatorCallback(CreateLibraryService);
//
container.AddService(typeof(IXSharpLibraryManager), callback, true);
this._documentWatcher = new XSharpDocumentWatcher(this);
_txtManager = await GetServiceAsync(typeof(SVsTextManager)) as IVsTextManager4;
// determine version of VS
object vers;
shell.GetProperty((int)__VSSPROPID5.VSSPROPID_ReleaseVersion, out vers);
VsVersion = vers.ToString();
_errorList = await GetServiceAsync(typeof(SVsErrorList)) as IErrorList;
_taskList = await GetServiceAsync(typeof(SVsTaskList)) as ITaskList;
}
private ITaskList taskList; //why private - outside world should not know. proxy attendance cannot given public
#endregion Fields
#region Constructors
public TaskEventGenerator(ITaskList taskList)
{
this.taskList = taskList;
Console.WriteLine("from TaskEventGenerator added");
}
public TaskListController()
{
this.tasklist = new Interfaces.TaskList();
}
public TaskView(Gtk.TreeModel model, IPreferences preferences)
{
if (preferences == null)
throw new ArgumentNullException ("preferences");
TreeView = new TreeView ();
#if GTK_2_12
// set up the timing for the tooltips
TreeView.Settings.SetLongProperty("gtk-tooltip-browse-mode-timeout", 0, "Tasque:TaskTreeView");
TreeView.Settings.SetLongProperty("gtk-tooltip-browse-timeout", 750, "Tasque:TaskTreeView");
TreeView.Settings.SetLongProperty("gtk-tooltip-timeout", 750, "Tasque:TaskTreeView");
ConnectEvents();
#endif
// TODO: Modify the behavior of the TreeView so that it doesn't show
// the highlighted row. Then, also tie in with the mouse hovering
// so that as you hover the mouse around, it will automatically
// select the row that the mouse is hovered over. By doing this,
// we should be able to not require the user to click on a task
// to select it and THEN have to click on the column item they want
// to modify.
filterTaskList = null;
modelFilter = new Gtk.TreeModelFilter (model, null);
modelFilter.VisibleFunc = FilterFunc;
modelFilter.RowInserted += OnRowInsertedHandler;
modelFilter.RowDeleted += OnRowDeletedHandler;
Refilter ();
//Model = modelFilter
TreeView.Selection.Mode = Gtk.SelectionMode.Single;
TreeView.RulesHint = false;
TreeView.HeadersVisible = false;
TreeView.HoverSelection = true;
// TODO: Figure out how to turn off selection highlight
columns = new List<ITaskColumn> ();
var nodeList = AddinManager.GetExtensionNodes (typeof(ITaskColumn)).Cast<TaskColNode> ();
var nodes = new List<TaskColNode> (nodeList);
foreach (var node in nodes)
AddColumn (node, nodes);
rowEditingDictionary = new ConcurrentDictionary<ITaskColumn, TaskRowEditingEventArgs> ();
columns.Sort ((x, y) => x.DefaultPosition.CompareTo (y.DefaultPosition));
foreach (var col in columns) {
col.Initialize (Model, this, preferences);
col.CellEditingStarted += (sender, e) => {
if (rowEditingDictionary.IsEmpty)
IsTaskBeingEdited = true;
if (!rowEditingDictionary.Any (v => v.Value.ITask == e.ITask)) {
if (RowEditingStarted != null)
RowEditingStarted (this, e);
}
rowEditingDictionary.TryAdd ((ITaskColumn)sender, e);
};
col.CellEditingFinished += (sender, e) => {
TaskRowEditingEventArgs args;
rowEditingDictionary.TryRemove ((ITaskColumn)sender, out args);
if (!rowEditingDictionary.Any (v => v.Value.ITask == e.ITask)) {
if (RowEditingFinished != null)
RowEditingFinished (this, e);
}
if (rowEditingDictionary.IsEmpty)
IsTaskBeingEdited = false;
};
TreeView.AppendColumn (col.TreeViewColumn);
}
}
public void Refilter(ITaskList selectedTaskList)
{
this.filterTaskList = selectedTaskList;
TreeView.Model = modelFilter;
modelFilter.Refilter ();
}
