/// <summary>
/// Populates the list of logs contained in the field notes file
/// </summary>
/// <param name="logs">
/// A list of cache logs<see cref="List<CacheLog>"/>
/// </param>
public void PopulateLogs(List <CacheLog> logs)
{
this.GdkWindow.Cursor = new Gdk.Cursor(Gdk.CursorType.Watch);
this.Sensitive = false;
OCMApp.UpdateGUIThread();
m_logList.Clear();
m_caches.Clear();
fieldNotesDescPane.Sensitive = false;
viewCacheButton.Sensitive = false;
deleteButton.Sensitive = false;
m_Logs = logs;
listSort.SetSortColumnId(0, SortType.Descending);
List <String> caches = new List <String> ();
foreach (CacheLog log in logs)
{
m_logList.AppendValues(log);
caches.Add(log.CacheCode);
}
List <Geocache> cachesInDb = m_Win.App.CacheStore.GetCachesByName(caches.ToArray());
foreach (Geocache cache in cachesInDb)
{
m_caches[cache.Name] = cache;
}
this.Sensitive = true;
this.GdkWindow.Cursor = new Gdk.Cursor(Gdk.CursorType.Arrow);
}
private void SetModel(TreeView tree, ListStore store)
{
TreeModelSort storeSort = new TreeModelSort(store);
storeSort.SetSortColumnId(descColumnNum, SortType.Ascending);
tree.Model = storeSort;
}
void InitTreeDebaters()
{
// Init Store
store = new ListStore(typeof(EditableDebater));
foreach (Debater d in Tournament.I.Debaters)
{
store.AppendValues(new EditableDebater(d));
}
// Setup Treeview
TreeModelFilter modelDebatersFilter = new TreeModelFilter(store, null);
modelDebatersFilter.VisibleFunc = FilterDebaters;
TreeModelSort modelDebatersSort = new TreeModelSort(modelDebatersFilter);
treeDebaters.Model = modelDebatersSort;
foreach (var col in columns)
{
SetupDebaterColumn(col.Key, col.Value.cellRendererType);
}
treeDebaters.HeadersClickable = true;
treeDebaters.Selection.Mode = SelectionMode.Multiple;
treeDebaters.Columns[editDebatersSettings.sortCol].SortIndicator = true;
treeDebaters.Columns[editDebatersSettings.sortCol].SortOrder = editDebatersSettings.sortOrder;
modelDebatersSort.SetSortColumnId(editDebatersSettings.sortCol,
editDebatersSettings.sortOrder);
UpdateDebatersInfo();
}
public LoadBackup() : base(Gtk.WindowType.Toplevel)
{
this.Build();
// determine available backups and append to store
string dir = System.IO.Path.GetDirectoryName(AppSettings.I.TournamentFile);
string backupPrefix = System.IO.Path.GetFileName(
System.IO.Path.ChangeExtension(AppSettings.I.TournamentFile, "backup"));
DateTime now = DateTime.Now;
store = new ListStore(typeof(string), typeof(TimeSpan));
foreach (string backupFile in Directory.GetFiles(dir, backupPrefix + "*"))
{
TimeSpan lastWriteAgo = now.Subtract(Directory.GetLastWriteTime(backupFile));
store.AppendValues(backupFile, lastWriteAgo);
}
// setup combobox
TreeModelSort sortedStore = new TreeModelSort(store);
sortedStore.SetSortFunc(0, delegate(TreeModel model, TreeIter a, TreeIter b) {
TimeSpan tsA = (TimeSpan)model.GetValue(a, 1);
TimeSpan tsB = (TimeSpan)model.GetValue(b, 1);
return(tsA.CompareTo(tsB));
});
sortedStore.SetSortColumnId(0, SortType.Ascending);
cbBackupFiles.Model = sortedStore;
CellRendererText cellFile = new CellRendererText();
cbBackupFiles.PackStart(cellFile, false);
cbBackupFiles.SetCellDataFunc(cellFile, delegate(CellLayout layout,
CellRenderer cell,
TreeModel model,
TreeIter iter) {
object o = model.GetValue(iter, 0);
if (o == null)
{
return;
}
(cell as CellRendererText).Text = System.IO.Path.GetFileName(o as string);
});
CellRendererText cellLastWrite = new CellRendererText();
cbBackupFiles.PackStart(cellLastWrite, false);
cbBackupFiles.SetCellDataFunc(cellLastWrite, delegate(CellLayout layout,
CellRenderer cell,
TreeModel model,
TreeIter iter) {
object o = model.GetValue(iter, 1);
if (o == null)
{
return;
}
CellRendererText cellText = cell as CellRendererText;
cellText.Xpad = 10;
cellText.Markup = "<i><small>" + FormatTimeSpan((TimeSpan)o) + " ago</small></i>";
});
}
Widget MonoDevelop.DesignerSupport.IOutlinedDocument.GetOutlineWidget()
{
if (outlineTreeView != null)
{
return(outlineTreeView);
}
outlineTreeStore = new TreeStore(typeof(object));
outlineTreeModelSort = new TreeModelSort(outlineTreeStore);
settings = ClassOutlineSettings.Load();
comparer = new ClassOutlineNodeComparer(GetAmbience(), settings, outlineTreeModelSort);
outlineTreeModelSort.SetSortFunc(0, comparer.CompareNodes);
outlineTreeModelSort.SetSortColumnId(0, SortType.Ascending);
outlineTreeView = new MonoDevelop.Ide.Gui.Components.PadTreeView(outlineTreeStore);
var pixRenderer = new CellRendererImage();
pixRenderer.Xpad = 0;
pixRenderer.Ypad = 0;
outlineTreeView.TextRenderer.Xpad = 0;
outlineTreeView.TextRenderer.Ypad = 0;
TreeViewColumn treeCol = new TreeViewColumn();
treeCol.PackStart(pixRenderer, false);
treeCol.SetCellDataFunc(pixRenderer, new TreeCellDataFunc(OutlineTreeIconFunc));
treeCol.PackStart(outlineTreeView.TextRenderer, true);
treeCol.SetCellDataFunc(outlineTreeView.TextRenderer, new TreeCellDataFunc(OutlineTreeTextFunc));
outlineTreeView.AppendColumn(treeCol);
outlineTreeView.HeadersVisible = false;
outlineTreeView.Selection.Changed += delegate {
JumpToDeclaration(false);
};
outlineTreeView.RowActivated += delegate {
JumpToDeclaration(true);
};
this.lastCU = Document.ParsedDocument;
outlineTreeView.Realized += delegate { RefillOutlineStore(); };
UpdateSorting();
var sw = new CompactScrolledWindow();
sw.Add(outlineTreeView);
sw.ShowAll();
return(sw);
}
protected void CreateFilterAndSort()
{
filter = new TreeModelFilter(store, null);
filter.VisibleFunc = new TreeModelFilterVisibleFunc(HandleFilter);
sort = new TreeModelSort(filter);
sort.SetSortFunc(COL_DATA, HandleSort);
sort.SetSortColumnId(COL_DATA, SortType.Ascending);
Model = sort;
}
public void Initialize(ExchangeViewModel vm)
{
viewModel = vm;
sorted = new TreeModelSort(store);
sorted.SetSortFunc(0, SortBySymbol);
sorted.SetSortFunc(4, SortByDistance);
sorted.SetSortColumnId(4, SortType.Ascending);
nodeview1.Model = sorted;
viewModel.MarketSummaries.CollectionChanged += MarketSummaries_CollectionChanged;
}
ListStore CreateStore()
{
store = new ListStore(typeof(string), typeof(Gdk.Pixbuf), typeof(Gdk.Pixbuf),
typeof(Gdk.Pixbuf), typeof(ProjectDescription));
filter = new Gtk.TreeModelFilter(store, null);
filter.VisibleFunc = new Gtk.TreeModelFilterVisibleFunc(FilterTree);
sort = new TreeModelSort(filter);
sort.SetSortFunc(COL_DISPLAY_NAME, SortFunc);
sort.SetSortColumnId(COL_DISPLAY_NAME, SortType.Ascending);
iconview.Model = sort;
treeview.Model = sort;
return(store);
}
void HandleEditPlayEvent(object sender, EventArgs e)
{
List <Player> players = SelectedPlay.Players.ToList();
Config.GUIToolkit.EditPlay(SelectedPlay, Project, true, true, true, true);
if (!Enumerable.SequenceEqual(players, SelectedPlay.Players))
{
Config.EventsBroker.EmitTeamTagsChanged();
}
Config.EventsBroker.EmitEventEdited(SelectedPlay);
modelSort.SetSortFunc(0, SortFunction);
modelSort.SetSortColumnId(0, SortType.Ascending);
}
public void Initialize(ExchangeViewModel vm)
{
viewModel = vm;
filter = new TreeModelFilter(store, null)
{
VisibleFunc = FilterSymbols
};
sorted = new TreeModelSort(filter);
sorted.SetSortFunc(0, SortBySymbol);
sorted.SetSortFunc(2, SortByPrice);
sorted.SetSortFunc(3, SortByPriceChangePercent);
sorted.SetSortFunc(4, SortByVolume);
sorted.SetSortColumnId(4, SortType.Ascending);
nodeview1.Model = sorted;
viewModel.MarketSummaries.CollectionChanged += MarketSummaries_CollectionChanged;
}
void HandleEditPlayEvent(object sender, EventArgs e)
{
LMTimelineEvent selectedEvent = SelectedPlay;
List <Player> players = selectedEvent.Players.ToList();
App.Current.EventsBroker.Publish <EditEventEvent> (
new EditEventEvent {
TimelineEvent = selectedEvent
});
if (!players.SequenceEqual(selectedEvent.Players))
{
App.Current.EventsBroker.Publish <TeamTagsChangedEvent> ();
}
modelSort.SetSortFunc(0, SortFunction);
modelSort.SetSortColumnId(0, SortType.Ascending);
}
public void SetCacheAndPoints(Geocache cache, List <Waypoint> points)
{
m_Cache = cache;
m_childPoints.Clear();
if (cache == null)
{
addButton.Sensitive = false;
grabButton.Sensitive = false;
return;
}
else
{
addButton.Sensitive = true;
grabButton.Sensitive = true;
}
m_ListSort.SetSortColumnId(1, SortType.Ascending);
m_childPoints.AppendValues(cache);
foreach (Waypoint pt in points)
{
m_childPoints.AppendValues(pt);
}
}
void SetSortColumn(int colNum)
{
TreeViewColumn col = treeDebaters.Columns[colNum];
col.SortIndicator = true;
int sortCol;
SortType sortOrder;
TreeModelSort modelSort = treeDebaters.Model as TreeModelSort;
modelSort.GetSortColumnId(out sortCol, out sortOrder);
if (sortCol == colNum)
{
if (sortOrder == SortType.Ascending)
{
col.SortOrder = SortType.Descending;
}
else
{
col.SortOrder = SortType.Ascending;
}
}
else
{
editDebatersSettings.lastSortCol = sortCol;
editDebatersSettings.lastSortOrder = treeDebaters.Columns[sortCol].SortOrder;
treeDebaters.Columns[sortCol].SortIndicator = false;
col.SortOrder = SortType.Descending;
}
editDebatersSettings.sortCol = colNum;
editDebatersSettings.sortOrder = col.SortOrder;
modelSort.SetSortColumnId(colNum, col.SortOrder);
}
void InitTreeDebaters()
{
// Init Store
store = new ListStore(typeof(EditableDebater));
foreach (Debater d in Tournament.I.Debaters)
{
store.AppendValues(new EditableDebater(d));
}
// Setup Treeview
TreeModelFilter modelDebatersFilter = new TreeModelFilter(store, null);
modelDebatersFilter.VisibleFunc = FilterDebaters;
TreeModelSort modelDebatersSort = new TreeModelSort(modelDebatersFilter);
treeDebaters.Model = modelDebatersSort;
SetupDebaterColumn("Name", CellRendererTextAdv.Type.Entry);
SetupDebaterColumn("Club", CellRendererTextAdv.Type.EntryWithCompletion);
SetupDebaterColumn("Age", CellRendererTextAdv.Type.Entry);
SetupDebaterColumn("Role", CellRendererTextAdv.Type.EntryWithCompletion);
SetupDebaterColumn("BlackList", CellRendererTextAdv.Type.DebaterPattern);
SetupDebaterColumn("WhiteList", CellRendererTextAdv.Type.DebaterPattern);
SetupDebaterColumn("ExtraInfo", CellRendererTextAdv.Type.Entry);
treeDebaters.HeadersClickable = true;
treeDebaters.Selection.Mode = SelectionMode.Multiple;
treeDebaters.Columns[editDebatersSettings.sortCol].SortIndicator = true;
treeDebaters.Columns[editDebatersSettings.sortCol].SortOrder = editDebatersSettings.sortOrder;
modelDebatersSort.SetSortColumnId(editDebatersSettings.sortCol,
editDebatersSettings.sortOrder);
UpdateDebatersInfo();
}
/// <summary>
/// Initializes a new instance of the <see cref="GamePage"/> class. The given package group and node tree are
/// wrapped by the page.
/// </summary>
/// <param name="packageGroup">The package group which the node tree maps to.</param>
/// <param name="nodeTree">The prebuilt node tree to display.</param>
/// <param name="version">The Warcraft version that the game page is contextually relevant for.</param>
/// <param name="alias">The name of the page.</param>
public GamePage(PackageGroup packageGroup, SerializedTree nodeTree, WarcraftVersion version, string alias)
{
this.Alias = alias;
_uiTaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
_treeModel = new FileTreeModel(nodeTree);
this.GameContext = new WarcraftGameContext(version, packageGroup, _treeModel);
_treeAlignment = new Alignment(0.5f, 0.5f, 1.0f, 1.0f)
{
TopPadding = 1,
BottomPadding = 1
};
_treeFilter = new TreeModelFilter(new TreeModelAdapter(_treeModel), null)
{
VisibleFunc = TreeModelVisibilityFunc
};
_treeSorter = new TreeModelSort(_treeFilter);
_treeSorter.SetSortFunc(0, SortGameTreeRow);
_treeSorter.SetSortColumnId(0, SortType.Descending);
this.Tree = new TreeView(_treeSorter)
{
HeadersVisible = true,
EnableTreeLines = true
};
var nodeIconRenderer = new CellRendererPixbuf
{
Xalign = 0.0f
};
var nodeNameRenderer = new CellRendererText
{
Xalign = 0.0f
};
var column = new TreeViewColumn
{
Title = "Data Files",
Spacing = 4
};
column.PackStart(nodeIconRenderer, false);
column.PackStart(nodeNameRenderer, false);
column.SetCellDataFunc(nodeIconRenderer, RenderNodeIcon);
column.SetCellDataFunc(nodeNameRenderer, RenderNodeName);
this.Tree.AppendColumn(column);
var sw = new ScrolledWindow
{
this.Tree
};
_treeAlignment.Add(sw);
this.Tree.RowActivated += OnRowActivated;
this.Tree.ButtonPressEvent += OnButtonPressed;
this.Tree.Selection.Changed += OnSelectionChanged;
_treeContextMenu = new Menu();
// Save item context button
_saveItem = new ImageMenuItem
{
UseStock = true,
Label = Stock.Save,
CanFocus = false,
TooltipText = "Save the currently selected item to disk.",
UseUnderline = true
};
_saveItem.Activated += OnSaveItem;
_treeContextMenu.Add(_saveItem);
// Export item context button
_exportItem = new ImageMenuItem("Export")
{
Image = new Image(Stock.Convert, IconSize.Button),
CanFocus = false,
TooltipText = "Exports the currently selected item to another format.",
};
_exportItem.Activated += OnExportItemRequested;
_treeContextMenu.Add(_exportItem);
// Open item context button
_openItem = new ImageMenuItem
{
UseStock = true,
Label = Stock.Open,
CanFocus = false,
TooltipText = "Open the currently selected item.",
UseUnderline = true
};
_openItem.Activated += OnOpenItem;
_treeContextMenu.Add(_openItem);
// Queue for export context button
_queueForExportItem = new ImageMenuItem("Queue for export")
{
Image = new Image(Stock.Convert, IconSize.Button),
CanFocus = false,
TooltipText = "Queues the currently selected item for batch export.",
};
_queueForExportItem.Activated += OnQueueForExportRequested;
_treeContextMenu.Add(_queueForExportItem);
// Separator
var separator = new SeparatorMenuItem();
_treeContextMenu.Add(separator);
// Copy path context button
_copyPathItem = new ImageMenuItem("Copy path")
{
Image = new Image(Stock.Copy, IconSize.Button),
CanFocus = false,
TooltipText = "Copy the path of the currently selected item.",
};
_copyPathItem.Activated += OnCopyPath;
_treeContextMenu.Add(_copyPathItem);
_treeAlignment.ShowAll();
}
void CellRendererEdited(CellRendererTextAdv sender,
string pathStr, string newText, int colNum)
{
TreeModelSort model = (TreeModelSort)treeDebaters.Model;
TreePath path = new TreePath(pathStr);
TreeIter iter = TreeIter.Zero;
model.GetIter(out iter, path);
EditableDebater d = (EditableDebater)model.GetValue(iter, 0);
try {
ColumnInfo prop = columns[treeDebaters.Columns[colNum].Title];
// This parses the given new string,
// and updates the data in store
prop.parseAndSet(d, newText);
// existing Debater: Update Data in (possibly) existing Rounds
// tries to keep data consisting, but there's no guarantee
// BlackList/WhiteList and ExtraInfo are not
// used in RoundDebater, so skip this by condition colNum<4
if (newDebaterPath == null && colNum < 4)
{
var rd = new EditableDebater(d);
var p = prop.get(d);
// Only simple Renaming of Role is possible if Rounds exist
if (colNum == 3 &&
Tournament.I.Rounds.Count > 0 &&
((d.Role.IsTeamMember != rd.Role.IsTeamMember) ||
(d.Role.IsJudge != rd.Role.IsJudge)))
{
MiscHelpers.ShowMessage(this, "Changing Role from Judge to TeamMember (or vice versa)" +
" is not possible since Rounds are already set.", MessageType.Error);
// reset to old role...
d.Role = rd.Role;
return;
}
// check if new TeamName is already present
if (colNum == 3 && d.Role.IsTeamMember)
{
int n = 0;
foreach (object[] row in store)
{
EditableDebater d_ = (EditableDebater)row[0];
if (!d.Equals(d_) && d_.Role.TeamName == d.Role.TeamName)
{
n++;
}
}
if (n == 3)
{
MiscHelpers.ShowMessage(this, "New TeamName is already present in three other Debaters.",
MessageType.Error);
// reset to old role...
d.Role = rd.Role;
return;
}
}
// check for duplicate
if (colNum < 3)
{
// need a temporary flag, throwing exceptions in delegates doesnt work...
// the following flag stuff isn't elegant, but it should work
bool flag = false;
model.Foreach((model_, _, iter_) => {
if (!iter.Equals(iter_))
{
EditableDebater d_ = (EditableDebater)model_.GetValue(iter_, 0);
if (d_.Equals(d))
{
// reset to old value...
prop.get(rd).Set(d);
flag = true;
return(true);
}
}
return(false);
});
if (flag)
{
throw new TargetInvocationException(new Exception("Debater exists."));
}
}
// keep data consistent in existing rounds
foreach (RoundData round in Tournament.I.Rounds)
{
foreach (RoomData room in round.Rooms)
{
foreach (RoundDebater rd_ in room.GetRoomMembers())
{
if (rd_ == null)
{
continue;
}
if (rd_.Equals(rd))
{
p.UnsafeSetRoundDebater(rd_);
}
if (rd_.Role.TeamName == rd.Role.TeamName)
{
rd_.Role.TeamName = d.Role.TeamName;
}
}
}
if (rd.Role.IsTeamMember)
{
foreach (TeamData team in round.AllTeams)
{
foreach (RoundDebater rd_ in team)
{
if (rd_.Equals(rd))
{
p.UnsafeSetRoundDebater(rd_);
}
if (rd_.Role.TeamName == rd.Role.TeamName)
{
rd_.Role.TeamName = d.Role.TeamName;
}
}
}
}
else if (rd.Role.IsJudge)
{
foreach (RoundDebater rd_ in round.AllJudges)
{
if (rd_.Equals(rd))
{
p.UnsafeSetRoundDebater(rd_);
}
}
}
}
// Renaming TeamName needs extra Handling
if (colNum == 3 && rd.Role.IsTeamMember && d.Role.IsTeamMember)
{
foreach (object[] row in store)
{
EditableDebater d_ = (EditableDebater)row[0];
if (d_.Role.TeamName == rd.Role.TeamName)
{
d_.Role.TeamName = d.Role.TeamName;
}
}
}
}
// newDebater is entered...
else if (newDebaterPath != null && colNum < 3)
{
// continue with entering data (goto next column)
// as idle so that cells are resized
GLib.Idle.Add(delegate {
treeDebaters.SetCursor(ConvertStorePathToModelPath(newDebaterPath),
treeDebaters.Columns[colNum + 1], true);
return(false);
});
}
else if (newDebaterPath != null)
{
// new Debater entered completely (at least all necessary data)
iter = TreeIter.Zero;
if (store.GetIter(out iter, newDebaterPath))
{
// as idle to prevent gtk critical (no idea why this happens)
GLib.Idle.Add(delegate {
store.Remove(ref iter);
newDebaterPath = null;
if (IsNotInStore(d))
{
store.AppendValues(d);
SaveDebaters();
}
else
{
MiscHelpers.ShowMessage(this, "Debater exists.", MessageType.Error);
}
UpdateDebatersInfo();
btnDebaterAdd.GrabFocus();
return(false);
});
}
}
// Gui stuff
treeDebaters.ColumnsAutosize();
// ugly method of resorting the TreeSortModel...
SortType st;
int sortColumn;
model.GetSortColumnId(out sortColumn,
out st);
if (st == SortType.Descending)
{
model.SetSortColumnId(sortColumn, SortType.Ascending);
model.SetSortColumnId(sortColumn, SortType.Descending);
}
else
{
model.SetSortColumnId(sortColumn, SortType.Descending);
model.SetSortColumnId(sortColumn, SortType.Ascending);
}
// save data from store if not adding new debater
if (newDebaterPath == null)
{
SaveDebaters();
}
}
catch (TargetInvocationException e) {
MessageDialog md = new MessageDialog(this, DialogFlags.Modal,
MessageType.Error,
ButtonsType.OkCancel,
e.InnerException.Message + ". Try again?");
md.DefaultResponse = ResponseType.Ok;
ResponseType r = (ResponseType)md.Run();
md.Destroy();
if (r == ResponseType.Ok)
{
// As Idle otherwise Editable isn't destroyed correctly
GLib.Idle.Add(delegate {
sender.TempEditString = newText;
treeDebaters.SetCursor(path, treeDebaters.Columns[colNum], true);
return(false);
});
}
else
{
if (newDebaterPath == null)
{
return;
}
iter = TreeIter.Zero;
if (store.GetIter(out iter, newDebaterPath))
{
// remove not finished new debater,
// with idle call,
// prevents Gtk critical filter model assertion.
GLib.Idle.Add(delegate {
newDebaterPath = null;
store.Remove(ref iter);
return(false);
});
}
}
}
}
