protected override void PostEntryStep()
        {
            const string objectId   = "RecordedAt";
            const string object2Id  = "PIP";
            const string object3Id  = "IsAuthorized";
            IActiveView  activeView = ArcUtils.ActiveView;
            IEnvelope    envelope   = activeView.Extent;

            ISpatialFilter spatialFilter = new SpatialFilterClass
            {
                Geometry      = envelope,
                GeometryField = FeatureClass.ShapeFieldName,
                SpatialRel    = esriSpatialRelEnum.esriSpatialRelContains,
                SubFields     = string.Format("{0},{1},{2}", objectId, object2Id, object3Id)
            };

            var      existsResult = FeatureClass.Search(spatialFilter, false);
            IFeature feature;
            var      added          = new List <int>();
            var      pipAdded       = new List <int>();
            var      forbiddenAdded = new List <int>();

            while ((feature = existsResult.NextFeature()) != null)
            {
                // ReSharper disable UseIndexedProperty
                int    imId     = existsResult.FindField(objectId);
                object value    = feature.get_Value(imId);
                var    dateTime = (DateTime)value;
                int    year     = dateTime.Year;
                int    month    = dateTime.Month;
                int    calcYear = (year * 4) + (int)Math.Floor(((double)(month - 1)) / 3);

                if (!YearToColor.ContainsKey(calcYear))
                {
                    YearToColor.Add(calcYear, Color.Transparent);
                    added.Add(calcYear);
                }

                int    pipId    = existsResult.FindField(object2Id);
                object pipValue = feature.get_Value(pipId);

                if (pipValue != null)
                {
                    bool pip = bool.Parse((string)pipValue);

                    if (pip && (!YearPip.Contains(calcYear)))
                    {
                        YearPip.Add(calcYear);
                        pipAdded.Add(calcYear);
                    }
                }

                int    forbiddenId    = existsResult.FindField(object3Id);
                object forbiddenValue = feature.get_Value(forbiddenId);
                // ReSharper restore UseIndexedProperty

                if (forbiddenValue != null)
                {
                    bool forbidden = !bool.Parse((string)forbiddenValue);

                    if (forbidden && (!YearForbidden.Contains(calcYear)))
                    {
                        YearForbidden.Add(calcYear);
                        forbiddenAdded.Add(calcYear);
                    }
                }
            }

            var geoFeatureLayer = Layer as IGeoFeatureLayer;

            if (geoFeatureLayer != null)
            {
                IFeatureRenderer featureRenderer = geoFeatureLayer.Renderer;
                var uniqueValueRenderer          = featureRenderer as IUniqueValueRenderer;

                if (uniqueValueRenderer != null)
                {
                    foreach (var value in added)
                    {
                        bool realAdd  = true;
                        var  newValue = (int)Math.Floor(((double)value) / 4);

                        for (int i = newValue; i < (newValue + 4); i++)
                        {
                            realAdd = (!YearToColor.ContainsKey(i)) && realAdd;
                        }

                        if (realAdd)
                        {
                            // ReSharper disable CSharpWarnings::CS0612
                            // ReSharper disable CSharpWarnings::CS0618

                            var symbol = new SimpleMarkerSymbol
                            {
                                Color = Converter.ToRGBColor(Color.Transparent),
                                Size  = SizeLayer
                            };

                            // ReSharper restore CSharpWarnings::CS0618
                            // ReSharper restore CSharpWarnings::CS0612
                            var    markerSymbol = symbol as ISymbol;
                            string classValue   = string.Format("{0}, {1}, {2}", newValue, false, true);
                            uniqueValueRenderer.AddValue(classValue, string.Empty, markerSymbol);

                            // ReSharper disable UseIndexedProperty
                            string label = newValue.ToString(CultureInfo.InvariantCulture);
                            uniqueValueRenderer.set_Label(classValue, label);
                            // ReSharper restore UseIndexedProperty
                        }
                    }

                    foreach (var value in pipAdded)
                    {
                        bool realAdd  = true;
                        var  newValue = (int)Math.Floor(((double)value) / 4);

                        for (int i = newValue; i < (newValue + 4); i++)
                        {
                            realAdd = (!YearToColor.ContainsKey(i)) && realAdd;
                        }

                        if (realAdd)
                        {
                            var rotationRenderer = uniqueValueRenderer as IRotationRenderer;

                            if (rotationRenderer != null)
                            {
                                rotationRenderer.RotationField = "PIP1Yaw";
                                rotationRenderer.RotationType  = esriSymbolRotationType.esriRotateSymbolGeographic;
                            }

                            Color   color      = YearToColor.ContainsKey(value) ? YearToColor[value] : Color.Transparent;
                            ISymbol symbol     = ArcUtils.GetPipSymbol(SizeLayer, color);
                            string  classValue = string.Format("{0}, {1}, {2}", newValue, true, true);
                            uniqueValueRenderer.AddValue(classValue, string.Empty, symbol);

                            // ReSharper disable UseIndexedProperty
                            string label = string.Format("{0} (Detail images)", newValue);
                            uniqueValueRenderer.set_Label(classValue, label);
                            // ReSharper restore UseIndexedProperty
                            activeView.ContentsChanged();
                        }
                    }

                    foreach (var value in forbiddenAdded)
                    {
                        bool realAdd  = true;
                        var  newValue = (int)Math.Floor(((double)value) / 4);

                        for (int i = newValue; i < (newValue + 4); i++)
                        {
                            realAdd = (!YearToColor.ContainsKey(i)) && realAdd;
                        }

                        if (realAdd)
                        {
                            Color   color      = YearToColor.ContainsKey(value) ? YearToColor[value] : Color.Transparent;
                            ISymbol symbol     = ArcUtils.GetForbiddenSymbol(SizeLayer, color);
                            string  classValue = string.Format("{0}, {1}, {2}", newValue, false, false);
                            uniqueValueRenderer.AddValue(classValue, string.Empty, symbol);

                            // ReSharper disable UseIndexedProperty
                            string label = string.Format("{0} (No Authorization)", newValue);
                            uniqueValueRenderer.set_Label(classValue, label);
                            // ReSharper restore UseIndexedProperty

                            if (pipAdded.Contains(value))
                            {
                                classValue = string.Format("{0}, {1}, {2}", newValue, true, false);
                                uniqueValueRenderer.AddValue(classValue, string.Empty, symbol);

                                // ReSharper disable UseIndexedProperty
                                label = string.Format("{0} (Detail images, No Authorization)", newValue);
                                uniqueValueRenderer.set_Label(classValue, label);
                                // ReSharper restore UseIndexedProperty
                            }

                            activeView.ContentsChanged();
                        }
                    }

                    var removed = (from yearColor in YearToColor
                                   select yearColor.Key
                                   into year
                                   where ((!YearInsideRange((int)Math.Floor(((double)year) / 4), (((year % 4) * 3) + 1))) && (!added.Contains(year)))
                                   select year).ToList();

                    foreach (var year in removed)
                    {
                        var newYear = (int)Math.Floor(((double)year) / 4);

                        if (YearPip.Contains(year))
                        {
                            string classValuePip = string.Format("{0}, {1}, {2}", newYear, true, true);
                            uniqueValueRenderer.RemoveValue(classValuePip);
                            YearPip.Remove(year);
                        }

                        string classValue = string.Format("{0}, {1}, {2}", newYear, false, true);
                        uniqueValueRenderer.RemoveValue(classValue);
                        YearToColor.Remove(year);
                    }
                }
            }

            foreach (var value in added)
            {
                var newValue = (int)Math.Floor(((double)value) / 4);
                FrmGlobespotter.UpdateColor(this, newValue);
            }
        }