static void Encode(BinaryWriter writer, LayerFilter o)
{
EncodeID(writer, typeof(LayerFilter));
writer.Write(o.Target);
writer.Write(o.Range);
}
/// <summary>
/// 局部加载处理
/// </summary>
/// <param name="db"></param>
/// <returns></returns>
public static bool PartialOpenDatabase(Database db)
{
if (db == null)
{
return(false); //数据库未赋值，返回
}
//指定局部加载的范围
Point2d pt1 = Point2d.Origin;
Point2d pt2 = new Point2d(100, 100);
Point2dCollection pts = new Point2dCollection(2)
{
pt1, pt2
};
//创建局部加载范围过滤器
SpatialFilterDefinition filterDef = new SpatialFilterDefinition(pts, Vector3d.ZAxis, 0.0, 0.0, 0.0, true);
SpatialFilter sFilter = new SpatialFilter();
sFilter.Definition = filterDef;
//创建图层过滤器，只加载Circle和Line层
LayerFilter layerFilter = new LayerFilter();
layerFilter.Add("Circle");
layerFilter.Add("Line");
//对图形数据库应用局部加载
db.ApplyPartialOpenFilters(sFilter, layerFilter);
if (db.IsPartiallyOpened) //判断图形数据库是否已局部加载
{
db.CloseInput(true); //关闭文件输入
return(true); //局部加载成功
}
return(false); //局部加载失败
}
public void AddNewFilter()
{
var vectorLayer = _abstractMap.VectorData.FindFeatureSubLayerWithName("loc");
LayerFilter layerFilter = new LayerFilter(LayerFilterOperationType.Contains);
vectorLayer.filterOptions.filters.Add(layerFilter);
vectorLayer.filterOptions.HasChanged = true;
}
public LayerFilterViewer(LayerFilter filter)
{
InitializeComponent();
_filter = filter;
Target.RawValue = _filter.Target;
Range.RawValue = _filter.Range;
}
/// <summary>
/// Removes a filter.
/// </summary>
/// <param name="layerFilter">Layer filter.</param>
public virtual void RemoveFilter(LayerFilter layerFilter)
{
layerFilter.PropertyHasChanged -= OnLayerFilterChanged;
if (filters.Contains(layerFilter))
{
filters.Remove(layerFilter);
HasChanged = true;
}
}
/// <summary>
/// Merges the filters with item filters.
/// </summary>
/// <param name="item">Item.</param>
private void AddFilterToItem(PrefabItemOptions item, LayerFilter filter)
{
if (item.filterOptions == null)
{
item.filterOptions = new VectorFilterOptions();
}
item.filterOptions.filters.Add(filter);
item.filterOptions.combinerType = item._combinerType;
}
/// <summary>
/// Removes all filters.
/// </summary>
public virtual void RemoveAllFilters()
{
for (int i = 0; i < filters.Count; i++)
{
LayerFilter filter = filters[i];
if (filter != null)
{
RemoveFilter(filter);
}
}
}
/// <summary>
/// Adds a number filter that uses a greater than operator.
/// </summary>
/// <returns>The filter.</returns>
/// <param name="key">Key.</param>
/// <param name="value">Value.</param>
public virtual ILayerFilter AddNumericFilterGreaterThan(string key, float value)
{
var layerFilter = new LayerFilter()
{
Key = key,
filterOperator = LayerFilterOperationType.IsGreater,
Min = value
};
AddFilterToList(layerFilter);
return(layerFilter);
}
/// <summary>
/// Adds a string filter that uses a contains operator.
/// </summary>
/// <returns>The filter.</returns>
/// <param name="key">Key.</param>
/// <param name="property">Property.</param>
public virtual ILayerFilter AddStringFilterContains(string key, string property)
{
LayerFilter layerFilter = new LayerFilter()
{
Key = key,
filterOperator = LayerFilterOperationType.Contains,
PropertyValue = property
};
AddFilterToList(layerFilter);
return(layerFilter);
}
/// <summary>
/// Adds a number filter that uses an equals operator.
/// </summary>
/// <returns>The filter.</returns>
/// <param name="key">Key.</param>
/// <param name="value">Value.</param>
public virtual ILayerFilter AddNumericFilterEquals(string key, float value)
{
LayerFilter layerFilter = new LayerFilter()
{
Key = key,
filterOperator = LayerFilterOperationType.IsEqual,
Min = value
};
AddFilterToList(layerFilter);
return(layerFilter);
}
/// <summary>
/// Adds a number filter that uses an in range operator.
/// </summary>
/// <returns>The filter.</returns>
/// <param name="key">Key.</param>
/// <param name="min">Minimum.</param>
/// <param name="max">Max.</param>
public virtual ILayerFilter AddNumericFilterInRange(string key, float min, float max)
{
LayerFilter layerFilter = new LayerFilter()
{
Key = key,
filterOperator = LayerFilterOperationType.IsInRange,
Min = min,
Max = max
};
AddFilterToList(layerFilter);
return(layerFilter);
}
public CircularGravity()
{
_forceTypeProperties = new ForceTypeProperties();
_specialEffect = new SpecialEffect();
_gameobjectFilter = new GameobjectFilter();
_tagFilter = new TagFilter();
_layerFilter = new LayerFilter();
_triggerAreaFilter = new TriggerAreaFilter();
_constraintProperties = new ConstraintProperties();
_constraintProperties._gameobjectFilter = new GameobjectFilter();
_constraintProperties._tagFilter = new TagFilter();
_constraintProperties._layerFilter = new LayerFilter();
_drawGravityProperties = new DrawGravityProperties();
}
CollectEvent(object sender, CollectorEventArgs e)
{
// cast the sender object to the SnoopCollector we are expecting
Collector snoopCollector = sender as Collector;
if (snoopCollector == null)
{
Debug.Assert(false); // why did someone else send us the message?
return;
}
// see if it is a type we are responsible for
AndExpression andExprn = e.ObjToSnoop as AndExpression;
if (andExprn != null)
{
Stream(snoopCollector.Data(), andExprn);
return;
}
LayerFilter layerFilter = e.ObjToSnoop as LayerFilter;
if (layerFilter != null)
{
Stream(snoopCollector.Data(), layerFilter);
return;
}
RelationalExpression relExprn = e.ObjToSnoop as RelationalExpression;
if (relExprn != null)
{
Stream(snoopCollector.Data(), relExprn);
return;
}
// ValueTypes we have to treat a bit different
if (e.ObjToSnoop is LayerFilterDisplayImages)
{
Stream(snoopCollector.Data(), (LayerFilterDisplayImages)e.ObjToSnoop);
return;
}
if (e.ObjToSnoop is LayerFilterTree)
{
Stream(snoopCollector.Data(), (LayerFilterTree)e.ObjToSnoop);
return;
}
}
private string mapper(LayerFilter layerFilter)
{
var freeze = "";
var thaw = "";
var layerOn = "";
var layerOff = "";
if (layerFilter.Freeze)
{
freeze = "x";
}
if (layerFilter.Thaw)
{
thaw = "x";
}
if (layerFilter.LayerOn)
{
layerOn = "x";
}
if (layerFilter.LayerOff)
{
layerOff = "x";
}
try
{
return(layerFilter.LayerName + "\t"
+ freeze + "\t"
+ thaw + "\t"
+ layerFilter.Color.ColorIndex + "\t"
+ layerOn + "\t"
+ layerOff + "\t"
+ layerFilter.Priority);
}
catch (Exception)
{
return(layerFilter.LayerName + "\t"
+ freeze + "\t"
+ thaw + "\t"
+ "" + "\t"
+ layerOn + "\t"
+ layerOff + "\t"
+ layerFilter.Priority);
}
}
private static void ImportNestedFilters([NotNull] LayerFilter srcFilter, LayerFilter destFilter, IdMapping idmap)
{
foreach (LayerFilter sf in srcFilter.NestedFilters)
{
// Опеределяем не было ли фильтра слоев
// с таким же именем во внешней db
var df = destFilter.NestedFilters.Cast <LayerFilter>().FirstOrDefault(f => f.Name.Equals(sf.Name));
if (df == null)
{
if (sf is LayerGroup)
{
// Создаем новую группу слоев если ничего не найдено
var sfgroup = sf as LayerGroup;
var dfgroup = new LayerGroup {
Name = sf.Name
};
df = dfgroup;
var lyrs = sfgroup.LayerIds;
foreach (ObjectId lid in lyrs)
{
if (idmap.Contains(lid))
{
var idp = idmap[lid];
dfgroup.LayerIds.Add(idp.Value);
}
}
destFilter.NestedFilters.Add(df);
}
else
{
// Создаем фильтр слоев если ничего не найдено
df = new LayerFilter
{
Name = sf.Name,
FilterExpression = sf.FilterExpression
};
destFilter.NestedFilters.Add(df);
}
}
// Импортируем другие фильтры
ImportNestedFilters(sf, df, idmap);
}
}
/// <summary>
/// Sets the density filters.
/// </summary>
/// <param name="item">Item.</param>
private void SetDensityFilters(PrefabItemOptions item)
{
if (item.density >= maxDensity) // decided that the max value for density
{
return;
}
string propertyName = "";
item.densityPropertyFromFindByTypeDictionary.TryGetValue(item.findByType, out propertyName);
if (item.findByType == LocationPrefabFindBy.MapboxCategory || item.findByType == LocationPrefabFindBy.POIName)
{
LayerFilter filter = new LayerFilter(LayerFilterOperationType.IsLess)
{
Key = propertyName,
Min = item.density
};
AddFilterToItem(item, filter);
}
}
/// <summary>
/// Sets the name filters.
/// </summary>
/// <param name="item">Item.</param>
private void SetNameFilters(PrefabItemOptions item)
{
if (string.IsNullOrEmpty(item.nameString))
{
return;
}
string propertyName = "";
item.namePropertyFromFindByTypeDictionary.TryGetValue(item.findByType, out propertyName);
if (item.findByType == LocationPrefabFindBy.POIName)
{
LayerFilter filter = new LayerFilter(LayerFilterOperationType.Contains)
{
Key = propertyName,
PropertyValue = item.nameString
};
AddFilterToItem(item, filter);
}
}
/// <summary>
/// Sets the category filter options.
/// </summary>
/// <param name="item">Item.</param>
private void SetCategoryFilterOptions(PrefabItemOptions item)
{
string propertyName = "";
item.categoryPropertyFromFindByTypeDictionary.TryGetValue(item.findByType, out propertyName);
string concatenatedString = "";
if (item.findByType == LocationPrefabFindBy.MapboxCategory)
{
List <LocationPrefabCategories> categoriesList = GetSelectedCategoriesList(item.categories);
if (categoriesList == null || categoriesList.Count == 0)
{
return;
}
else
{
List <string> stringsList = new List <string>();
foreach (LocationPrefabCategories category in categoriesList)
{
stringsList = LocationPrefabCategoryOptions.GetMakiListFromCategory(category);
if (string.IsNullOrEmpty(concatenatedString))
{
concatenatedString = string.Join(",", stringsList.ToArray());
}
else
{
concatenatedString += "," + string.Join(",", stringsList.ToArray());
}
}
LayerFilter filter = new LayerFilter(LayerFilterOperationType.Contains)
{
Key = propertyName,
PropertyValue = concatenatedString
};
AddFilterToItem(item, filter);
}
}
}
Stream(ArrayList data, LayerFilter layerFilter)
{
data.Add(new Snoop.Data.ClassSeparator(typeof(LayerFilter)));
data.Add(new Snoop.Data.Bool("Allow delete", layerFilter.AllowDelete));
data.Add(new Snoop.Data.Bool("Allow nested", layerFilter.AllowNested));
data.Add(new Snoop.Data.Bool("Allow rename", layerFilter.AllowRename));
data.Add(new Snoop.Data.Object("Display images", layerFilter.DisplayImages));
data.Add(new Snoop.Data.Bool("Dynamically generated", layerFilter.DynamicallyGenerated));
data.Add(new Snoop.Data.String("Filter expression", layerFilter.FilterExpression));
data.Add(new Snoop.Data.Bool("Is Id filter", layerFilter.IsIdFilter));
data.Add(new Snoop.Data.Bool("Is proxy", layerFilter.IsProxy));
data.Add(new Snoop.Data.String("Name", layerFilter.Name));
data.Add(new Snoop.Data.Enumerable("Nested filters", layerFilter.NestedFilters));
data.Add(new Snoop.Data.Object("Parent", layerFilter.Parent));
LayerGroup layerGrp = layerFilter as LayerGroup;
if (layerGrp != null)
{
Stream(data, layerGrp);
return;
}
}
void Unloaded(object sender, VisualTreeAttachmentEventArgs e) => _filter = null;
private void AddFilterToList(LayerFilter layerFilter)
{
filters.Add(layerFilter);
HasChanged = true;
}
private LayerFilter mapper(string filterLine)
{
var lineArray = filterLine.Split('\t');
var layerFilter = new LayerFilter();
if (lineArray.Length >= 1)
{
if (string.IsNullOrEmpty(lineArray[0]))
{
return(null);
}
layerFilter.LayerName = lineArray[0];
}
if (lineArray.Length >= 2)
{
if (!string.IsNullOrEmpty(lineArray[1]))
{
layerFilter.Freeze = true;
}
else
{
layerFilter.Freeze = false;
}
}
if (lineArray.Length >= 3)
{
if (!string.IsNullOrEmpty(lineArray[2]))
{
layerFilter.Thaw = true;
}
else
{
layerFilter.Thaw = false;
}
}
if (lineArray.Length >= 4)
{
short s;
if (short.TryParse(lineArray[3], out s))
{
layerFilter.Color = Color.FromColorIndex(ColorMethod.ByAci, s);
}
else
{
layerFilter.Color = null;
}
}
if (lineArray.Length >= 5)
{
if (!string.IsNullOrEmpty(lineArray[4]))
{
layerFilter.LayerOn = true;
}
else
{
layerFilter.LayerOn = false;
}
}
if (lineArray.Length >= 6)
{
if (!string.IsNullOrEmpty(lineArray[5]))
{
layerFilter.LayerOff = true;
}
else
{
layerFilter.LayerOff = false;
}
}
if (lineArray.Length >= 7)
{
try
{
layerFilter.Priority = Convert.ToInt32(lineArray[6]);
}
catch (Exception) { }
}
return(layerFilter);
}
private static void ImportLayerFilterTree(string filePath, LayerFilter lfDest, Database dbDest)
{
using (Database dbSrc = new Database(false, false))
{
dbSrc.ReadDwgFile(filePath, FileOpenMode.OpenForReadAndAllShare, false, string.Empty);
ImportNestedFilters(dbSrc.LayerFilters.Root, lfDest,dbSrc, dbDest );
}
}
public static void ImportNestedFilters(LayerFilter srcFilter, LayerFilter destFilter, Database srcDb, Database destDb)
{
using (Transaction t = srcDb.TransactionManager.StartTransaction())
{
LayerTable lt = t.GetObject(srcDb.LayerTableId, OpenMode.ForRead, false) as LayerTable;
foreach (LayerFilter sf in srcFilter.NestedFilters)
{
// Получаем слои, которые следует клонировать в db
// Только те, которые участвуют в фильтре
ObjectIdCollection layerIds = new ObjectIdCollection();
foreach (ObjectId layerId in lt)
{
LayerTableRecord ltr = t.GetObject(layerId, OpenMode.ForRead, false) as LayerTableRecord;
if (sf.Filter(ltr))
{
layerIds.Add(layerId);
}
}
// Клонируем слои во внешнюю db
IdMapping idmap = new IdMapping();
if (layerIds.Count > 0)
{
srcDb.WblockCloneObjects(layerIds, destDb.LayerTableId, idmap, DuplicateRecordCloning.Replace, false);
}
// Опеределяем не было ли фильтра слоев
// с таким же именем во внешней db
LayerFilter df = null;
foreach (LayerFilter f in destFilter.NestedFilters)
{
if (f.Name.Equals(sf.Name))
{
df = f;
break;
}
}
if (df == null)
{
if (sf is LayerGroup)
{
// Создаем новую группу слоев если
// ничего не найдено
LayerGroup sfgroup = sf as LayerGroup;
LayerGroup dfgroup = new LayerGroup();
dfgroup.Name = sf.Name;
df = dfgroup;
LayerCollection lyrs = sfgroup.LayerIds;
foreach (ObjectId lid in lyrs)
{
if (idmap.Contains(lid))
{
IdPair idp = idmap[lid];
dfgroup.LayerIds.Add(idp.Value);
}
}
destFilter.NestedFilters.Add(df);
}
else
{
// Создаем фильтр слоев если
// ничего не найдено
df = new LayerFilter();
df.Name = sf.Name;
df.FilterExpression = sf.FilterExpression;
destFilter.NestedFilters.Add(df);
}
}
// Импортируем другие фильтры
ImportNestedFilters(sf, df, srcDb, destDb);
}
t.Commit();
}
}
static void Init()
{
LayerFilter window = (LayerFilter)EditorWindow.GetWindow(typeof(LayerFilter));
}
