static NotebookManager ()
{
notebooks = new Gtk.ListStore (typeof (Notebook));
sortedNotebooks = new Gtk.TreeModelSort (notebooks);
sortedNotebooks.SetSortFunc (0, new Gtk.TreeIterCompareFunc (CompareNotebooksSortFunc));
sortedNotebooks.SetSortColumnId (0, Gtk.SortType.Ascending);
filteredNotebooks = new Gtk.TreeModelFilter (sortedNotebooks, null);
filteredNotebooks.VisibleFunc = FilterNotebooks;
AllNotesNotebook allNotesNotebook = new AllNotesNotebook ();
Gtk.TreeIter iter = notebooks.Append ();
notebooks.SetValue (iter, 0, allNotesNotebook);
UnfiledNotesNotebook unfiledNotesNotebook = new UnfiledNotesNotebook ();
iter = notebooks.Append ();
notebooks.SetValue (iter, 0, unfiledNotesNotebook);
// <summary>
// The key for this dictionary is Notebook.Name.ToLower ().
// </summary>
notebookMap = new Dictionary<string, Gtk.TreeIter> ();
// Load the notebooks now if the notes have already been loaded
// or wait for the NotesLoaded event otherwise.
if (Tomboy.DefaultNoteManager.Initialized)
LoadNotebooks ();
else
Tomboy.DefaultNoteManager.NotesLoaded += OnNotesLoaded;
}
static void SetSortFunctions(
Gtk.TreeModelSort treeModelSort,
Dictionary <int, Gtk.TreeIterCompareFunc> sortFunctions)
{
foreach (int sortColumnId in sortFunctions.Keys)
{
treeModelSort.SetSortFunc(sortColumnId, sortFunctions[sortColumnId]);
}
}
static void SortColumnChanged_cb(IntPtr inst)
{
try {
Gtk.TreeModelSort __obj = GLib.Object.GetObject(inst, false) as Gtk.TreeModelSort;
__obj.OnSortColumnChanged();
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException(e, false);
}
}
static void RowDeleted_cb(IntPtr inst, IntPtr path)
{
try {
Gtk.TreeModelSort __obj = GLib.Object.GetObject(inst, false) as Gtk.TreeModelSort;
__obj.OnRowDeleted(path == IntPtr.Zero ? null : (Gtk.TreePath)GLib.Opaque.GetOpaque(path, typeof(Gtk.TreePath), false));
} catch (Exception e) {
GLib.ExceptionManager.RaiseUnhandledException(e, false);
}
}
//SqliteCategory workCategory;
//SqliteCategory projectsCategory;
public SqliteBackend()
{
initialized = false;
taskIters = new Dictionary<int, Gtk.TreeIter> ();
taskStore = new Gtk.TreeStore (typeof (ITask));
sortedTasksModel = new Gtk.TreeModelSort (taskStore);
sortedTasksModel.SetSortFunc (0, new Gtk.TreeIterCompareFunc (CompareTasksSortFunc));
sortedTasksModel.SetSortColumnId (0, Gtk.SortType.Ascending);
categoryListStore = new Gtk.ListStore (typeof (ICategory));
sortedCategoriesModel = new Gtk.TreeModelSort (categoryListStore);
sortedCategoriesModel.SetSortFunc (0, new Gtk.TreeIterCompareFunc (CompareCategorySortFunc));
sortedCategoriesModel.SetSortColumnId (0, Gtk.SortType.Ascending);
}
//SqliteCategory workCategory;
//SqliteCategory projectsCategory;
public SqliteBackend()
{
initialized = false;
taskIters = new Dictionary <int, Gtk.TreeIter> ();
taskStore = new Gtk.TreeStore(typeof(ITask));
sortedTasksModel = new Gtk.TreeModelSort(taskStore);
sortedTasksModel.SetSortFunc(0, new Gtk.TreeIterCompareFunc(CompareTasksSortFunc));
sortedTasksModel.SetSortColumnId(0, Gtk.SortType.Ascending);
categoryListStore = new Gtk.ListStore(typeof(ICategory));
sortedCategoriesModel = new Gtk.TreeModelSort(categoryListStore);
sortedCategoriesModel.SetSortFunc(0, new Gtk.TreeIterCompareFunc(CompareCategorySortFunc));
sortedCategoriesModel.SetSortColumnId(0, Gtk.SortType.Ascending);
}
public EDSBackend()
{
initialized = false;
taskIters = new Dictionary <string, Gtk.TreeIter> ();
taskStore = new Gtk.TreeStore(typeof(ITask));
taskLock = new object();
sortedTasksModel = new Gtk.TreeModelSort(taskStore);
sortedTasksModel.SetSortFunc(0, new Gtk.TreeIterCompareFunc(CompareTasksSortFunc));
sortedTasksModel.SetSortColumnId(0, Gtk.SortType.Ascending);
categoryListStore = new Gtk.ListStore(typeof(ICategory));
sortedCategoriesModel = new Gtk.TreeModelSort(categoryListStore);
sortedCategoriesModel.SetSortFunc(0, new Gtk.TreeIterCompareFunc(CompareCategorySortFunc));
sortedCategoriesModel.SetSortColumnId(0, Gtk.SortType.Ascending);
defaultCategory = null;
}
public EDSBackend()
{
initialized = false;
taskIters = new Dictionary<string, Gtk.TreeIter> ();
taskStore = new Gtk.TreeStore (typeof (ITask));
taskLock = new object ();
sortedTasksModel = new Gtk.TreeModelSort (taskStore);
sortedTasksModel.SetSortFunc (0, new Gtk.TreeIterCompareFunc (CompareTasksSortFunc));
sortedTasksModel.SetSortColumnId (0, Gtk.SortType.Ascending);
categoryListStore = new Gtk.ListStore (typeof (ICategory));
sortedCategoriesModel = new Gtk.TreeModelSort (categoryListStore);
sortedCategoriesModel.SetSortFunc (0, new Gtk.TreeIterCompareFunc (CompareCategorySortFunc));
sortedCategoriesModel.SetSortColumnId (0, Gtk.SortType.Ascending);
defaultCategory = null;
}
public static Gtk.Window CreateTreeWindow()
{
Gtk.Window window = new Gtk.Window("Sortable TreeView");
Gtk.TreeIter iter;
Gtk.TreeViewColumn col;
Gtk.CellRendererText cell;
Gtk.TreeView tree = new Gtk.TreeView();
cell = new Gtk.CellRendererText();
col = new Gtk.TreeViewColumn();
col.Title = "Column 1";
col.PackStart(cell, true);
col.AddAttribute(cell, "text", 0);
col.SortColumnId = 0;
tree.AppendColumn(col);
cell = new Gtk.CellRendererText();
col = new Gtk.TreeViewColumn();
col.Title = "Column 2";
col.PackStart(cell, true);
col.AddAttribute(cell, "text", 1);
tree.AppendColumn(col);
Gtk.TreeStore store = new Gtk.TreeStore(typeof(string), typeof(string));
iter = store.AppendValues("BBB");
store.AppendValues(iter, "AAA", "Zzz");
store.AppendValues(iter, "DDD", "Ttt");
store.AppendValues(iter, "CCC", "Ggg");
iter = store.AppendValues("AAA");
store.AppendValues(iter, "ZZZ", "Zzz");
store.AppendValues(iter, "GGG", "Ggg");
store.AppendValues(iter, "TTT", "Ttt");
Gtk.TreeModelSort sortable = new Gtk.TreeModelSort(store);
sortable.SetSortFunc(0, delegate(TreeModel model, TreeIter a, TreeIter b) {
string s1 = (string)model.GetValue(a, 0);
string s2 = (string)model.GetValue(b, 0);
return(String.Compare(s1, s2));
});
tree.Model = sortable;
window.Add(tree);
return(window);
}
public RtmBackend()
{
initialized = false;
configured = false;
taskIters = new Dictionary <string, Gtk.TreeIter> ();
taskLock = new Object();
categories = new Dictionary <string, RtmCategory> ();
catLock = new Object();
// *************************************
// Data Model Set up
// *************************************
taskStore = new Gtk.TreeStore(typeof(ITask));
sortedTasksModel = new Gtk.TreeModelSort(taskStore);
sortedTasksModel.SetSortFunc(0, new Gtk.TreeIterCompareFunc(CompareTasksSortFunc));
sortedTasksModel.SetSortColumnId(0, Gtk.SortType.Ascending);
categoryListStore = new Gtk.ListStore(typeof(ICategory));
sortedCategoriesModel = new Gtk.TreeModelSort(categoryListStore);
sortedCategoriesModel.SetSortFunc(0, new Gtk.TreeIterCompareFunc(CompareCategorySortFunc));
sortedCategoriesModel.SetSortColumnId(0, Gtk.SortType.Ascending);
// make sure we have the all Category in our list
Gtk.Application.Invoke(delegate {
AllCategory allCategory = new Tasque.AllCategory();
Gtk.TreeIter iter = categoryListStore.Append();
categoryListStore.SetValue(iter, 0, allCategory);
});
runRefreshEvent = new AutoResetEvent(false);
runningRefreshThread = false;
refreshThread = new Thread(RefreshThreadLoop);
}
public RtmBackend()
{
initialized = false;
configured = false;
taskIters = new Dictionary<string, Gtk.TreeIter> ();
taskLock = new Object();
categories = new Dictionary<string, RtmCategory> ();
catLock = new Object();
// *************************************
// Data Model Set up
// *************************************
taskStore = new Gtk.TreeStore (typeof (ITask));
sortedTasksModel = new Gtk.TreeModelSort (taskStore);
sortedTasksModel.SetSortFunc (0, new Gtk.TreeIterCompareFunc (CompareTasksSortFunc));
sortedTasksModel.SetSortColumnId (0, Gtk.SortType.Ascending);
categoryListStore = new Gtk.ListStore (typeof (ICategory));
sortedCategoriesModel = new Gtk.TreeModelSort (categoryListStore);
sortedCategoriesModel.SetSortFunc (0, new Gtk.TreeIterCompareFunc (CompareCategorySortFunc));
sortedCategoriesModel.SetSortColumnId (0, Gtk.SortType.Ascending);
// make sure we have the all Category in our list
Gtk.Application.Invoke ( delegate {
AllCategory allCategory = new Tasque.AllCategory ();
Gtk.TreeIter iter = categoryListStore.Append ();
categoryListStore.SetValue (iter, 0, allCategory);
});
runRefreshEvent = new AutoResetEvent(false);
runningRefreshThread = false;
refreshThread = new Thread(RefreshThreadLoop);
}
public IceBackend()
{
initialized = false;
//
// Set up the Tasks ListStore
//
tasks = new Gtk.ListStore (typeof (ITask));
sortedTasks = new Gtk.TreeModelSort (tasks);
sortedTasks.SetSortFunc (0,
new Gtk.TreeIterCompareFunc (CompareTasksSortFunc));
sortedTasks.SetSortColumnId (0, Gtk.SortType.Ascending);
taskIters = new Dictionary<string, Gtk.TreeIter> ();
categories = new Gtk.ListStore (typeof (ICategory));
sortedCategories = new Gtk.TreeModelSort (categories);
sortedCategories.SetSortFunc (0,
new Gtk.TreeIterCompareFunc (CompareCategoriesSortFunc));
sortedCategories.SetSortColumnId (0, Gtk.SortType.Ascending);
categoryIters = new Dictionary<string, Gtk.TreeIter> ();
DaemonService.Initialize ();
}
public IceBackend()
{
initialized = false;
//
// Set up the Tasks ListStore
//
tasks = new Gtk.ListStore(typeof(ITask));
sortedTasks = new Gtk.TreeModelSort(tasks);
sortedTasks.SetSortFunc(0,
new Gtk.TreeIterCompareFunc(CompareTasksSortFunc));
sortedTasks.SetSortColumnId(0, Gtk.SortType.Ascending);
taskIters = new Dictionary <string, Gtk.TreeIter> ();
categories = new Gtk.ListStore(typeof(ICategory));
sortedCategories = new Gtk.TreeModelSort(categories);
sortedCategories.SetSortFunc(0,
new Gtk.TreeIterCompareFunc(CompareCategoriesSortFunc));
sortedCategories.SetSortColumnId(0, Gtk.SortType.Ascending);
categoryIters = new Dictionary <string, Gtk.TreeIter> ();
DaemonService.Initialize();
}
static NotebookManager()
{
notebooks = new Gtk.ListStore(typeof(Notebook));
sortedNotebooks = new Gtk.TreeModelSort(notebooks);
sortedNotebooks.SetSortFunc(0, new Gtk.TreeIterCompareFunc(CompareNotebooksSortFunc));
sortedNotebooks.SetSortColumnId(0, Gtk.SortType.Ascending);
filteredNotebooks = new Gtk.TreeModelFilter(sortedNotebooks, null);
filteredNotebooks.VisibleFunc = FilterNotebooks;
AllNotesNotebook allNotesNotebook = new AllNotesNotebook();
Gtk.TreeIter iter = notebooks.Append();
notebooks.SetValue(iter, 0, allNotesNotebook);
UnfiledNotesNotebook unfiledNotesNotebook = new UnfiledNotesNotebook();
iter = notebooks.Append();
notebooks.SetValue(iter, 0, unfiledNotesNotebook);
// <summary>
// The key for this dictionary is Notebook.Name.ToLower ().
// </summary>
notebookMap = new Dictionary <string, Gtk.TreeIter> ();
// Load the notebooks now if the notes have already been loaded
// or wait for the NotesLoaded event otherwise.
if (Tomboy.DefaultNoteManager.Initialized)
{
LoadNotebooks();
}
else
{
Tomboy.DefaultNoteManager.NotesLoaded += OnNotesLoaded;
}
}
internal void Fill(List <T> values)
{
if (values == null)
{
return;
}
Gtk.ListStore listStore = new Gtk.ListStore(typeof(T));
values.ForEach((val) => listStore.AppendValues(val));
mModelFilter = new Gtk.TreeModelFilter(listStore, null);
mModelFilter.VisibleFunc = mVisibleFunc;
mModelSort = new Gtk.TreeModelSort(mModelFilter);
SetSortFunctions(mModelSort, mSortFunctionByColumn);
if (View.Model != null)
{
(View.Model as Gtk.TreeModelSort).Dispose();
}
View.Model = mModelSort;
}
public HmBackend()
{
initialized = false;
configured = false;
newTaskId = 0;
taskIters = new Dictionary <string, Gtk.TreeIter> ();
taskStore = new Gtk.TreeStore(typeof(ITask));
taskLock = new object();
sortedTasksModel = new Gtk.TreeModelSort(taskStore);
sortedTasksModel.SetSortFunc(0, new Gtk.TreeIterCompareFunc(CompareTasksSortFunc));
sortedTasksModel.SetSortColumnId(0, Gtk.SortType.Ascending);
categoryListStore = new Gtk.ListStore(typeof(ICategory));
sortedCategoriesModel = new Gtk.TreeModelSort(categoryListStore);
sortedCategoriesModel.SetSortFunc(0, new Gtk.TreeIterCompareFunc(CompareCategorySortFunc));
sortedCategoriesModel.SetSortColumnId(0, Gtk.SortType.Ascending);
runRefreshEvent = new AutoResetEvent(false);
runningRefreshThread = false;
}
void CreateControl()
{
// control = new HPaned ();
// store = new Gtk.ListStore (typeof (Gdk.Pixbuf), // image - type
// typeof (bool), // read?
// typeof (Task)); // read? -- use Pango weight
// Gtk.TreeModelFilterVisibleFunc filterFunct = new Gtk.TreeModelFilterVisibleFunc();
filter = new Gtk.TreeModelFilter(store, null);
// filter.VisibleFunc = filterFunct;
//
sort = new Gtk.TreeModelSort(filter);
// sort.SetSortFunc (VisibleColumns.Type, SeverityIterSort);
// sort.SetSortFunc (VisibleColumns.Project, ProjectIterSort);
// sort.SetSortFunc (VisibleColumns.File, FileIterSort);
//
view = new PadTreeView(sort);
view.RulesHint = true;
// view.DoPopupMenu = (evnt) => IdeApp.CommandService.ShowContextMenu (view, evnt, CreateMenu ());
// AddColumns ();
// LoadColumnsVisibility ();
// view.Columns[VisibleColumns.Type].SortColumnId = VisibleColumns.Type;
// view.Columns[VisibleColumns.Project].SortColumnId = VisibleColumns.Project;
// view.Columns[VisibleColumns.File].SortColumnId = VisibleColumns.File;
sw = new CompactScrolledWindow();
sw.ShadowType = Gtk.ShadowType.None;
sw.Add(view);
// TaskService.Errors.TasksRemoved += DispatchService.GuiDispatch<TaskEventHandler> (ShowResults);
// TaskService.Errors.TasksAdded += DispatchService.GuiDispatch<TaskEventHandler> (TaskAdded);
// TaskService.Errors.TasksChanged += DispatchService.GuiDispatch<TaskEventHandler> (TaskChanged);
// TaskService.Errors.CurrentLocationTaskChanged += HandleTaskServiceErrorsCurrentLocationTaskChanged;
//
// IdeApp.Workspace.FirstWorkspaceItemOpened += OnCombineOpen;
// IdeApp.Workspace.LastWorkspaceItemClosed += OnCombineClosed;
// view.RowActivated += new Gtk.RowActivatedHandler (OnRowActivated);
iconWarning = sw.RenderIcon(Stock.Warning, Gtk.IconSize.Menu, "");
iconError = sw.RenderIcon(Stock.Error, Gtk.IconSize.Menu, "");
iconInfo = sw.RenderIcon(Gtk.Stock.DialogInfo, Gtk.IconSize.Menu, "");
// control.Add1 (sw);
//
// outputView = new LogView ();
// control.Add2 (outputView);
Control.ShowAll();
// control.SizeAllocated += HandleControlSizeAllocated;
// bool outputVisible = PropertyService.Get<bool> (outputViewVisiblePropertyName, false);
// if (outputVisible) {
// outputView.Visible = true;
// logBtn.Active = true;
// } else {
// outputView.Hide ();
// }
//
// sw.SizeAllocated += HandleSwSizeAllocated;
// control.FocusChain = new Gtk.Widget [] { sw };
}
public LitTreeView(Gtk.ITreeModel model)
{
sorter = new Gtk.TreeModelSort(model);
columnsIconSettings = new BibliographerSettings("apps.bibliographer.columns.icon");
columnsAuthorSettings = new BibliographerSettings("apps.bibliographer.columns.author");
columnsTitleSettings = new BibliographerSettings("apps.bibliographer.columns.title");
columnsYearSettings = new BibliographerSettings("apps.bibliographer.columns.year");
columnsJournalSettings = new BibliographerSettings("apps.bibliographer.columns.journal");
columnsBibtexKeySettings = new BibliographerSettings("apps.bibliographer.columns.bibtexkey");
columnsVolumeSettings = new BibliographerSettings("apps.bibliographer.columns.volume");
columnsPagesSettings = new BibliographerSettings("apps.bibliographer.columns.pages");
Model = sorter;
Gtk.CellRendererPixbuf columnIconRenderer;
Gtk.CellRendererText columnAuthorRenderer;
Gtk.CellRendererText columnTitleRenderer;
Gtk.CellRendererText columnYearRenderer;
Gtk.CellRendererText columnJournalRenderer;
Gtk.CellRendererText columnBibtexKeyRenderer;
Gtk.CellRendererText columnVolumeRenderer;
Gtk.CellRendererText columnPagesRenderer;
columnIconRenderer = new Gtk.CellRendererPixbuf();
columnAuthorRenderer = new Gtk.CellRendererText();
columnTitleRenderer = new Gtk.CellRendererText();
columnYearRenderer = new Gtk.CellRendererText();
columnJournalRenderer = new Gtk.CellRendererText();
columnBibtexKeyRenderer = new Gtk.CellRendererText();
columnVolumeRenderer = new Gtk.CellRendererText();
columnPagesRenderer = new Gtk.CellRendererText();
AppendColumn("Icon", columnIconRenderer, "image");
AppendColumn("Author", columnAuthorRenderer, "text");
AppendColumn("Title", columnTitleRenderer, "text");
AppendColumn("Year", columnYearRenderer, "text");
AppendColumn("Journal", columnJournalRenderer, "text");
AppendColumn("Bibtex Key", columnBibtexKeyRenderer, "text");
AppendColumn("Volume", columnVolumeRenderer, "text");
AppendColumn("Pages", columnPagesRenderer, "text");
HeadersClickable = true;
var textDataFunc = new Gtk.TreeCellDataFunc(RenderColumnTextFromBibtexRecord);
var pixmapDataFunc = new Gtk.TreeCellDataFunc(RenderColumnPixbufFromBibtexRecord);
int idx = 0;
foreach (Gtk.TreeViewColumn column in Columns)
{
column.Expand = false;
column.Reorderable = true;
column.Resizable = true;
column.Clickable = true;
if (column.Title == "Icon")
{
column.FixedWidth = columnsIconSettings.GetInt("width");
column.Visible = columnsIconSettings.GetBoolean("visible");
column.SetCellDataFunc(column.Cells[0], pixmapDataFunc);
column.Sizing = Gtk.TreeViewColumnSizing.Fixed;
column.Resizable = false;
column.Reorderable = false;
column.Clickable = false;
column.MinWidth = 20;
}
else if (column.Title == "Author")
{
column.FixedWidth = columnsAuthorSettings.GetInt("width");
column.Visible = columnsAuthorSettings.GetBoolean("visible");
column.SetCellDataFunc(column.Cells[0], textDataFunc);
column.SortColumnId = 1;
sorter.SetSortFunc(1, StringCompareAuthor);
column.Clicked += OnColumnSort;
if (column != Columns[columnsAuthorSettings.GetInt("order") - 1])
{
MoveColumnAfter(column, Columns[columnsAuthorSettings.GetInt("order") - 1]);
}
}
else if (column.Title == "Title")
{
column.Expand = true;
column.FixedWidth = columnsTitleSettings.GetInt("width");
column.Visible = columnsTitleSettings.GetBoolean("visible");
column.SetCellDataFunc(column.Cells[0], textDataFunc);
column.SortColumnId = 2;
sorter.SetSortFunc(2, StringCompare);
column.Clicked += OnColumnSort;
if (column != Columns[columnsTitleSettings.GetInt("order") - 1])
{
MoveColumnAfter(column, Columns[columnsTitleSettings.GetInt("order") - 1]);
}
}
else if (column.Title == "Year")
{
column.FixedWidth = columnsYearSettings.GetInt("width");
column.Visible = columnsYearSettings.GetBoolean("visible");
column.SetCellDataFunc(column.Cells[0], textDataFunc);
column.SortColumnId = 3;
sorter.SetSortFunc(3, StringCompare);
column.Clicked += OnColumnSort;
if (column != Columns[columnsYearSettings.GetInt("order") - 1])
{
MoveColumnAfter(column, Columns[columnsYearSettings.GetInt("order") - 1]);
}
}
else if (column.Title == "Journal")
{
column.FixedWidth = columnsJournalSettings.GetInt("width");
column.Visible = columnsJournalSettings.GetBoolean("visible");
column.SetCellDataFunc(column.Cells[0], textDataFunc);
column.SortColumnId = 4;
sorter.SetSortFunc(4, StringCompare);
column.Clicked += OnColumnSort;
if (column != Columns[columnsJournalSettings.GetInt("order") - 1])
{
MoveColumnAfter(column, Columns[columnsJournalSettings.GetInt("order") - 1]);
}
}
else if (column.Title == "Bibtex Key")
{
column.FixedWidth = columnsBibtexKeySettings.GetInt("width");
column.Visible = columnsBibtexKeySettings.GetBoolean("visible");
column.SetCellDataFunc(column.Cells[0], textDataFunc);
column.SortColumnId = 5;
sorter.SetSortFunc(5, StringCompare);
column.Clicked += OnColumnSort;
if (column != Columns[columnsBibtexKeySettings.GetInt("order") - 1])
{
MoveColumnAfter(column, Columns[columnsBibtexKeySettings.GetInt("order") - 1]);
}
}
else if (column.Title == "Volume")
{
column.FixedWidth = columnsVolumeSettings.GetInt("width");
column.Visible = columnsVolumeSettings.GetBoolean("visible");
column.SetCellDataFunc(column.Cells[0], textDataFunc);
column.SortColumnId = 6;
sorter.SetSortFunc(6, StringCompare);
column.Clicked += OnColumnSort;
if (column != Columns[columnsVolumeSettings.GetInt("order") - 1])
{
MoveColumnAfter(column, Columns[columnsVolumeSettings.GetInt("order") - 1]);
}
}
else if (column.Title == "Pages")
{
column.FixedWidth = columnsPagesSettings.GetInt("width");
column.Visible = columnsPagesSettings.GetBoolean("visible");
column.SetCellDataFunc(column.Cells[0], textDataFunc);
column.SortColumnId = 7;
sorter.SetSortFunc(7, StringCompare);
column.Clicked += OnColumnSort;
if (column != Columns[columnsPagesSettings.GetInt("order") - 1])
{
MoveColumnAfter(column, Columns[columnsPagesSettings.GetInt("order") - 1]);
}
}
idx++;
}
//RedrawColumns ();
// Callbacks for the LitTreeView
ColumnsChanged += OnColumnsChanged;
DragMotion += OnDragMotion;
RowActivated += OnRowActivated;
DragLeave += OnDragLeave;
Show();
}
public HmBackend()
{
initialized = false;
configured = false;
newTaskId = 0;
taskIters = new Dictionary<string, Gtk.TreeIter> ();
taskStore = new Gtk.TreeStore (typeof (ITask));
taskLock = new object ();
sortedTasksModel = new Gtk.TreeModelSort (taskStore);
sortedTasksModel.SetSortFunc (0, new Gtk.TreeIterCompareFunc (CompareTasksSortFunc));
sortedTasksModel.SetSortColumnId (0, Gtk.SortType.Ascending);
categoryListStore = new Gtk.ListStore (typeof (ICategory));
sortedCategoriesModel = new Gtk.TreeModelSort (categoryListStore);
sortedCategoriesModel.SetSortFunc (0, new Gtk.TreeIterCompareFunc (CompareCategorySortFunc));
sortedCategoriesModel.SetSortColumnId (0, Gtk.SortType.Ascending);
runRefreshEvent = new AutoResetEvent(false);
runningRefreshThread = false;
}
static T GetObjectFromTreePath(Gtk.TreeModelSort modelSort, Gtk.TreePath path)
{
Gtk.TreeIter iter;
modelSort.GetIter(out iter, path);
return(GetObjectFromTreeIter(modelSort, iter));
}
private void UpdateModel()
{
// Create a list store with all the check information
checkPropsList = new Gtk.ListStore (typeof(CheckClass), typeof(string));
// Create a list with all checks objects
checkList = DataManager.GetChecks ();
// Add all checks and customer name to the list store
foreach (CheckClass check in checkList) {
string name = (DAL.DataManager.GetCustomer (check.CustomerID)).Name;
checkPropsList.AppendValues (check, name);
}
// Add filter for searching
filter = new Gtk.TreeModelFilter (checkPropsList, null);
filter.VisibleFunc = new Gtk.TreeModelFilterVisibleFunc (FilterTree);
// Configure sorter and the sort funcions
sorter = new Gtk.TreeModelSort (filter);
sorter.SetSortFunc (0, CompareCustomerIDFunc);
sorter.SetSortFunc (1, CompareCustomerNameFunc);
sorter.SetSortFunc (2, CompareCheckNumberFunc);
sorter.SetSortFunc (3, CompareBankNumberFunc);
sorter.SetSortFunc (4, CompareBranchNumberFunc);
sorter.SetSortFunc (5, CompareSerialFunc);
sorter.SetSortFunc (6, CompareDueDateFunc);
sorter.SetSortFunc (7, CompareValueFunc);
// Set the treeview model
checktableview.Model = sorter;
}
