/// <summary>
/// Updates the query search filter.
/// </summary>
/// <param name="filterText">The filter text.</param>
public void UpdateFilter(string filterText)
{
// SKip hidden actors
var actor = Actor;
if (actor != null && (actor.HideFlags & HideFlags.HideInHierarchy) != 0)
{
return;
}
bool noFilter = string.IsNullOrWhiteSpace(filterText);
_hasSearchFilter = !noFilter;
// Update itself
bool isThisVisible;
if (noFilter)
{
// Clear filter
_highlights?.Clear();
isThisVisible = true;
}
else
{
var text = Text;
if (QueryFilterHelper.Match(filterText, text, out QueryFilterHelper.Range[] ranges))
{
// Update highlights
if (_highlights == null)
{
_highlights = new List <Rectangle>(ranges.Length);
}
else
{
_highlights.Clear();
}
var font = Style.Current.FontSmall;
var textRect = TextRect;
for (int i = 0; i < ranges.Length; i++)
{
var start = font.GetCharPosition(text, ranges[i].StartIndex);
var end = font.GetCharPosition(text, ranges[i].EndIndex);
_highlights.Add(new Rectangle(start.X + textRect.X, textRect.Y, end.X - start.X, textRect.Height));
}
isThisVisible = true;
}
/// <summary>
/// Updates the filter.
/// </summary>
/// <param name="filterText">The filter text.</param>
public void UpdateFilter(string filterText)
{
Profiler.BeginEvent("VisjectCMGroup.UpdateFilter");
// Update items
bool isAnyVisible = false;
for (int i = 0; i < _children.Count; i++)
{
if (_children[i] is VisjectCMItem item)
{
item.UpdateFilter(filterText);
isAnyVisible |= item.Visible;
}
}
// Update header title
if (QueryFilterHelper.Match(filterText, HeaderText))
{
for (int i = 0; i < _children.Count; i++)
{
if (_children[i] is VisjectCMItem item)
{
item.Visible = true;
}
}
isAnyVisible = true;
}
// Update itself
if (isAnyVisible)
{
if (!string.IsNullOrEmpty(filterText))
{
Open(false);
}
Visible = true;
}
else
{
// Hide group if none of the items matched the filter
Visible = false;
}
Profiler.EndEvent();
}
/// <summary>
/// 执行查询记录
/// </summary>
/// <returns></returns>
public PageResult <T> ToPageList()
{
PageResult <T> result = new PageResult <T>();
QueryFilter filter = QueryFilterHelper.GetPageFilter(query, select, orderByClauseList, pager, unSelect);
List <T> list = new List <T>();
DbCommand dbCommand = null;
try
{
if (!filter.IsPage)
{
throw new Exception("分页查询未指定分页信息");
}
else
{
dbCommand = dbContext.DbProvider.GetQueryRecordsPageDbCommand <T>(filter, subTableArg);
}
dbCommand.Connection = dbContext.GetDbConnection();
DbDataReader dr = dbCommand.ExecuteReader();
DataTable dt = dbContext.ConvertDataReaderToDataTable(dr);
list = dt.ToList <T>();
int totalCount = 0;
DbCommand getRecCountDbCommand = dbContext.DbProvider.GetCountDbCommand <T>(filter, subTableArg);
getRecCountDbCommand.Connection = dbCommand.Connection;
object valueObj = getRecCountDbCommand.ExecuteScalar();
if (valueObj != null && valueObj != DBNull.Value)
{
totalCount = Convert.ToInt32(valueObj);
}
//分页查询 获取记录总数
result.Rows = list;
result.Total = totalCount;
filter.TotalCount = totalCount;
dbContext.CloseDbConnection(dbCommand);
}
catch (Exception ex)
{
dbContext.CloseDbConnection(dbCommand);
throw ex;
}
return(result);
}
private void BuildLinqFilter(UserEntityPermissionSet permissionSet)
{
permissionSet.QueryFilterPredicate = null;
var readPerms = permissionSet.ConditionalPermissions.Where(
p => p.RecordPermission.AccessTypes.IsSet(AccessType.Peek | AccessType.Read));
if (readPerms.Any(p => p.QueryPredicate == null)) // if any permission has no linq filter, it means all allowed through this permission
{
return;
}
var allFilters = readPerms.Where(p => p.QueryPredicate != null).Select(p => p.QueryPredicate).Distinct().ToList();
if (allFilters.Count == 0)
{
return;
}
permissionSet.QueryFilterPredicate = QueryFilterHelper.CombinePredicatesWithOR(allFilters);
}
protected override void BeginTileCore(BeginTileParameters parameters)
{
base.BeginTileCore(parameters);
for (var involvedTable = 0; involvedTable < InvolvedTables.Count; involvedTable++)
{
QueryFilterHelper filterHelper = GetQueryFilterHelper(involvedTable);
filterHelper.ForNetwork = true;
}
_pointsEnumerator = null; // points enumerator is valid only within same tile
_pointSearchEnvelope = null;
if (parameters.TileEnvelope != null)
{
_pointSearchEnvelope = GeometryFactory.Clone(parameters.TileEnvelope);
}
_pointSearchEnvelope?.Expand(SearchDistance, SearchDistance, asRatio: false);
}
private void UpdateItemsSearchFilter(ContentFolder folder, List <ContentItem> items, bool[] filters, string filterText)
{
for (int i = 0; i < folder.Children.Count; i++)
{
var child = folder.Children[i];
if (child is ContentFolder childFolder)
{
UpdateItemsSearchFilter(childFolder, items, filters, filterText);
}
else if (filters[(int)child.SearchFilter])
{
if (filters[(int)child.SearchFilter] && QueryFilterHelper.Match(filterText, child.ShortName))
{
items.Add(child);
}
}
}
}
protected int FindErrors([NotNull] IFeature feature,
[NotNull] IGeometry searchGeometry,
int tableIndex, int relatedTableIndex)
{
Assert.ArgumentNotNull(feature, nameof(feature));
Assert.ArgumentNotNull(searchGeometry, nameof(searchGeometry));
ITable relatedTable = InvolvedTables[relatedTableIndex];
// access through properties to allow lazy initialization:
ISpatialFilter relatedFilter = SpatialFilters[relatedTableIndex];
QueryFilterHelper relatedFilterHelper = FilterHelpers[relatedTableIndex];
relatedFilter.Geometry = searchGeometry;
var errorCount = 0;
var anyFound = false;
foreach (IRow relatedRow in Search(relatedTable,
relatedFilter,
relatedFilterHelper,
feature.Shape))
{
anyFound = true;
errorCount += FindErrors(feature, tableIndex,
relatedRow, relatedTableIndex);
}
if (!anyFound && _disjointIsError)
{
if (IsDisjoint(searchGeometry,
relatedTable, relatedTableIndex,
relatedFilterHelper,
feature.Shape))
{
errorCount += FindErrorsNoRelated(feature);
}
}
return(errorCount);
}
private void OnSearchBoxTextChanged()
{
// Skip events during setup or init stuff
if (IsLayoutLocked)
{
return;
}
var filterText = _searchBox.Text;
_groupSearch.LockChildrenRecursive();
_groupSearch.DisposeChildren();
foreach (var actorType in Editor.CodeEditing.Actors.Get())
{
var text = actorType.Name;
if (!QueryFilterHelper.Match(filterText, text, out QueryFilterHelper.Range[] ranges))
{
continue;
}
var item = _groupSearch.AddChild(CreateActorItem(CustomEditors.CustomEditorsUtil.GetPropertyNameUI(text), actorType));
item.TooltipText = Surface.SurfaceUtils.GetVisualScriptTypeDescription(actorType);
var highlights = new List <Rectangle>(ranges.Length);
var style = Style.Current;
var font = style.FontSmall;
var textRect = item.TextRect;
for (int i = 0; i < ranges.Length; i++)
{
var start = font.GetCharPosition(text, ranges[i].StartIndex);
var end = font.GetCharPosition(text, ranges[i].EndIndex);
highlights.Add(new Rectangle(start.X + textRect.X, textRect.Y, end.X - start.X, textRect.Height));
}
item.SetHighlights(highlights);
}
_groupSearch.UnlockChildrenRecursive();
PerformLayout();
PerformLayout();
}
/// <summary>
/// Updates the filter.
/// </summary>
/// <param name="filterText">The filter text.</param>
public void UpdateFilter(string filterText)
{
if (string.IsNullOrWhiteSpace(filterText))
{
// Clear filter
_highlights?.Clear();
Visible = true;
}
else
{
QueryFilterHelper.Range[] ranges;
if (QueryFilterHelper.Match(filterText, Name, out ranges))
{
// Update highlights
if (_highlights == null)
{
_highlights = new List <Rectangle>(ranges.Length);
}
else
{
_highlights.Clear();
}
var style = Style.Current;
var font = style.FontSmall;
for (int i = 0; i < ranges.Length; i++)
{
var start = font.GetCharPosition(Name, ranges[i].StartIndex);
var end = font.GetCharPosition(Name, ranges[i].EndIndex);
_highlights.Add(new Rectangle(start.X + 2, 0, end.X - start.X, Height));
}
Visible = true;
}
else
{
// Hide
_highlights?.Clear();
Visible = false;
}
}
}
/// <summary>
/// create a filter that gets the lines crossing the current row,
/// with the same attribute constraints as the table
/// </summary>
private void InitFilters()
{
_filters = new Dictionary <int, ISpatialFilter>();
_helpers = new Dictionary <int, QueryFilterHelper>();
bool caseSensitive = GetSqlCaseSensitivity();
foreach (int tableIndex in NonNetworkClassIndexList)
{
ITable nonNetworkClass = InvolvedTables[tableIndex];
ISpatialFilter filter = new SpatialFilterClass();
var helper = new QueryFilterHelper(nonNetworkClass,
GetConstraint(tableIndex),
caseSensitive);
ConfigureQueryFilter(tableIndex, filter);
esriGeometryType geometryType =
((IFeatureClass)nonNetworkClass).ShapeType;
switch (geometryType)
{
case esriGeometryType.esriGeometryPolyline:
filter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
break;
case esriGeometryType.esriGeometryPolygon:
filter.SpatialRel = esriSpatialRelEnum.esriSpatialRelTouches;
break;
default:
throw new NotImplementedException("Unhandled geometry type " +
geometryType);
}
_filters.Add(tableIndex, filter);
_helpers.Add(tableIndex, helper);
}
}
protected override int ExecuteCore(IRow row, int tableIndex)
{
Assert.ArgumentNotNull(row, nameof(row));
var feature = row as IFeature;
if (feature == null)
{
return(NoError);
}
IGeometry searchGeometry = GetSearchGeometry(feature, tableIndex);
if (searchGeometry == null || searchGeometry.IsEmpty)
{
return(NoError);
}
var errorCount = 0;
int startCompare = IgnoreUndirected && UsesSymmetricRelation
? tableIndex
: 0;
for (int searchTableIndex = startCompare;
searchTableIndex < TotalClassCount;
searchTableIndex++)
{
QueryFilterHelper filter = GetQueryFilterHelper(searchTableIndex);
filter.MinimumOID = IgnoreUndirected && UsesSymmetricRelation &&
tableIndex == searchTableIndex
? row.OID
: -1;
errorCount += FindErrors(feature, searchGeometry, tableIndex, searchTableIndex);
}
return(errorCount);
}
/// <summary>
/// Updates the query search filter.
/// </summary>
/// <param name="filterText">The filter text.</param>
public void UpdateFilter(string filterText)
{
bool noFilter = string.IsNullOrWhiteSpace(filterText);
// Update itself
bool isThisVisible;
if (noFilter)
{
// Clear filter
_highlights?.Clear();
isThisVisible = true;
}
else
{
var text = Text;
if (QueryFilterHelper.Match(filterText, text, out QueryFilterHelper.Range[] ranges))
{
// Update highlights
if (_highlights == null)
{
_highlights = new List <Rectangle>(ranges.Length);
}
else
{
_highlights.Clear();
}
var style = Style.Current;
var font = style.FontSmall;
var textRect = TextRect;
for (int i = 0; i < ranges.Length; i++)
{
var start = font.GetCharPosition(text, ranges[i].StartIndex);
var end = font.GetCharPosition(text, ranges[i].EndIndex);
_highlights.Add(new Rectangle(start.X + textRect.X, textRect.Y, end.X - start.X, textRect.Height));
}
isThisVisible = true;
}
/// <summary>
/// create a filter that gets the lines crossing the current row,
/// with the same attribute constraints as the table
/// </summary>
private void InitFilter()
{
IList <ISpatialFilter> spatialFilters;
IList <QueryFilterHelper> filterHelpers;
// there is one table and hence one filter (see constructor)
// Create copy of this filter and use it for quering crossing lines
CopyFilters(out spatialFilters, out filterHelpers);
_spatialFilter = spatialFilters[0];
_selectHelper = filterHelpers[0];
_spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelTouches;
if (_constraint != null)
{
_compareHelper = TableViewFactory.Create(
new[] { InvolvedTables[0], InvolvedTables[0] },
new[] { "L", "R" },
_constraint,
GetSqlCaseSensitivity());
}
}
private int FindErrors([NotNull] IRow row,
[NotNull] IPolyline polyline,
int tableIndex,
int searchTableIndex)
{
Assert.ArgumentNotNull(row, nameof(row));
Assert.ArgumentNotNull(polyline, nameof(polyline));
ITable searchTable = InvolvedTables[searchTableIndex];
ISpatialFilter searchFilter = _filter[searchTableIndex];
QueryFilterHelper searchFilterHelper = _helper[searchTableIndex];
int errorCount = 0;
int routeFieldIndex = _routeIdFieldIndexes[tableIndex];
object routeId = row.get_Value(routeFieldIndex);
if (routeId == null || routeId == DBNull.Value)
{
return(NoError);
}
foreach (IPoint endPoint in GetEndpoints(polyline, _fromPoint, _toPoint))
{
searchFilter.Geometry = endPoint;
foreach (IRow searchRow in Search(searchTable, searchFilter, searchFilterHelper))
{
errorCount += FindErrors(endPoint, row, routeId,
tableIndex, searchRow, searchTableIndex);
}
}
return(errorCount);
}
private bool IsDisjoint([NotNull] IGeometry shape,
[NotNull] ITable relatedTable, int relatedTableIndex,
[NotNull] QueryFilterHelper relatedFilterHelper,
[NotNull] IGeometry cacheShape)
{
ISpatialFilter intersectsFilter = _spatialFiltersIntersects[relatedTableIndex];
intersectsFilter.Geometry = shape;
foreach (
IRow row in
Search(relatedTable, intersectsFilter, relatedFilterHelper, cacheShape))
{
if (_msg.IsVerboseDebugEnabled)
{
_msg.VerboseDebugFormat("not disjoint (row found: {0})",
GdbObjectUtils.ToString(row));
}
return(false);
}
return(true);
}
private void OnSelectStringClicked(Button button)
{
var settings = GameSettings.Load <LocalizationSettings>();
if (settings?.LocalizedStringTables == null || settings.LocalizedStringTables.Length == 0)
{
MessageBox.Show("No valid localization settings setup.");
return;
}
Profiler.BeginEvent("LocalizedStringEditor.OnSelectStringClicked");
var allKeys = new HashSet <string>();
for (int i = 0; i < settings.LocalizedStringTables.Length; i++)
{
var table = settings.LocalizedStringTables[i];
if (table && !table.WaitForLoaded())
{
var entries = table.Entries;
foreach (var e in entries)
{
allKeys.Add(e.Key);
}
}
}
var allKeysSorted = allKeys.ToList();
allKeysSorted.Sort();
var value = _idElement?.TextBox.Text;
var menu = Utils.CreateSearchPopup(out var searchBox, out var tree);
var idToNode = new TreeNode[allKeysSorted.Count];
for (var i = 0; i < allKeysSorted.Count; i++)
{
var key = allKeysSorted[i];
var node = new TreeNode
{
Text = key,
TooltipText = Localization.GetString(key),
Parent = tree,
};
if (key == value)
{
tree.Select(node);
}
idToNode[i] = node;
}
tree.SelectedChanged += delegate(List <TreeNode> before, List <TreeNode> after)
{
if (after.Count == 1)
{
menu.Hide();
_idElement.TextBox.SetTextAsUser(after[0].Text);
}
};
searchBox.TextChanged += delegate
{
if (tree.IsLayoutLocked)
{
return;
}
tree.LockChildrenRecursive();
var query = searchBox.Text;
for (int i = 0; i < idToNode.Length; i++)
{
var node = idToNode[i];
node.Visible = string.IsNullOrWhiteSpace(query) || QueryFilterHelper.Match(query, node.Text);
}
tree.UnlockChildrenRecursive();
menu.PerformLayout();
};
menu.Show(button, new Vector2(0, button.Height));
Profiler.EndEvent();
}
/// <summary>
/// Updates the query search filter.
/// </summary>
/// <param name="filterText">The filter text.</param>
public void UpdateFilter(string filterText)
{
bool noFilter = string.IsNullOrWhiteSpace(filterText);
// Update itself
bool isThisVisible;
if (noFilter)
{
// Clear filter
_highlights?.Clear();
isThisVisible = true;
}
else
{
QueryFilterHelper.Range[] ranges;
var text = Text;
if (QueryFilterHelper.Match(filterText, text, out ranges))
{
// Update highlights
if (_highlights == null)
{
_highlights = new List <Rectangle>(ranges.Length);
}
else
{
_highlights.Clear();
}
var style = Style.Current;
var font = style.FontSmall;
var textRect = TextRect;
for (int i = 0; i < ranges.Length; i++)
{
var start = font.GetCharPosition(text, ranges[i].StartIndex);
var end = font.GetCharPosition(text, ranges[i].EndIndex);
_highlights.Add(new Rectangle(start.X + textRect.X, textRect.Y, end.X - start.X, textRect.Height));
}
isThisVisible = true;
}
else
{
// Hide
_highlights?.Clear();
isThisVisible = false;
}
}
// Update children
bool isAnyChildVisible = false;
for (int i = 0; i < _children.Count; i++)
{
if (_children[i] is ContentTreeNode child)
{
child.UpdateFilter(filterText);
isAnyChildVisible |= child.Visible;
}
}
bool isExpanded = isAnyChildVisible;
if (isExpanded)
{
Expand(true);
}
else
{
Collapse(true);
}
Visible = isThisVisible | isAnyChildVisible;
}
private int CheckRows([NotNull] IList <NetElement> connectedRows,
bool ignoreLoopEndpoints)
{
IRow lineFeature1;
IRow lineFeature2;
if (!IsPseudoNode(connectedRows, ignoreLoopEndpoints,
out lineFeature1, out lineFeature2))
{
return(NoError);
}
Assert.NotNull(lineFeature1, "lineFeature1");
Assert.NotNull(lineFeature2, "lineFeature2");
//compare fields
Dictionary <int, esriFieldType> compareFields =
GetFieldIndexesToCompare(lineFeature1.Table);
foreach (KeyValuePair <int, esriFieldType> pair in compareFields)
{
int fieldIndex = pair.Key;
if (pair.Value == esriFieldType.esriFieldTypeGeometry)
{
// Do not compare the geometries by default
continue;
}
if (!Equals(lineFeature1.Value[fieldIndex],
lineFeature2.Value[fieldIndex]))
{
// one of the relevant fields has a different value --> pseudo node is allowed
return(NoError);
}
}
// Check if point lies on NON network feature
IPoint netPoint = connectedRows[0].NetPoint;
foreach (int nonNetworkClassIndex in NonNetworkClassIndexList)
{
ISpatialFilter relatedFilter = Filters[nonNetworkClassIndex];
relatedFilter.Geometry = netPoint;
QueryFilterHelper relatedFilterHelper = Helpers[nonNetworkClassIndex];
IEnumerable <IRow> searchResult = Search(InvolvedTables[nonNetworkClassIndex],
relatedFilter,
relatedFilterHelper);
if (searchResult.Any())
{
// Point lies on NON network feature --> the pseudo node is allowed
return(NoError);
}
}
return(ReportError("Pseudo Node", netPoint,
Codes[Code.PseudoNode],
TestUtils.GetShapeFieldName(lineFeature1),
lineFeature1, lineFeature2));
}
public void TestMatching()
{
// Simple matching
Assert.IsFalse(QueryFilterHelper.Match("text", "txt"));
Assert.IsFalse(QueryFilterHelper.Match("text", "txt txt"));
Assert.IsFalse(QueryFilterHelper.Match("text", "txttxt"));
Assert.IsTrue(QueryFilterHelper.Match("text", "text"));
Assert.IsTrue(QueryFilterHelper.Match("text", "ss text"));
Assert.IsTrue(QueryFilterHelper.Match("text", "text1"));
Assert.IsTrue(QueryFilterHelper.Match("text", "text 1"));
Assert.IsTrue(QueryFilterHelper.Match("text", "1text1"));
Assert.IsTrue(QueryFilterHelper.Match("text", "text text"));
// Exact matching
QueryFilterHelper.Range[] range;
Assert.IsTrue(QueryFilterHelper.Match("text", "text", out range));
Assert.AreEqual(1, range.Length);
Assert.AreEqual(new QueryFilterHelper.Range(0, 4), range[0]);
//
Assert.IsTrue(QueryFilterHelper.Match("text", "text text", out range));
Assert.AreEqual(2, range.Length);
Assert.AreEqual(new QueryFilterHelper.Range(0, 4), range[0]);
Assert.AreEqual(new QueryFilterHelper.Range(5, 4), range[1]);
//
Assert.IsTrue(QueryFilterHelper.Match("bool", "is it bool or boolean, boolish bol", out range));
Assert.AreEqual(3, range.Length);
Assert.AreEqual(new QueryFilterHelper.Range(6, 4), range[0]);
Assert.AreEqual(new QueryFilterHelper.Range(14, 4), range[1]);
Assert.AreEqual(new QueryFilterHelper.Range(23, 4), range[2]);
//
Assert.IsTrue(QueryFilterHelper.Match("boolean", "is it bool or boolean, boolish bol", out range));
Assert.AreEqual(1, range.Length);
Assert.AreEqual(new QueryFilterHelper.Range(14, 7), range[0]);
//
Assert.IsTrue(QueryFilterHelper.Match("boolean (0)", "is it bool or boolean (0)", out range));
Assert.AreEqual(1, range.Length);
Assert.AreEqual(new QueryFilterHelper.Range(14, 11), range[0]);
// More for searching in scene graph examples
Assert.IsFalse(QueryFilterHelper.Match("actor", "acctor", out range));
//
Assert.IsTrue(QueryFilterHelper.Match("actor", "actor (0)", out range));
Assert.AreEqual(1, range.Length);
Assert.AreEqual(new QueryFilterHelper.Range(0, 5), range[0]);
//
Assert.IsTrue(QueryFilterHelper.Match("actor ", "actor (0)", out range));
Assert.AreEqual(1, range.Length);
Assert.AreEqual(new QueryFilterHelper.Range(0, 6), range[0]);
//
Assert.IsTrue(QueryFilterHelper.Match("actor (0)", "actor (0) more", out range));
Assert.AreEqual(1, range.Length);
Assert.AreEqual(new QueryFilterHelper.Range(0, 9), range[0]);
//
Assert.IsFalse(QueryFilterHelper.Match("actor (0)", "actor (1) more", out range));
// Even more
Assert.IsTrue(QueryFilterHelper.Match("magic", "Are you looking forTheMagic?", out range));
Assert.AreEqual(1, range.Length);
Assert.AreEqual(new QueryFilterHelper.Range(22, 5), range[0]);
//
Assert.IsTrue(QueryFilterHelper.Match("magic", "black Magical stuff", out range));
Assert.AreEqual(1, range.Length);
Assert.AreEqual(new QueryFilterHelper.Range(6, 5), range[0]);
// Sth more tricky
Assert.IsTrue(QueryFilterHelper.Match("magic ma", "magic magic magic", out range));
Assert.AreEqual(1, range.Length);
Assert.AreEqual(new QueryFilterHelper.Range(0, 8), range[0]);
}
/// <summary>
/// Updates the query search filter.
/// </summary>
/// <param name="filterText">The filter text.</param>
public void UpdateFilter(string filterText)
{
// SKip hidden actors
var actor = Actor;
if (actor != null && (actor.HideFlags & HideFlags.HideInHierarchy) != 0)
{
return;
}
bool noFilter = string.IsNullOrWhiteSpace(filterText);
_hasSearchFilter = !noFilter;
// Update itself
bool isThisVisible;
if (noFilter)
{
// Clear filter
_highlights?.Clear();
isThisVisible = true;
}
else
{
QueryFilterHelper.Range[] ranges;
var text = Text;
if (QueryFilterHelper.Match(filterText, text, out ranges))
{
// Update highlights
if (_highlights == null)
{
_highlights = new List <Rectangle>(ranges.Length);
}
else
{
_highlights.Clear();
}
var font = Style.Current.FontSmall;
var textRect = TextRect;
for (int i = 0; i < ranges.Length; i++)
{
var start = font.GetCharPosition(text, ranges[i].StartIndex);
var end = font.GetCharPosition(text, ranges[i].EndIndex);
_highlights.Add(new Rectangle(start.X + textRect.X, textRect.Y, end.X - start.X, textRect.Height));
}
isThisVisible = true;
}
else
{
// Hide
_highlights?.Clear();
isThisVisible = false;
}
}
// Update children
bool isAnyChildVisible = false;
for (int i = 0; i < _children.Count; i++)
{
if (_children[i] is ActorTreeNode child)
{
child.UpdateFilter(filterText);
isAnyChildVisible |= child.Visible;
}
}
bool isExpanded = isAnyChildVisible;
// Restore cached state on query filter clear
if (noFilter && actor != null)
{
var id = actor.ID;
isExpanded = Editor.Instance.ProjectCache.IsExpandedActor(ref id);
}
if (isExpanded)
{
Expand(true);
}
else
{
Collapse(true);
}
Visible = isThisVisible | isAnyChildVisible;
}
private int CheckTable([NotNull] IFeature feature,
[NotNull] IFeatureClass referenceClass,
int referenceClassIndex)
{
GeometryComponent geometryComponent =
GetGeometryComponent(referenceClassIndex);
IValidRelationConstraint validConstraint =
GetValidRelationConstraint(referenceClassIndex);
if (_pointTemplate == null)
{
_pointTemplate = new PointClass();
}
var errorCount = 0;
foreach (IPoint point in GetNodes(feature.Shape, _pointTemplate))
{
ISpatialFilter filter = PrepareSpatialFilter(point, referenceClassIndex);
QueryFilterHelper helper = _helper[referenceClassIndex];
const int pointClassIndex = 0;
foreach (IRow referenceRow in Search((ITable)referenceClass,
filter, helper, point))
{
if (TestUtils.IsSameRow(feature, referenceRow))
{
continue;
}
var referenceFeature = (IFeature)referenceRow;
string conditionMessage;
if (validConstraint != null &&
validConstraint.HasConstraint &&
validConstraint.IsFulfilled(feature, pointClassIndex,
referenceFeature, referenceClassIndex,
out conditionMessage))
{
continue;
}
double standardDistance;
double?rightSideDistance;
double maxNeededDistance = GetMaxNeededDistance(
feature, referenceFeature, referenceClassIndex,
out standardDistance, out rightSideDistance);
maxNeededDistance = Math.Max(maxNeededDistance, _pointClassXyTolerance);
bool isWithinPolygon;
bool onRightSide;
double distance = GetDistance(point, referenceFeature, _nearPoint,
geometryComponent, maxNeededDistance,
out isWithinPolygon, out onRightSide);
if (AllowCoincidentPoints &&
IsSmallerThanXyTolerance(distance, referenceClassIndex))
{
continue;
}
if (distance > maxNeededDistance)
{
continue;
}
double minimumDistance = maxNeededDistance;
if (rightSideDistance.HasValue)
{
if (_referenceFlipConditions == null)
{
_referenceFlipConditions =
CreateFlipConditions(_referenceFlipExpressions);
}
bool flip = _referenceFlipConditions.Count > 0
? _referenceFlipConditions[
referenceClassIndex -
_firstReferenceClassIndex].IsFulfilled(
referenceFeature)
: false;
double useDistance = (onRightSide == flip)
? standardDistance
: rightSideDistance.Value;
if (distance > useDistance)
{
continue;
}
minimumDistance = useDistance;
}
errorCount += ReportError(feature, referenceFeature,
point, _nearPoint,
distance, minimumDistance,
isWithinPolygon, geometryComponent,
validConstraint);
}
}
return(errorCount);
}
/// <summary>
/// Updates the filter.
/// </summary>
/// <param name="filterText">The filter text.</param>
public void UpdateFilter(string filterText)
{
if (string.IsNullOrWhiteSpace(filterText))
{
// Clear filter
_highlights?.Clear();
Visible = true;
}
else
{
object[] data;
QueryFilterHelper.Range[] ranges;
if (QueryFilterHelper.Match(filterText, _archetype.Title, out ranges))
{
// Update highlights
if (_highlights == null)
{
_highlights = new List <Rectangle>(ranges.Length);
}
else
{
_highlights.Clear();
}
var style = Style.Current;
var font = style.FontSmall;
for (int i = 0; i < ranges.Length; i++)
{
var start = font.GetCharPosition(_archetype.Title, ranges[i].StartIndex);
var end = font.GetCharPosition(_archetype.Title, ranges[i].EndIndex);
_highlights.Add(new Rectangle(start.X + 2, 0, end.X - start.X, Height));
}
Visible = true;
}
else if (_archetype.AlternativeTitles?.Any(filterText.Equals) == true)
{
// Update highlights
if (_highlights == null)
{
_highlights = new List <Rectangle>(1);
}
else
{
_highlights.Clear();
}
var style = Style.Current;
var font = style.FontSmall;
var start = font.GetCharPosition(_archetype.Title, 0);
var end = font.GetCharPosition(_archetype.Title, _archetype.Title.Length - 1);
_highlights.Add(new Rectangle(start.X + 2, 0, end.X - start.X, Height));
Visible = true;
}
else if (NodeArchetype.TryParseText != null && NodeArchetype.TryParseText(filterText, out data))
{
// Update highlights
if (_highlights == null)
{
_highlights = new List <Rectangle>(1);
}
else
{
_highlights.Clear();
}
var style = Style.Current;
var font = style.FontSmall;
var start = font.GetCharPosition(_archetype.Title, 0);
var end = font.GetCharPosition(_archetype.Title, _archetype.Title.Length - 1);
_highlights.Add(new Rectangle(start.X + 2, 0, end.X - start.X, Height));
Visible = true;
Data = data;
}
else
{
// Hide
_highlights?.Clear();
Visible = false;
}
}
}
public IList <IRow> Search([NotNull] ITable table,
int tableIndex,
[NotNull] IQueryFilter queryFilter,
[NotNull] QueryFilterHelper filterHelper,
[CanBeNull] IGeometry cacheGeometry)
{
var spatialFilter = (ISpatialFilter)queryFilter;
IGeometry filterGeometry = spatialFilter.Geometry;
IList <IRow> result = new List <IRow>();
// TODO explain network queries
bool repeatCachedRows = filterHelper.ForNetwork;
// filterHelper.PointSearchOnlyWithinTile
if (filterHelper.ForNetwork)
{
var filterPoint = filterGeometry as IPoint;
if (filterPoint != null)
{
// search only if the point is within the tile box
// (or left/below of test run box)
double x;
double y;
filterPoint.QueryCoords(out x, out y);
Pnt tileMin = CurrentTileBox.Min;
Pnt tileMax = CurrentTileBox.Max;
IPnt testRunMin = _testRunBox.Min;
if ((x <= tileMin.X && x > testRunMin.X) || x > tileMax.X ||
(y <= tileMin.Y && y > testRunMin.Y) || y > tileMax.Y)
{
// outside of tile box, return empty list
return(result);
}
}
}
List <BoxTree <CachedRow> .TileEntry> searchList = SearchList(filterGeometry,
tableIndex);
if (searchList == null || searchList.Count == 0)
{
return(result);
}
var cacheGeometryOverlapsLeftTile = false;
var cacheGeometryOverlapsBottomTile = false;
if (!repeatCachedRows)
{
if (cacheGeometry != null)
{
cacheGeometry.QueryEnvelope(_envelopeTemplate);
}
else
{
filterGeometry.QueryEnvelope(_envelopeTemplate);
}
double xmin;
double ymin;
double xmax;
double ymax;
_envelopeTemplate.QueryCoords(out xmin, out ymin, out xmax, out ymax);
cacheGeometryOverlapsLeftTile = xmin <CurrentTileBox.Min.X &&
xmin> _testRunBox.Min.X;
// https://issuetracker02.eggits.net/browse/COM-85
// observed (CtLu):
// - filter geometry ymin = 220532.967
// - filter geometry ymax = 220557.78500
// - tile ymin = 220557.78534
// --> filter geometry is completely outside of tile boundaries!!!
// --> causes incorrect error in QaContainsOther
cacheGeometryOverlapsBottomTile = ymin <CurrentTileBox.Min.Y &&
ymin> _testRunBox.Min.Y;
}
IGeometryEngine engine = _container.GeometryEngine;
engine.SetSourceGeometry(filterGeometry);
IList <ContainerTest> tests = _testsPerTable[table];
int indexTest = tests.IndexOf(filterHelper.ContainerTest);
IList <BaseRow> ignoredRows = IgnoredRowsByTableAndTest[tableIndex][indexTest];
foreach (BoxTree <CachedRow> .TileEntry entry in searchList)
{
CachedRow cachedRow = Assert.NotNull(entry.Value, "cachedRow");
// This causes problems for QaIsCoveredByOther. However
// IsCoveredByOther is not a network test, but still requires cached features
// to be returned repeatedly
if (cacheGeometryOverlapsLeftTile && !cachedRow.IsFirstOccurrenceX)
{
// only if *not for network*:
// the filter geometry overlaps the left border of the tile, but
// not the left border of the test run box AND the cached row
// was already returned previously --> skip it
continue;
}
if (cacheGeometryOverlapsBottomTile && !cachedRow.IsFirstOccurrenceY)
{
// only if *not for network*:
// the filter geometry overlaps the bottom border of the tile, but
// not the bottom border of the test run box AND the cached row
// was already returned previously --> skip it
continue;
}
if (ignoredRows != null && ignoredRows.Contains(entry.Value))
{
continue;
}
IFeature targetFeature = cachedRow.Feature;
if (targetFeature.OID < filterHelper.MinimumOID)
{
continue;
}
engine.SetTargetGeometry(cachedRow.Geometry);
// Remark: if most of the rows fullfill helper.Check,
// it is better to check the geometric relation first
var matchesConstraint = false;
if (filterHelper.AttributeFirst)
{
if (!filterHelper.MatchesConstraint(targetFeature))
{
continue;
}
matchesConstraint = true;
}
if (engine.EvaluateRelation(spatialFilter))
{
if (matchesConstraint || filterHelper.MatchesConstraint(targetFeature))
{
result.Add(targetFeature);
}
}
}
return(result);
}
/// <summary>
/// Updates the filter.
/// </summary>
/// <param name="filterText">The filter text.</param>
public void UpdateFilter(string filterText)
{
_isStartsWithMatch = _isFullMatch = false;
if (filterText == null)
{
// Clear filter
_highlights?.Clear();
Visible = true;
}
else
{
if (QueryFilterHelper.Match(filterText, _archetype.Title, out var ranges))
{
// Update highlights
if (_highlights == null)
{
_highlights = new List <Rectangle>(ranges.Length);
}
else
{
_highlights.Clear();
}
var style = Style.Current;
var font = style.FontSmall;
for (int i = 0; i < ranges.Length; i++)
{
var start = font.GetCharPosition(_archetype.Title, ranges[i].StartIndex);
var end = font.GetCharPosition(_archetype.Title, ranges[i].EndIndex);
_highlights.Add(new Rectangle(start.X + 2, 0, end.X - start.X, Height));
if (ranges[i].StartIndex <= 0)
{
_isStartsWithMatch = true;
if (ranges[i].Length == _archetype.Title.Length)
{
_isFullMatch = true;
}
}
}
Visible = true;
}
else if (_archetype.AlternativeTitles?.Any(altTitle => string.Equals(filterText, altTitle, StringComparison.CurrentCultureIgnoreCase)) == true)
{
// Update highlights
if (_highlights == null)
{
_highlights = new List <Rectangle>(1);
}
else
{
_highlights.Clear();
}
var style = Style.Current;
var font = style.FontSmall;
var start = font.GetCharPosition(_archetype.Title, 0);
var end = font.GetCharPosition(_archetype.Title, _archetype.Title.Length - 1);
_highlights.Add(new Rectangle(start.X + 2, 0, end.X - start.X, Height));
Visible = true;
}
else if (NodeArchetype.TryParseText != null && NodeArchetype.TryParseText(filterText, out var data))
{
// Update highlights
if (_highlights == null)
{
_highlights = new List <Rectangle>(1);
}
else
{
_highlights.Clear();
}
var style = Style.Current;
var font = style.FontSmall;
var start = font.GetCharPosition(_archetype.Title, 0);
var end = font.GetCharPosition(_archetype.Title, _archetype.Title.Length - 1);
_highlights.Add(new Rectangle(start.X + 2, 0, end.X - start.X, Height));
Visible = true;
Data = data;
}
else
{
// Hide
_highlights?.Clear();
Visible = false;
}
}
}
private void CompleteJunctions()
{
foreach (KeyValuePair <RowKey, SegmentNeighbors> pair in ProcessedList)
{
RowKey key = pair.Key;
if (_conflictTables.ContainsKey(key.TableIndex))
{
continue;
}
// --> junction was not searched
var thisFeature = (IFeature)key.Row;
var thisCurve = (IGeometryCollection)thisFeature.Shape;
IIndexedSegments thisGeom =
IndexedSegmentUtils.GetIndexedGeometry(thisFeature, false);
Dictionary <int, SegmentPart> handledParts = new Dictionary <int, SegmentPart>();
foreach (KeyValuePair <SegmentPart, SegmentParts> segmentPair in pair.Value)
{
if (segmentPair.Value.Count == 0)
{
continue;
}
SegmentPart segment = segmentPair.Key;
if (handledParts.ContainsKey(segment.PartIndex))
{
continue;
}
int segmentsCount = thisGeom.GetPartSegmentCount(segment.PartIndex);
IEnvelope searchBox = thisCurve.Geometry[segment.PartIndex].Envelope;
double tolerance = UsedJunctionCoincidenceTolerance;
searchBox.Expand(tolerance, tolerance, asRatio: false);
Pnt start = thisGeom.GetSegment(segment.PartIndex, 0).GetStart(false);
IBox startBox = new Box(new Pnt2D(start.X - tolerance, start.Y - tolerance),
new Pnt2D(start.X + tolerance, start.Y + tolerance));
Pnt end = thisGeom.GetSegment(segment.PartIndex, segmentsCount - 1)
.GetEnd(false);
IBox endBox = new Box(new Pnt2D(end.X - tolerance, end.Y - tolerance),
new Pnt2D(end.X + tolerance, end.Y + tolerance));
foreach (KeyValuePair <int, IFeatureClass> topoPair in _topoTables)
{
int neighborTableIdx = topoPair.Key;
ISpatialFilter filter = _topoFilters[neighborTableIdx];
filter.Geometry = searchBox;
QueryFilterHelper helper = _topoHelpers[neighborTableIdx];
foreach (IRow neighborRow in Search((ITable)topoPair.Value, filter, helper)
)
{
if (neighborRow.OID == key.Row.OID &&
neighborTableIdx == key.TableIndex)
{
continue;
}
var neighborFeature = (IFeature)neighborRow;
IIndexedSegments neighborGeom =
IndexedSegmentUtils.GetIndexedGeometry(neighborFeature, false);
int connectedPart;
int connectedFraction;
if (IsConnected(neighborGeom, startBox, start,
JunctionCoincidenceToleranceSquare,
out connectedPart, out connectedFraction))
{
var jct =
new Junction(thisFeature, key.TableIndex, segment.PartIndex, 0,
neighborFeature, neighborTableIdx, connectedPart,
connectedFraction);
_junctions.Add(jct);
}
if (IsConnected(neighborGeom, endBox, end,
JunctionCoincidenceToleranceSquare,
out connectedPart, out connectedFraction))
{
var jct = new Junction(
thisFeature, key.TableIndex, segment.PartIndex, segmentsCount,
neighborFeature, neighborTableIdx, connectedPart,
connectedFraction);
_junctions.Add(jct);
}
if (ConnectionMode == ConnectionMode.VertexOnVertex)
{
for (int iSegment = 1; iSegment < segmentsCount; iSegment++)
{
Pnt vertex = thisGeom
.GetSegment(segment.PartIndex, iSegment)
.GetStart(false);
IBox vertexBox =
new Box(
new Pnt2D(vertex.X - tolerance, vertex.Y - tolerance),
new Pnt2D(vertex.X + tolerance, vertex.Y + tolerance));
if (IsConnected(neighborGeom, vertexBox, vertex,
JunctionCoincidenceToleranceSquare,
out connectedPart, out connectedFraction))
{
var jct = new Junction(
thisFeature, key.TableIndex, segment.PartIndex,
iSegment,
neighborFeature, neighborTableIdx, connectedPart,
connectedFraction);
_junctions.Add(jct);
}
}
}
}
}
handledParts.Add(segment.PartIndex, segment);
}
}
}
