// Constructors
public TypeMapping(TypeInfo type, MapTransform keyTransform, MapTransform transform, int[] keyIndexes)
{
Type = type;
KeyTransform = keyTransform;
Transform = transform;
KeyIndexes = keyIndexes;
}
/// <summary>
/// 坐标转换
/// </summary>
/// <param name="coordinateType">坐标转换方式：1 百度地图转天地图,2天地图转百度地图</param>
/// <param name="inMapX">经度</param>
/// <param name="inMapY">纬度</param>
/// <param name="MapX">经度</param>
/// <param name="MapY">纬度</param>
/// <returns></returns>
private int GetMapXAndMapY(int coordinateType, string inMapX, string inMapY, out string MapX, out string MapY)
{
MapX = inMapX;
MapY = inMapY;
try
{
double mapx = double.Parse(MapX); double mapy = double.Parse(MapY);
if (mapx > 0 && mapy > 0)
{
if (coordinateType == 1)
{
//百度地图转天地图
double[] gcjarr = MapTransform.BD09ToGCJ02(mapx, mapy);
double[] wgsarr = MapTransform.GCJ02ToWGS84(gcjarr[0], gcjarr[1]);
MapX = Math.Round(wgsarr[0], 6).ToString();
MapY = Math.Round(wgsarr[1], 6).ToString();
}
else if (coordinateType == 2)
{
//天地图转百度地图
double[] GCJ02 = MapTransform.WGS84ToGCJ02(mapx, mapy);
double[] BD09 = MapTransform.GCJ02ToBD09(GCJ02[0], GCJ02[1]);
MapX = Math.Round(BD09[0], 6).ToString();
MapY = Math.Round(BD09[1], 6).ToString();
}
}
return(1);
}
catch (Exception ex)
{
}
return(1);
}
/// <inheritdoc/>
protected override void Initialize()
{
base.Initialize();
var comparisonRules = new ComparisonRules[Order.Count];
for (int i = 0; i < Order.Count; i++)
{
var orderItem = Order[i];
var culture = CultureInfo.InvariantCulture;
var column = Header.Columns[orderItem.Key];
var mappedColumn = column as MappedColumn;
if (mappedColumn != null && mappedColumn.ColumnInfoRef != null)
{
culture = mappedColumn.ColumnInfoRef.CultureInfo;
}
comparisonRules[i] = new ComparisonRule(orderItem.Value, culture);
}
var fieldTypes = new Type[Order.Count];
var map = new int[Order.Count];
for (var i = 0; i < Order.Count; i++)
{
var p = Order[i];
fieldTypes[i] = Header.Columns[p.Key].Type;
map[i] = p.Key;
}
var orderKeyDescriptor = TupleDescriptor.Create(fieldTypes);
OrderKeyExtractorTransform = new MapTransform(true, orderKeyDescriptor, map);
}
private void InitOrigin()
{
if (!initialized)
{
playerModel = Instantiate(_jidoManager.PlayerModelPrefab);
playerModel.name = name;
HitTestPlayerFeet(playerModel.transform.position, playerModel.GetComponentInChildren <PlayerCallouts>());
GetComponent <PlayerController>().SetGameStarted(playerModel);
MapTransform transform = FindObjectOfType <MapSession> ().MultiplayerSync(getTapLocalFrame, tapLocalFrame, getTapRemoteFrame, tapRemoteFrame, null);
rotationRemoteToLocal = transform.RotationRemoteToLocal;
offsetLocalToRemote = transform.OffsetLocalToRemote;
initialized = true;
}
else
{
MapTransform transform = FindObjectOfType <MapSession> ().MultiplayerSync(getTapLocalFrame, tapLocalFrame, getTapRemoteFrame, tapRemoteFrame, rotationRemoteToLocal);
if (transform.UpdateError > (errorThresh * 1.2f))
{
return;
}
updateTarget = true;
updateOffset = transform.OffsetLocalToRemote;
}
}
private static EntitySetTypeState BuildEntitySetTypeState(object key, EntitySetBase entitySet)
{
var field = ((Pair <object, FieldInfo>)key).Second;
var association = field.Associations.Last();
var query = association.UnderlyingIndex.GetQuery().Seek(() => keyParameter.Value);
var seek = entitySet.Session.Compile(query);
var ownerDescriptor = association.OwnerType.Key.TupleDescriptor;
var targetDescriptor = association.TargetType.Key.TupleDescriptor;
var itemColumnOffsets = association.AuxiliaryType == null
? association.UnderlyingIndex.ValueColumns
.Where(ci => ci.IsPrimaryKey)
.Select(ci => ci.Field.MappingInfo.Offset)
.ToList()
: Enumerable.Range(0, targetDescriptor.Count).ToList();
var keyDescriptor = TupleDescriptor.Create(ownerDescriptor
.Concat(itemColumnOffsets.Select(i => targetDescriptor[i]))
.ToList());
var map = Enumerable.Range(0, ownerDescriptor.Count)
.Select(i => new Pair <int, int>(0, i))
.Concat(itemColumnOffsets.Select(i => new Pair <int, int>(1, i)))
.ToArray();
var seekTransform = new MapTransform(true, keyDescriptor, map);
Func <Tuple, Entity> itemCtor = null;
if (association.AuxiliaryType != null)
{
itemCtor = DelegateHelper.CreateDelegate <Func <Tuple, Entity> >(null,
association.AuxiliaryType.UnderlyingType, DelegateHelper.AspectedFactoryMethodName,
ArrayUtils <Type> .EmptyArray);
}
return(new EntitySetTypeState(seek, seekTransform, itemCtor, entitySet.GetItemCountQueryDelegate(field)));
}
private async void Locations_ValueChanged(object sender, EventArgs e)
{
var locations = this.Locations;
var valueLevels = this.ValueLevels;
if (locations == null || valueLevels == null)
{
return;
}
this.PolylineParts = await Task.Run(() => this.Segment(locations, valueLevels));
var mapView = this.GetParent <MapView>();
var polylineParts = this.PolylineParts;
var tolerance = this.Tolerance;
var isEnabled = this.IsEnabled;
var doubleToBrushMap = this.DoubleToBrushMap;
var disabledStroke = this.DisabledStroke;
var converter = new MapTransform(mapView);
this.SimplifiedPolylineParts = new ObservableCollection <LocationCollectionViewModel>();
foreach (var part in polylineParts)
{
this.SimplifiedPolylineParts.Add(await Task.Run(() => this.Reduce(part, converter, tolerance, doubleToBrushMap, isEnabled, disabledStroke)));
}
}
/// <summary>
/// Returns a cloned copy of this map-object.
/// Layers are not cloned. The same instances are referenced from the cloned copy as from the original.
/// The property <see cref="DisposeLayersOnDispose"/> is however false on this object (which prevents layers beeing disposed and then not usable from the original map)
/// </summary>
/// <returns>Instance of <see cref="Map"/></returns>
public Map Clone()
{
Map clone = null;
lock (MapTransform)
{
clone = new Map()
{
BackColor = BackColor,
Disclaimer = Disclaimer,
DisclaimerLocation = DisclaimerLocation,
MaximumZoom = MaximumZoom,
MinimumZoom = MinimumZoom,
PixelAspectRatio = PixelAspectRatio,
Zoom = Zoom,
DisposeLayersOnDispose = false
};
if (DisclaimerFont != null)
{
clone.DisclaimerFont = (Font)DisclaimerFont.Clone();
}
if (MapTransform != null)
{
clone.MapTransform = MapTransform.Clone();
}
if (Size != null)
{
clone.Size = new Size(Size.Width, Size.Height);
}
if (Center != null)
{
clone.Center = Center.Clone();
}
}
if (clone != null)
{
if (BackgroundLayer != null)
{
clone.BackgroundLayer.AddCollection(BackgroundLayer.Clone());
}
for (int i = 0; i < Decorations.Count; i++)
{
clone.Decorations.Add(Decorations[i]);
}
if (Layers != null)
{
clone.Layers.AddCollection(Layers.Clone());
}
if (VariableLayers != null)
{
clone.VariableLayers.AddCollection(VariableLayers.Clone());
}
}
return(clone);
}
public EntitySetTypeState(ExecutableProvider seekProvider, MapTransform seekTransform,
Func <Tuple, Entity> itemCtor, Func <QueryEndpoint, long> itemCountQuery)
{
SeekProvider = seekProvider;
SeekTransform = seekTransform;
ItemCtor = itemCtor;
ItemCountQuery = itemCountQuery;
}
public TypeMapping GetTypeMapping(int entityIndex, TypeInfo approximateType, int typeId, Pair <int>[] columns)
{
TypeMapping result;
var cache = entityMappings[entityIndex];
if (cache.SingleItem != null)
{
if (typeId != ResolveTypeToNodeSpecificTypeIdentifier(cache.SingleItem.Type))
{
throw new ArgumentOutOfRangeException("typeId");
}
return(cache.SingleItem);
}
if (cache.Items.TryGetValue(typeId, out result))
{
return(result);
}
var type = TypeIdRegistry[typeId];
var keyInfo = type.Key;
var descriptor = type.TupleDescriptor;
var typeColumnMap = columns.ToArray();
if (approximateType.IsInterface)
{
// fixup target index
for (int i = 0; i < columns.Length; i++)
{
var pair = typeColumnMap[i];
var approxTargetIndex = pair.First;
var interfaceField = approximateType.Columns[approxTargetIndex].Field;
var field = type.FieldMap[interfaceField];
var targetIndex = field.MappingInfo.Offset;
typeColumnMap[i] = new Pair <int>(targetIndex, pair.Second);
}
}
int[] allIndexes = MaterializationHelper.CreateSingleSourceMap(descriptor.Count, typeColumnMap);
int[] keyIndexes = allIndexes.Take(keyInfo.TupleDescriptor.Count).ToArray();
var transform = new MapTransform(true, descriptor, allIndexes);
var keyTransform = new MapTransform(true, keyInfo.TupleDescriptor, keyIndexes);
result = new TypeMapping(type, keyTransform, transform, keyIndexes);
if (type.Hierarchy.Root.IsLeaf && approximateType == type)
{
cache.SingleItem = result;
}
else
{
cache.Items.Add(typeId, result);
}
entityMappings[entityIndex] = cache;
return(result);
}
/// <inheritdoc/>
protected override RecordSetHeader BuildHeader()
{
var newHeader = Source.Header.Add(new SystemColumn(ResultColumnName, 0, typeof(bool)));
var types = FilteredColumns.Select(m => newHeader.Columns[m].Type);
FilteredColumnsExtractionTransform = new MapTransform(true, TupleDescriptor.Create(types), FilteredColumns);
ResultTransform = new CombineTransform(true, Source.Header.TupleDescriptor, TupleDescriptor.Create(new [] { typeof(bool) }));
return(newHeader);
}
public void MainTest()
{
Xtensive.Tuples.Tuple source = Tuple.Create(1);
MapTransform transform = new MapTransform(true, TupleDescriptor.Create <byte, int, string>(), new[] { -1, 0 });
Xtensive.Tuples.Tuple result = transform.Apply(TupleTransformType.TransformedTuple, source);
Assert.AreEqual(TupleFieldState.Default, result.GetFieldState(0));
Assert.AreEqual(TupleFieldState.Available, result.GetFieldState(1));
Assert.AreEqual(TupleFieldState.Default, result.GetFieldState(2));
}
/// <inheritdoc/>
protected override void Initialize()
{
base.Initialize();
var columnIndexes = new int[Header.Length];
for (int i = 0; i < columnIndexes.Length; i++)
{
columnIndexes[i] = (i < Source.Header.Length) ? i : MapTransform.NoMapping;
}
ResizeTransform = new MapTransform(false, Header.TupleDescriptor, columnIndexes);
}
/// <summary>
/// Converts a point from world coordinates to image coordinates based on the current
/// zoom, center and mapsize.
/// </summary>
/// <param name="p">Point in world coordinates</param>
/// <param name="careAboutMapTransform">Indicates whether MapTransform should be taken into account</param>
/// <returns>Point in image coordinates</returns>
public PointF WorldToImage(Point p, bool careAboutMapTransform)
{
PointF pTmp = Transform.WorldtoMap(p, this);
if (careAboutMapTransform && !MapTransform.IsIdentity)
{
PointF[] pts = new PointF[] { pTmp };
MapTransform.TransformPoints(pts);
pTmp = pts[0];
}
return(pTmp);
}
protected override Provider VisitRaw(RawProvider provider)
{
var mapping = mappings[provider];
if (mapping.SequenceEqual(Enumerable.Range(0, provider.Header.Length)))
{
return(provider);
}
var mappingTransform = new MapTransform(true, provider.Header.TupleDescriptor, mapping.ToArray());
var newExpression = RemapRawProviderSource(provider.Source, mappingTransform);
return(new RawProvider(provider.Header.Select(mapping), newExpression));
}
/// <inheritdoc/>
protected override void Initialize()
{
base.Initialize();
var types = new List <Type>();
int i = 0;
var columnIndexes = new int[GroupColumnIndexes.Length];
foreach (var index in GroupColumnIndexes)
{
types.Add(Source.Header.Columns[index].Type);
columnIndexes[i++] = index;
}
Transform = new MapTransform(false, TupleDescriptor.Create(types), columnIndexes);
}
private NamePrepTransform()
{
// load the resource bundle
//ICUResourceBundle bundle = (ICUResourceBundle)ICUResourceBundle.GetBundleInstance("com/ibm/icu/dev/data/testdata", "idna_rules", typeof(NamePrepTransform).GetTypeInfo().Assembly, true);
ICUResourceBundle bundle = (ICUResourceBundle)ICUResourceBundle.GetBundleInstance("Dev/Data/TestData", "idna_rules", typeof(NamePrepTransform).GetTypeInfo().Assembly, true);
String mapRules = bundle.GetString("MapNoNormalization");
mapRules += bundle.GetString("MapNFKC");
// disable
mapTransform = new MapTransform("CaseMap", mapRules, 0 /*Transliterator.FORWARD*/);
labelSeparatorSet = new UnicodeSet(bundle.GetString("LabelSeparatorSet"));
prohibitedSet = new UnicodeSet(bundle.GetString("ProhibitedSet"));
unassignedSet = new UnicodeSet(bundle.GetString("UnassignedSet"));
}
private static Expression <Func <ParameterContext, IEnumerable <Tuple> > > RemapRawProviderSource(
Expression <Func <ParameterContext, IEnumerable <Tuple> > > source, MapTransform mappingTransform)
{
var selectMethodInfo = WellKnownTypes.Enumerable
.GetMethods()
.Single(methodInfo => methodInfo.Name == nameof(Enumerable.Select) &&
methodInfo.GetParameters()[1].ParameterType.GetGenericTypeDefinition() == typeof(Func <,>))
.MakeGenericMethod(WellKnownOrmTypes.Tuple, WellKnownOrmTypes.Tuple);
Func <Tuple, Tuple> selector = tuple => mappingTransform.Apply(TupleTransformType.Auto, tuple);
var newExpression = Expression.Call(selectMethodInfo, source.Body, Expression.Constant(selector));
return((Expression <Func <ParameterContext, IEnumerable <Tuple> > >)FastExpression.Lambda(newExpression, source.Parameters[0]));
}
/// <inheritdoc/>
protected override void Initialize()
{
base.Initialize();
var fieldTypes = new Type[GroupColumnIndexes.Length];
var columnIndexes = new int[GroupColumnIndexes.Length];
var i = 0;
foreach (var index in GroupColumnIndexes)
{
fieldTypes[i] = Source.Header.Columns[index].Type;
columnIndexes[i] = index;
i++;
}
Transform = new MapTransform(false, TupleDescriptor.Create(fieldTypes), columnIndexes);
}
/// <inheritdoc/>
protected override RecordSetHeader BuildHeader()
{
var newHeader = Source.Header.Add(new SystemColumn(ResultColumnName, 0, BoolType));
var fieldTypes = new Type[FilteredColumns.Count];
for (var index = 0; index < fieldTypes.Length; index++)
{
fieldTypes[index] = newHeader.Columns[FilteredColumns[index]].Type;
}
var tupleDescriptor = TupleDescriptor.Create(fieldTypes);
FilteredColumnsExtractionTransform = new MapTransform(true, tupleDescriptor, FilteredColumns);
ResultTransform = new CombineTransform(true, Source.Header.TupleDescriptor, BoolTupleDescriptor);
return(newHeader);
}
/// <summary>
/// Cuts out <paramref name="segment"/> from <paramref name="tuple"/> <see cref="Tuple"/>.
/// </summary>
/// <param name="tuple">The <see cref="Tuple"/> to get segment from.</param>
/// <param name="segment">The <see cref="Segment{T}"/> to cut off.</param>
/// <returns></returns>
public static Tuple GetSegment(this Tuple tuple, Segment <int> segment)
{
var map = new int[segment.Length];
for (int i = 0; i < segment.Length; i++)
{
map[i] = segment.Offset + i;
}
var types = new ArraySegment <Type>(tuple.Descriptor.FieldTypes, segment.Offset, segment.Length);
var descriptor = TupleDescriptor.Create(types.AsEnumerable());
var transform = new MapTransform(false, descriptor, map);
return(transform.Apply(TupleTransformType.TransformedTuple, tuple));
}
/// <summary>
/// Converts a point from world coordinates to image coordinates based on the current
/// zoom, center and mapsize.
/// </summary>
/// <param name="p">Point in world coordinates</param>
/// <param name="careAboutMapTransform">Indicates whether MapTransform should be taken into account</param>
/// <returns>Point in image coordinates</returns>
public PointF WorldToImage(Coordinate p, bool careAboutMapTransform)
{
var pTmp = Transform.WorldtoMap(p, this);
lock (MapTransform)
{
if (careAboutMapTransform && !MapTransform.IsIdentity)
{
var pts = new[] { pTmp };
MapTransform.TransformPoints(pts);
pTmp = pts[0];
}
}
return(pTmp);
}
private void BuildVersionExtractor()
{
// Building version tuple extractor
var versionColumns = GetVersionColumns();
if (versionColumns == null || versionColumns.Count == 0)
{
VersionExtractor = null;
return;
}
var types = versionColumns.Select(c => c.ValueType).ToArray();
var map = versionColumns.Select(c => c.Field.MappingInfo.Offset).ToArray();
var versionTupleDescriptor = TupleDescriptor.Create(types);
VersionExtractor = new MapTransform(true, versionTupleDescriptor, map);
}
public override void Read(XmlNode os)
{
foreach (XmlNode current in LoadXML.GetChilds(os))
{
switch (current.Name)
{
case "Camp":
this.Camp = (EBattleCamp)ReadInt(current);
break;
case "TransParam":
this.TransParam = new MapTransform();
this.TransParam.Read(current);
break;
}
}
}
/// <summary>
/// Returns a cloned copy of this map-object.
/// Layers are not cloned. The same instances are referenced from the cloned copy as from the original.
/// The property <see cref="DisposeLayersOnDispose"/> is however false on this object (which prevents layers beeing disposed and then not usable from the original map)
/// </summary>
/// <returns>Instance of <see cref="Map"/></returns>
public Map Clone()
{
Map clone = null;
lock (MapTransform)
{
clone = new Map()
{
BackColor = BackColor,
Center = Center,
Disclaimer = Disclaimer,
DisclaimerFont = DisclaimerFont,
DisclaimerLocation = DisclaimerLocation,
MapTransform = MapTransform.Clone(),
MaximumZoom = MaximumZoom,
MinimumZoom = MinimumZoom,
PixelAspectRatio = PixelAspectRatio,
Size = Size,
Zoom = Zoom,
DisposeLayersOnDispose = false
};
}
if (clone != null)
{
foreach (var lay in BackgroundLayer)
{
clone.BackgroundLayer.Add(lay);
}
foreach (var dec in Decorations)
{
clone.Decorations.Add(dec);
}
foreach (var lay in Layers)
{
clone.Layers.Add(lay);
}
foreach (var lay in VariableLayers)
{
clone.VariableLayers.Add(lay);
}
}
return(clone);
}
/// <summary>
/// Returns a cloned copy of this map-object.
/// Layers are not cloned. The same instances are referenced from the cloned copy as from the original.
/// The property <see cref="DisposeLayersOnDispose"/> is however false on this object (which prevents layers beeing disposed and then not usable from the original map)
/// </summary>
/// <returns>Instance of <see cref="Map"/></returns>
public Map Clone()
{
Map clone = null;
lock (MapTransform)
{
clone = new Map()
{
BackColor = BackColor,
#pragma warning disable 612,618
Disclaimer = Disclaimer,
DisclaimerLocation = DisclaimerLocation,
#pragma warning restore 612,618
MaximumZoom = MaximumZoom,
MinimumZoom = MinimumZoom,
PixelAspectRatio = PixelAspectRatio,
Zoom = Zoom,
DisposeLayersOnDispose = false,
SRID = SRID
};
#pragma warning disable 612,618
if (DisclaimerFont != null)
{
clone.DisclaimerFont = (Font)DisclaimerFont.Clone();
}
#pragma warning restore 612,618
if (MapTransform != null)
{
clone.MapTransform = MapTransform.Clone();
}
if (!Size.IsEmpty)
{
clone.Size = new Size(Size.Width, Size.Height);
}
if (Center != null)
{
clone.Center = (Coordinate)Center.Clone();
}
}
if (BackgroundLayer != null)
{
clone.BackgroundLayer.AddCollection(BackgroundLayer.Clone());
}
for (int i = 0; i < Decorations.Count; i++)
{
clone.Decorations.Add(Decorations[i]);
}
if (Layers != null)
{
clone.Layers.AddCollection(Layers.Clone());
}
if (VariableLayers != null)
{
clone.VariableLayers.AddCollection(VariableLayers.Clone());
}
return(clone);
}
/// <summary>
/// Renders the map using the provided <see cref="Graphics"/> object.
/// </summary>
/// <param name="g">the <see cref="Graphics"/> object to use</param>
/// <param name="layerCollectionType">the <see cref="LayerCollectionType"/> to use</param>
/// <param name="drawMapDecorations">Set whether to draw map decorations on the map (if such are set)</param>
/// <param name="drawTransparent">Set wether to draw with transparent background or with BackColor as background</param>
/// <exception cref="ArgumentNullException">if <see cref="Graphics"/> object is null.</exception>
/// <exception cref="InvalidOperationException">if there are no layers to render.</exception>
public void RenderMap(Graphics g, LayerCollectionType layerCollectionType, bool drawMapDecorations, bool drawTransparent)
{
if (g == null)
{
throw new ArgumentNullException("g", "Cannot render map with null graphics object!");
}
VariableLayerCollection.Pause = true;
LayerCollection lc = null;
switch (layerCollectionType)
{
case LayerCollectionType.Static:
lc = Layers;
break;
case LayerCollectionType.Variable:
lc = VariableLayers;
break;
case LayerCollectionType.Background:
lc = BackgroundLayer;
break;
}
if (lc == null || lc.Count == 0)
{
throw new InvalidOperationException("No layers to render");
}
Matrix transform = g.Transform;
lock (MapTransform)
{
g.Transform = MapTransform.Clone();
}
if (!drawTransparent)
{
g.Clear(BackColor);
}
g.PageUnit = GraphicsUnit.Pixel;
ILayer[] layerList = new ILayer[lc.Count];
lc.CopyTo(layerList, 0);
foreach (ILayer layer in layerList)
{
if (layer.Enabled && layer.MaxVisible >= Zoom && layer.MinVisible < Zoom)
{
layer.Render(g, this);
}
}
if (drawTransparent)
{
g.Transform = transform;
}
if (layerCollectionType == LayerCollectionType.Static)
{
#pragma warning disable 612,618
RenderDisclaimer(g);
#pragma warning restore 612,618
if (drawMapDecorations)
{
foreach (var mapDecoration in Decorations)
{
mapDecoration.Render(g, this);
}
}
}
VariableLayerCollection.Pause = false;
}
/// <summary>
/// Renders the map using the provided <see cref="Graphics"/> object.
/// </summary>
/// <param name="g">the <see cref="Graphics"/> object to use</param>
/// <exception cref="ArgumentNullException">if <see cref="Graphics"/> object is null.</exception>
/// <exception cref="InvalidOperationException">if there are no layers to render.</exception>
public void RenderMap(Graphics g)
{
OnMapRendering(g);
if (g == null)
{
throw new ArgumentNullException("g", "Cannot render map with null graphics object!");
}
//Pauses the timer for VariableLayer
VariableLayerCollection.Pause = true;
if ((Layers == null || Layers.Count == 0) && (BackgroundLayer == null || BackgroundLayer.Count == 0) && (_variableLayers == null || _variableLayers.Count == 0))
{
throw new InvalidOperationException("No layers to render");
}
lock (MapTransform)
{
g.Transform = MapTransform.Clone();
}
g.Clear(BackColor);
g.PageUnit = GraphicsUnit.Pixel;
//int srid = (Layers.Count > 0 ? Layers[0].SRID : -1); //Get the SRID of the first layer
ILayer[] layerList;
if (_backgroundLayers != null && _backgroundLayers.Count > 0)
{
layerList = new ILayer[_backgroundLayers.Count];
_backgroundLayers.CopyTo(layerList, 0);
foreach (ILayer layer in layerList)
{
OnLayerRendering(layer, LayerCollectionType.Background);
if (layer.Enabled && layer.MaxVisible >= Zoom && layer.MinVisible < Zoom)
{
layer.Render(g, this);
}
OnLayerRendered(layer, LayerCollectionType.Background);
}
}
if (_layers != null && _layers.Count > 0)
{
layerList = new ILayer[_layers.Count];
_layers.CopyTo(layerList, 0);
//int srid = (Layers.Count > 0 ? Layers[0].SRID : -1); //Get the SRID of the first layer
foreach (ILayer layer in layerList)
{
OnLayerRendering(layer, LayerCollectionType.Static);
if (layer.Enabled && layer.MaxVisible >= Zoom && layer.MinVisible < Zoom)
{
layer.Render(g, this);
}
OnLayerRendered(layer, LayerCollectionType.Static);
}
}
if (_variableLayers != null && _variableLayers.Count > 0)
{
layerList = new ILayer[_variableLayers.Count];
_variableLayers.CopyTo(layerList, 0);
foreach (ILayer layer in layerList)
{
if (layer.Enabled && layer.MaxVisible >= Zoom && layer.MinVisible < Zoom)
{
layer.Render(g, this);
}
}
}
#pragma warning disable 612,618
RenderDisclaimer(g);
#pragma warning restore 612,618
// Render all map decorations
foreach (var mapDecoration in _decorations)
{
mapDecoration.Render(g, this);
}
//Resets the timer for VariableLayer
VariableLayerCollection.Pause = false;
OnMapRendered(g);
}
private LocationCollectionViewModel Reduce(LocationCollection locationCollection, MapTransform converter, double tolerance, IDoubleToBrushMap doubleToBrushMap, bool isEnabled, Brush disabledStroke)
{
return(new LocationCollectionViewModel
{
Locations = new LocationCollection(locationCollection.Reduce(converter, tolerance)),
//Stroke = isEnabled ? doubleToBrushMap.Map(locationCollection[1].Value) : disabledStroke
});
}
private void BuildTuplePrototype()
{
// Building nullable map
var nullabilityMap = new BitArray(TupleDescriptor.Count);
int i = 0;
foreach (var column in Columns)
{
nullabilityMap[i++] = column.IsNullable;
}
// fixing reference fields that are marked as not nullable
foreach (var field in Fields.Where(f => f.IsEntity && !f.IsPrimaryKey && f.IsNullable == false))
{
var segment = field.MappingInfo;
for (int j = segment.Offset; j < segment.EndOffset; j++)
{
nullabilityMap[j] = true;
}
}
// Building TuplePrototype
var tuple = Tuple.Create(TupleDescriptor);
tuple.Initialize(nullabilityMap);
// Initializing defaults
i = 0;
foreach (var column in Columns)
{
if (column.DefaultValue != null)
{
try {
tuple.SetValue(i, column.DefaultValue);
}
catch (Exception e) {
OrmLog.Error(e, Strings.LogExErrorSettingDefaultValueXForColumnYInTypeZ,
column.DefaultValue, column.Name, Name);
}
}
i++;
}
// Aditional initialization for entities
if (IsEntity)
{
// Setting type discriminator column
if (Hierarchy.TypeDiscriminatorMap != null)
{
tuple.SetValue(Hierarchy.TypeDiscriminatorMap.Field.MappingInfo.Offset, typeDiscriminatorValue);
}
// Building primary key injector
var fieldCount = TupleDescriptor.Count;
var keyFieldCount = Key.TupleDescriptor.Count;
var keyFieldMap = new Pair <int, int> [fieldCount];
for (i = 0; i < fieldCount; i++)
{
keyFieldMap[i] = new Pair <int, int>((i < keyFieldCount) ? 0 : 1, i);
}
primaryKeyInjector = new MapTransform(false, TupleDescriptor, keyFieldMap);
}
TuplePrototype = IsEntity ? tuple.ToFastReadOnly() : tuple;
}
private static Expression <Func <IEnumerable <Tuple> > > RemapRawProviderSource(Expression <Func <IEnumerable <Tuple> > > source, MapTransform mappingTransform)
{
var selectMethodInfo = typeof(Enumerable)
.GetMethods()
.Single(methodInfo => methodInfo.Name == "Select" &&
methodInfo.GetParameters()[1].ParameterType.GetGenericTypeDefinition() == typeof(Func <,>))
.MakeGenericMethod(typeof(Tuple), typeof(Tuple));
Func <Tuple, Tuple> selector = tuple => mappingTransform.Apply(TupleTransformType.Auto, tuple);
var newExpression = Expression.Call(selectMethodInfo, source.Body, Expression.Constant(selector));
return((Expression <Func <IEnumerable <Tuple> > >)Expression.Lambda(newExpression));
}