/// <summary>Refreshes the entire tree from the specified descriptions.</summary>
/// <param name="nodeDescriptions">The nodes descriptions.</param>
public void Refresh(NodeDescriptionArgs nodeDescriptions)
{
// Record which rows are currently expanded.
// We can't directly use a TreePath to an outdated TreeModel/TreeView, so we store the path as a string, and
// then parse that into a new TreePath after the model is reassembled. This assumes that the structure of the
// tree view/model does not change when RefreshNode() is called (e.g. it still has the same number of rows/columns).
List <string> expandedRows = new List <string>();
treeview1.MapExpandedRows(new TreeViewMappingFunc((tree, path) =>
{
expandedRows.Add(path.ToString());
}));
treemodel.Clear();
TreeIter iter = treemodel.AppendNode();
RefreshNode(iter, nodeDescriptions);
treeview1.ShowAll();
treeview1.ExpandRow(new TreePath("0"), false);
// Expand all rows which were previously expanded by the user.
try
{
expandedRows.ForEach(row => treeview1.ExpandRow(new TreePath(row), false));
}
catch
{
}
}
private TreeStore populateTreeStoreFromSession()
{
TreeStore ts = new TreeStore(typeof(string), typeof(string));
TreeIter iter;
TreeIter parent = ts.AppendNode();
iter = parent;
ts.SetValues(iter, "Nanoc", "Human, male");
iter = ts.AppendNode(iter);
ts.SetValues(iter, "Abilities", "");
ts.AppendValues(iter, "Charisma", "0");
ts.AppendValues(iter, "Dexterity", "+1");
ts.AppendValues(iter, "Intelligence", "0");
ts.AppendValues(iter, "Power", "0");
ts.AppendValues(iter, "Perception", "+1");
ts.AppendValues(iter, "Strength", "+4");
ts.AppendValues(iter, "Stamina", "+2");
ts.AppendValues(iter, "Willpower", "+1");
iter = ts.AppendNode(parent);
ts.SetValues(iter, "Experience", "");
ts.AppendValues(iter, "Level", "1");
ts.AppendValues(iter, "Barbarian", "230");
iter = ts.AppendNode(parent);
ts.SetValues(iter, "Adventures", "");
return(ts);
}
/// <summary>Refreshes the entire tree from the specified descriptions.</summary>
/// <param name="nodeDescriptions">The nodes descriptions.</param>
public void Refresh(TreeViewNode nodeDescriptions)
{
treemodel.Clear();
TreeIter iter = treemodel.AppendNode();
RefreshNode(iter, nodeDescriptions);
treeview1.ShowAll();
treeview1.ExpandRow(new TreePath("0"), false);
}
// insert tag into the correct place in the tree, with parent. return the new TagIter in iter.
TreeIter InsertInOrder(TreeIter parent, bool is_root, Tag tag)
{
TreeStore store = Model as TreeStore;
TreeIter iter;
Tag compare;
bool valid;
if (is_root)
{
valid = store.GetIterFirst(out iter);
}
else
{
valid = store.IterChildren(out iter, parent);
}
while (valid)
{
//I have no desire to figure out a more performant sort over this...
GLib.Value value = new GLib.Value();
store.GetValue(iter, IdColumn, ref value);
compare = tag_store.Get((uint)value);
if (compare.CompareTo(tag) > 0)
{
iter = store.InsertNodeBefore(iter);
store.SetValue(iter, IdColumn, tag.Id);
store.SetValue(iter, NameColumn, tag.Name);
if (!is_root)
{
ExpandRow(Model.GetPath(parent), false);
}
return(iter);
}
valid = store.IterNext(ref iter);
}
if (is_root)
{
iter = store.AppendNode();
}
else
{
iter = store.AppendNode(parent);
ExpandRow(Model.GetPath(parent), false);
}
store.SetValue(iter, IdColumn, tag.Id);
store.SetValue(iter, NameColumn, tag.Name);
return(iter);
}
void AppendValue(TreeIter parent, string name, ObjectValue val)
{
TreeIter it;
if (parent.Equals(TreeIter.Zero))
{
it = store.AppendNode();
}
else
{
it = store.AppendNode(parent);
}
SetValues(parent, it, name, val);
RegisterValue(val, it);
}
/// <summary>Adds a child node.</summary>
/// <param name="parentNodePath">The node path.</param>
/// <param name="nodeDescription">The node description.</param>
/// <param name="position">The position.</param>
public void AddChild(string parentNodePath, TreeViewNode nodeDescription, int position = -1)
{
if (FindNode(parentNodePath, out TreeIter node))
{
TreeIter iter;
if (position == -1)
{
iter = treemodel.AppendNode(node);
}
else
{
iter = treemodel.InsertNode(node, position);
}
RefreshNode(iter, nodeDescription);
treeview1.ExpandToPath(treemodel.GetPath(iter));
}
}
private void FillTreeView()
{
_treeStore.Clear();
var versionControl = projectCollection.GetService <RepositoryService>();
var items = versionControl.QueryItems(this._currentWorkspace, new ItemSpec(VersionControlPath.RootFolder, RecursionType.Full), VersionSpec.Latest, DeletedState.NonDeleted, ItemType.Folder, false);
var root = ItemSetToHierarchItemConverter.Convert(items);
var node = _treeStore.AppendNode();
_treeStore.SetValues(node, root.Item, GetRepositoryImage(), root.Name);
AddChilds(node, root.Children);
TreeIter firstNode;
if (_treeStore.GetIterFirst(out firstNode))
{
_treeView.ExpandRow(_treeStore.GetPath(firstNode), false);
_treeView.Selection.SelectIter(firstNode);
}
_treeView.Model = _treeStore;
}
public void BindTask()
{
fTaskStore.Clear();
var passedState = ConfigurationManager.AppSettings["passed_state"];
try
{
foreach (DataRow row in TaskSource.Tables["Task"].Rows)
{
var actorName = ActorSource.Tables["Actor"].Select("ID = " + (int)row["ActorID"])[0]["Name"];
var stateName = string.Empty;
if (StateSource.Tables["TaskState"].Select("ID = " + (int)row["StateID"]).Length > 0)
{
stateName = (string)StateSource.Tables["TaskState"].Select("ID = " + (int)row["StateID"])[0]["Name"];
}
if (passedState.Split(';').Select(s => s.ToLower()).Contains(stateName.ToLower()))
{
continue;
}
if (!string.IsNullOrEmpty(searchTask))
{
string text = string.Join("", row["Id"], row["Description"], row["StartTime"], actorName, stateName);
if (!text.ToLower().Contains(searchTask.ToLower()))
{
continue;
}
}
var itemNode = fTaskStore.AppendNode();
fTaskStore.SetValue(itemNode, 0, row["Id"]);
fTaskStore.SetValue(itemNode, 1, stateName);
fTaskStore.SetValue(itemNode, 2, ((DateTime)row["StartTime"]).ToShortDateString());
fTaskStore.SetValue(itemNode, 3, ((DateTime)row["EndTime"]).ToShortDateString());
fTaskStore.SetValue(itemNode, 4, actorName);
fTaskStore.SetValue(itemNode, 5, row["Priority"]);
fTaskStore.SetValue(itemNode, 6, row["Description"]);
}
}
catch (Exception ex)
{
var m = ex.Message;
//todo: fix ui exception
}
}
int FillChildOperation(IDeleteInfo currentDeletion, Operation parentOperation, TreeIter parentIter, EntityDTO masterEntity)
{
TreeIter DeleteIter, ClearIter, RemoveIter;
int Totalcount = 0;
int DelCount = 0;
int ClearCount = 0;
int RemoveCount = 0;
EntityDTO secondEntity = null;
var secondInfo = CalculateSecondInfo(currentDeletion, masterEntity);
if (!currentDeletion.HasDependences && !(secondInfo == null || secondInfo.HasDependences))
{
return(0);
}
CheckDlg.SetOperationName(String.Format("Проверка ссылок на: {0}", masterEntity.Title));
logger.Debug(String.Format("Проверка ссылок на: {0}", masterEntity.Title));
if (CheckDlg.IsCanceled)
{
return(0);
}
if (secondInfo != null)
{
secondEntity = new EntityDTO {
ClassType = secondInfo.ObjectClass,
Entity = masterEntity.Entity,
Id = masterEntity.Id,
Title = masterEntity.Title
};
}
if (currentDeletion.DeleteItems.Count > 0 || (secondInfo != null && secondInfo.DeleteItems.Count > 0))
{
if (!ObjectsTreeStore.IterIsValid(parentIter))
{
DeleteIter = ObjectsTreeStore.AppendNode();
}
else
{
DeleteIter = ObjectsTreeStore.AppendNode(parentIter);
}
DelCount = FillDeleteItemsOperation(currentDeletion, parentOperation, DeleteIter, masterEntity, ref Totalcount);
if (secondInfo != null)
{
DelCount += FillDeleteItemsOperation(secondInfo, parentOperation, DeleteIter, secondEntity, ref Totalcount);
}
if (DelCount > 0)
{
ObjectsTreeStore.SetValues(DeleteIter, String.Format("Будет удалено ({0}/{1}) объектов:", DelCount, Totalcount));
}
else
{
ObjectsTreeStore.Remove(ref DeleteIter);
}
}
//TODO Сделать возможность журналирования очистки полей у объектов.
if (currentDeletion.ClearItems.Count > 0 || (secondInfo != null && secondInfo.ClearItems.Count > 0))
{
if (!ObjectsTreeStore.IterIsValid(parentIter))
{
ClearIter = ObjectsTreeStore.AppendNode();
}
else
{
ClearIter = ObjectsTreeStore.AppendNode(parentIter);
}
ClearCount = FillCleanItemsOperation(currentDeletion, parentOperation, ClearIter, masterEntity, ref Totalcount);
if (secondInfo != null)
{
ClearCount += FillDeleteItemsOperation(secondInfo, parentOperation, ClearIter, secondEntity, ref Totalcount);
}
if (ClearCount > 0)
{
ObjectsTreeStore.SetValues(ClearIter, RusNumber.FormatCase(ClearCount,
"Будет очищено ссылок у {0} объекта:",
"Будет очищено ссылок у {0} объектов:",
"Будет очищено ссылок у {0} объектов:"
));
}
else
{
ObjectsTreeStore.Remove(ref ClearIter);
}
}
if (currentDeletion.RemoveFromItems.Count > 0 || (secondInfo != null && secondInfo.RemoveFromItems.Count > 0))
{
if (!ObjectsTreeStore.IterIsValid(parentIter))
{
RemoveIter = ObjectsTreeStore.AppendNode();
}
else
{
RemoveIter = ObjectsTreeStore.AppendNode(parentIter);
}
RemoveCount = FillRemoveFromItemsOperation(currentDeletion, parentOperation, RemoveIter, masterEntity, ref Totalcount);
if (secondInfo != null)
{
RemoveCount += FillRemoveFromItemsOperation(secondInfo, parentOperation, RemoveIter, secondEntity, ref Totalcount);
}
if (RemoveCount > 0)
{
ObjectsTreeStore.SetValues(RemoveIter, RusNumber.FormatCase(RemoveCount,
"Будут очищены ссылки в коллекциях у {0} объекта:",
"Будут очищены ссылки в коллекциях у {0} объектов:",
"Будут очищены ссылки в коллекциях у {0} объектов:"));
}
else
{
ObjectsTreeStore.Remove(ref RemoveIter);
}
}
return(Totalcount);
}
public CoverageView(string fileName, ProgressBar status)
{
store = new TreeStore(typeof(string), typeof(string), typeof(string), typeof(string), typeof(object));
tree = new TreeView(store);
CellRendererText renderer = new CellRendererText();
CellRendererText coverageRenderer = new CellRendererText();
// LAME: Why is this property a float instead of a double ?
renderer.Xalign = 0.5f;
tree.AppendColumn("Classes", new CellRendererText(), "text", 0);
tree.AppendColumn("Lines Hit", renderer, "text", 1);
tree.AppendColumn("Lines Missed", renderer, "text", 2);
tree.AppendColumn("Coverage", coverageRenderer, "text", 3);
tree.GetColumn(0).Resizable = true;
tree.GetColumn(1).Alignment = 0.0f;
tree.GetColumn(1).Resizable = true;
tree.GetColumn(2).Alignment = 0.0f;
tree.GetColumn(2).Resizable = true;
tree.GetColumn(3).Alignment = 0.0f;
tree.GetColumn(3).Resizable = true;
tree.GetColumn(3).SetCellDataFunc(coverageRenderer, new TreeCellDataFunc(RenderCoverage));
tree.HeadersVisible = true;
model = new CoverageModel();
foreach (string filter in DEFAULT_FILTERS)
{
model.AddFilter(filter);
}
this.status = status;
model.Progress += Progress;
model.ReadFromFile(fileName);
TreeItem root = new TreeItem(store, null, model, "PROJECT");
Hashtable classes2 = model.Classes;
namespaces = new Hashtable();
string[] sorted_names = new string [classes2.Count];
classes2.Keys.CopyTo(sorted_names, 0);
Array.Sort(sorted_names);
Progress("Building tree", 0.95);
foreach (string name in sorted_names)
{
ClassCoverageItem klass = (ClassCoverageItem)classes2 [name];
if (klass.filtered)
{
continue;
}
string namespace2 = klass.name_space;
TreeItem nsItem = (TreeItem)namespaces [namespace2];
if (nsItem == null)
{
nsItem = new TreeItem(store, root, (CoverageItem)model.Namespaces [namespace2], namespace2);
// nsItem.SetPixmap (0, namespaceOpenPixmap);
namespaces [namespace2] = nsItem;
}
if (nsItem.model.filtered)
{
continue;
}
ClassItem classItem = new ClassItem(store, nsItem, klass, klass.name);
if (klass.ChildCount != 0)
{
TreeIter treeIter = store.AppendNode(classItem.iter);
store.SetValues(treeIter, "<loading>");
}
}
tree.ExpandRow(store.GetPath(root.Iter), false);
// it becomes very hard to navigate if everything is expanded
//foreach (string ns in namespaces.Keys)
// tree.ExpandRow (store.GetPath (((TreeItem)namespaces [ns]).Iter), false);
tree.RowExpanded += new RowExpandedHandler(OnRowExpanded);
tree.RowCollapsed += new RowCollapsedHandler(OnRowCollapsed);
tree.ButtonPressEvent += new ButtonPressEventHandler(OnButtonPress);
tree.Selection.Mode = SelectionMode.Single;
source_views = new Hashtable();
window_maps = new Hashtable();
Progress("Done", 1.0);
// LAME: Why doesn't widgets visible by default ???
tree.Show();
}
int FillObjects(string Table, TreeIter root, TableInfo.Params ParametersIn)
{
TreeIter DeleteIter, ClearIter, GroupIter, ItemIter;
int Totalcount = 0;
int DelCount = 0;
int ClearCount = 0;
int GroupCount;
DbCommand cmd;
DbDataReader rdr;
QSMain.CheckConnectionAlive();
logger.Debug("Поиск зависимостей для таблицы {0}", Table);
if (!QSMain.ProjectTables.ContainsKey(Table))
{
ErrorString = "Нет описания для таблицы " + Table;
logger.Error(ErrorString);
ErrorHappens = true;
return(0);
}
if (QSMain.ProjectTables[Table].DeleteItems.Count > 0)
{
if (!ObjectsTreeStore.IterIsValid(root))
{
DeleteIter = ObjectsTreeStore.AppendNode();
}
else
{
DeleteIter = ObjectsTreeStore.AppendNode(root);
}
foreach (KeyValuePair <string, TableInfo.DeleteDependenceItem> pair in QSMain.ProjectTables[Table].DeleteItems)
{
GroupCount = 0;
if (!QSMain.ProjectTables.ContainsKey(pair.Key))
{
ErrorString = String.Format("Зависимость удаления у таблицы {1} ссылается на таблицу {0} описания для которой нет.", pair.Key, Table);
logger.Error(ErrorString);
ErrorHappens = true;
return(0);
}
string sql = QSMain.ProjectTables[pair.Key].SqlSelect + pair.Value.sqlwhere;
cmd = QSMain.ConnectionDB.CreateCommand();
cmd.CommandText = sql;
AddParameters(cmd, pair.Value.SqlParam, ParametersIn);
rdr = cmd.ExecuteReader();
if (!rdr.HasRows)
{
rdr.Close();
continue;
}
GroupIter = ObjectsTreeStore.AppendNode(DeleteIter);
int IndexIntParam = 0;
int IndexStrParam = 0;
if (QSMain.ProjectTables[pair.Key].PrimaryKey.ParamInt != "")
{
IndexIntParam = rdr.GetOrdinal(QSMain.ProjectTables[pair.Key].PrimaryKey.ParamInt);
}
if (QSMain.ProjectTables[pair.Key].PrimaryKey.ParamStr != "")
{
IndexStrParam = rdr.GetOrdinal(QSMain.ProjectTables[pair.Key].PrimaryKey.ParamStr);
}
List <object[]> ReadedData = new List <object[]>();
while (rdr.Read())
{
object[] Fields = new object[rdr.FieldCount];
rdr.GetValues(Fields);
ReadedData.Add(Fields);
}
rdr.Close();
foreach (object[] row in ReadedData)
{
ItemIter = ObjectsTreeStore.AppendValues(GroupIter, String.Format(QSMain.ProjectTables[pair.Key].DisplayString, row));
if (QSMain.ProjectTables[pair.Key].DeleteItems.Count > 0 || QSMain.ProjectTables[pair.Key].ClearItems.Count > 0)
{
TableInfo.Params OutParam = new TableInfo.Params();
if (QSMain.ProjectTables[pair.Key].PrimaryKey.ParamInt != "")
{
OutParam.ParamInt = Convert.ToInt32(row[IndexIntParam]);
}
if (QSMain.ProjectTables[pair.Key].PrimaryKey.ParamStr != "")
{
OutParam.ParamStr = row[IndexStrParam].ToString();
}
Totalcount += FillObjects(pair.Key, ItemIter, OutParam);
}
GroupCount++;
Totalcount++;
DelCount++;
}
ObjectsTreeStore.SetValues(GroupIter, QSMain.ProjectTables[pair.Key].ObjectsName + "(" + GroupCount.ToString() + ")");
}
if (DelCount > 0)
{
ObjectsTreeStore.SetValues(DeleteIter, String.Format("Будет удалено ({0}/{1}) объектов:", DelCount, Totalcount));
}
else
{
ObjectsTreeStore.Remove(ref DeleteIter);
}
}
if (QSMain.ProjectTables[Table].ClearItems.Count > 0)
{
if (!ObjectsTreeStore.IterIsValid(root))
{
ClearIter = ObjectsTreeStore.AppendNode();
}
else
{
ClearIter = ObjectsTreeStore.AppendNode(root);
}
foreach (KeyValuePair <string, TableInfo.ClearDependenceItem> pair in QSMain.ProjectTables[Table].ClearItems)
{
GroupCount = 0;
if (!QSMain.ProjectTables.ContainsKey(pair.Key))
{
ErrorString = String.Format("Зависимость очистки у таблицы {1} ссылается на таблицу {0} описания для которой нет.", pair.Key, Table);
logger.Error(ErrorString);
ErrorHappens = true;
return(0);
}
string sql = QSMain.ProjectTables[pair.Key].SqlSelect + pair.Value.sqlwhere;
cmd = QSMain.ConnectionDB.CreateCommand();
cmd.CommandText = sql;
AddParameters(cmd, pair.Value.SqlParam, ParametersIn);
rdr = cmd.ExecuteReader();
if (!rdr.HasRows)
{
rdr.Close();
continue;
}
GroupIter = ObjectsTreeStore.AppendNode(ClearIter);
while (rdr.Read())
{
object[] Fields = new object[rdr.FieldCount];
rdr.GetValues(Fields);
ItemIter = ObjectsTreeStore.AppendValues(GroupIter, String.Format(QSMain.ProjectTables[pair.Key].DisplayString, Fields));
GroupCount++;
Totalcount++;
ClearCount++;
}
ObjectsTreeStore.SetValues(GroupIter, QSMain.ProjectTables[pair.Key].ObjectsName + "(" + GroupCount.ToString() + ")");
rdr.Close();
}
if (ClearCount > 0)
{
ObjectsTreeStore.SetValues(ClearIter, String.Format("Будет очищено ссылок у {0} объектов:", ClearCount));
}
else
{
ObjectsTreeStore.Remove(ref ClearIter);
}
}
return(Totalcount);
}
