public GeocacheWaypoint(GeocacheWaypoint other)
     : base(other)
 {
     Difficulty          = other.Difficulty;
     Terrain             = other.Terrain;
     Container           = other.Container;
     CacheType           = other.CacheType;
     Code                = other.Code;
     Owner               = other.Owner;
     Hint                = other.Hint;
     Found               = other.Found;
     Available           = other.Available;
     LongDescription     = other.LongDescription;
     Logs                = new ObservableCollection <GeocacheLog>(other.Logs);
     DescriptionParts    = new ObservableCollection <GeocacheDescriptionItem>(other.DescriptionParts);
     Pictures            = new ObservableCollection <GeocachePicture>(other.Pictures);
     Attributes          = new ObservableCollection <GeocacheAttribute>(other.Attributes);
     AdditionalWaypoints = new List <Waypoint>();
     foreach (Waypoint wp in other.AdditionalWaypoints)
     {
         AdditionalWaypoints.Add(wp.Clone());
     }
     OwnerID = other.OwnerID;
 }
        public bool IsFilterOut(Waypoint waypoint)
        {
            if (waypoint.GetType() == typeof(GeocacheWaypoint))
            {
                GeocacheWaypoint gc = (GeocacheWaypoint)waypoint;

                if (gc.Difficulty < mDifficultyFrom || gc.Difficulty > mDifficultyTo)
                {
                    return(true);
                }
                if (gc.Terrain < mTerrainFrom || gc.Terrain > mTerrainTo)
                {
                    return(true);
                }

                if (HideMyFinds && gc.Found)
                {
                    return(true);
                }

                if (HideInactiveCaches && !gc.Available)
                {
                    return(true);
                }

                if (!CacheTypeTraditional && gc.CacheType == GeocacheType.Traditional)
                {
                    return(true);
                }

                if (!CacheTypeMulti && gc.CacheType == GeocacheType.Multi)
                {
                    return(true);
                }

                if (!CacheTypeUnknown && gc.CacheType == GeocacheType.Mystery)
                {
                    return(true);
                }

                if (!CacheTypeEarth && gc.CacheType == GeocacheType.Earthcache)
                {
                    return(true);
                }

                if (!CacheTypeEvent && gc.CacheType == GeocacheType.Event)
                {
                    return(true);
                }

                if (!CacheTypeWhereigo && gc.CacheType == GeocacheType.Whereigo)
                {
                    return(true);
                }

                if (!CacheTypeVirtual && gc.CacheType == GeocacheType.Virtual)
                {
                    return(true);
                }

                if (!CacheTypeWebcam && gc.CacheType == GeocacheType.Webcam)
                {
                    return(true);
                }

                if (!CacheTypeMegaEvent && gc.CacheType == GeocacheType.MegaEvent)
                {
                    return(true);
                }

                if (!CacheTypeLetterbox && gc.CacheType == GeocacheType.Letterbox)
                {
                    return(true);
                }

                if (!CacheTypeTrashOut && gc.CacheType == GeocacheType.TrashOut)
                {
                    return(true);
                }

                if (Name.Length > 0 && !gc.Description.Contains(Name))
                {
                    return(true);
                }

                if (Owner.Length > 0 && !gc.Owner.Contains(Owner))
                {
                    return(true);
                }

                if (gc.Container == GeocacheSize.Micro && !CacheSizeMicro)
                {
                    return(true);
                }

                if (gc.Container == GeocacheSize.Small && !CacheSizeSmall)
                {
                    return(true);
                }

                if (gc.Container == GeocacheSize.Regular && !CacheSizeRegular)
                {
                    return(true);
                }

                if (gc.Container == GeocacheSize.Big && !CacheSizeBig)
                {
                    return(true);
                }
            }

            return(false);
        }
        public override Waypoint Clone()
        {
            GeocacheWaypoint copy = new GeocacheWaypoint(this);

            return(copy);
        }