public static DataTable SelectCriteriaDataByType(int DeptID, FilterType ftype, int TicketCriteriaID)
 {
     SqlParameter _pTicketCriteriaId=new SqlParameter("@TicketCriteriaId", SqlDbType.Int);
     if (TicketCriteriaID!=0) _pTicketCriteriaId.Value=TicketCriteriaID;
     else _pTicketCriteriaId.Value=DBNull.Value;
     return SelectRecords("sp_SelectTicketCriteriaDataByType", new SqlParameter[]{new SqlParameter("@DId", DeptID), new SqlParameter("@FilterType", (byte)ftype), _pTicketCriteriaId});
 }

 public ItemList Find(FilterType type, string key)
 {
     Request request = new Request(ItemAction.Search, type, key);
     request.SendPackage(_sck);
     Response response = (Response)Response.ReceivePackage(_sck);
     return response.data;
 }

 public Delete(string table, Select select, bool allowMultiple)
 {
     Table.Name = table;
     AllowMultiple = allowMultiple;
     Select = select;
     Filter = FilterType.Select;
 }

 public Request(ItemAction action,FilterType type,string filter_key)
 {
     this.action     = action;
        this.data       = null;
        this.filter     = type;
        this.filter_key = filter_key;
 }

 public FilterConfig()
 {
     Type = FilterType.None;
     Bypassed = true;
     Filter = null;
     _filterNames = new string[10];
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="FilterViewModel"/> class.
        /// </summary>
        /// <param name="filterInfo">The filter information.</param>
        /// <param name="filterType">Type of the filter.</param>
        public FilterViewModel(IFilterInfo filterInfo, FilterType filterType)
        {
            if (filterInfo == null)
                return;

            IsAdmin = filterInfo.IsAdminFilter.HasValue && filterInfo.IsAdminFilter.Value;
            _filterType = filterType;
            OriginalName = _name = filterInfo.Name;
            Id = filterInfo.Id;
            _originalFilterDefinitions = filterInfo.FilterDefinition;

            SortDescriptors = filterInfo.SortDescriptors;
            GroupColumn = filterInfo.GroupColumn;

            FilterGuid = filterInfo.Guid;

            DefaultLayoutId = filterInfo.DefaultLayoutId == 0 ? (int?) null : filterInfo.DefaultLayoutId;
            Layout = filterInfo.DefaultLayout;

            if (filterInfo.QuickFilterId != null)
            {
                QuickFilterId = filterInfo.QuickFilterId.Value;
                if ((QuickFilters) QuickFilterId.Value != QuickFilters.None)
                    QuickFilter = (QuickFilters) QuickFilterId.Value;
            }
        }

		private IEnumerable<Image> GetDBImageList (FilterType filterType, int userId)
		{
			lock (Database.Main)
			{
				if (filterType == FilterType.Recent)
				{
					return Database.Main.Table<Image>().OrderByDescending(el => el.Time);
				}
				if (filterType == FilterType.Friends)
				{
					List<Follow> friends = Database.Main.Table<Follow>().Where(el => el.FollowerId == userId).ToList();					
					var images = new List<Image>();
					//Add my friends photos
					foreach (Follow friend in friends)
					{
						images.AddRange(GetImagesOfUser(friend.UserId));
					}
					//Add my own photos
					images.AddRange(GetImagesOfUser(userId));
					
					return images.OrderByDescending(el => el.Time);
				}
				if (filterType == FilterType.Liked)
				{
					int minLikes = 1;
					var dateFrom = DateTime.UtcNow.Subtract(TimeSpan.FromDays(2));
					var recentImages = Database.Main.Table<Image>().Where(el => el.Time >= dateFrom).ToList();
					return recentImages.Where(el => GetLikedCount(el) >= minLikes).OrderByDescending(el => GetLikedCount(el));
				}
			}
			return new List<Image>();
		}

        private string getSyncFilename(FilterType filterType)
        {

            string folder = @"C:\simatek\";

            switch (filterType)
            {
                case FilterType.TestTemplate:
                    {
                        return folder + "TestTemplate.bin";
                    }
                case FilterType.EnglishTemplate:
                    {
                        return folder + "EnglishTemplate.bin";
                    }
                case FilterType.DanishTemplate:
                    {
                        return folder + "DanishTemplate.bin";
                    }
                case FilterType.DeutschTemplate:
                    {
                        return folder + "DeutschTemplate.bin";
                    }
            }

            throw new Exception("Forkert filter type");
        }

 public override void filterItems(FilterType newFiler)
 {
     Filter = newFiler;
     bookView.Nodes.Clear();
     ((MainWindow)parent).fillBooks(this);
     activated();
 }

        internal static Filter CreateFilter(IPrimitiveReader reader, FilterType filterType)
        {
            Filter filter;

            switch (filterType)
            {
                case FilterType.And:                    
                    filter = new AndFilter();                    
                    break;

                case FilterType.Or:
                    filter = new OrFilter();                    
                    break;

                case FilterType.Condition:
                    filter = new Condition();                    
                    break;
                    
                default:
                    throw new Exception("Unknown FilterType " + filterType);
            }

            Serializer.Deserialize(reader.BaseStream, filter);
            return filter;
        }

		public TimelineViewController (FilterType filterType, bool pushing, UINavigationController msp, 
		                               IMapLocationRequest maplocationRequest) 
			: base(pushing)
		{
			_FilterType = filterType;
			_MapLocationRequest = maplocationRequest;
			
			ShowLoadMorePhotos = true;

			this.TableView.SeparatorStyle = UITableViewCellSeparatorStyle.None;
			this.TableView.BackgroundColor = new UIColor (226f, 231f, 237f, 1f);
			this.TableView.AllowsSelection = false;

			switch(filterType)
			{
				case FilterType.Friends:
					TableView.BackgroundView = new UIImageView(Graphics.GetImgResource("fond1"));
					break;
				case FilterType.Recent:
					TableView.BackgroundView = new UIImageView(Graphics.GetImgResource("fond2"));
					break;
				case FilterType.All:
					TableView.BackgroundView = new UIImageView(Graphics.GetImgResource("fond3"));
					break;
			}

			_list = new List<ImageInfo>();
			_MSP = msp;
			
			OnGestSwipe += HandleOnSwipe;
		}

 public GetArrivalBoardRequest(ushort numRows, string crs, string filterCrs, FilterType filterType, int timeOffset)
 {
     this.numRows = numRows;
     this.crs = crs;
     this.filterCrs = filterCrs;
     this.filterType = filterType;
     this.timeOffset = timeOffset;
 }

 /// <summary>
 ///
 /// </summary>
 /// <param name="featureSet"></param>
 /// <param name="inFilter"></param>
 /// <param name="activeType"></param>
 /// <param name="isReadOnly"></param>
 public FeatureSelection(IFeatureSet featureSet, IDrawingFilter inFilter, FilterType activeType, bool isReadOnly)
 {
     _filter = inFilter;
     _activeType = activeType;
     _isReadOnly = isReadOnly;
     _featureSet = featureSet;
     Configure();
 }

 public IntPtr AddPreviousModeRule(FilterType filterType, KProcessorMode previousMode)
 {
     return KProcessHacker.Instance.SsAddPreviousModeRule(
         _ruleSetEntryHandle,
         filterType.ToKphSs(),
         previousMode
         );
 }

 public IntPtr AddNumberRule(FilterType filterType, int number)
 {
     return KProcessHacker.Instance.SsAddNumberRule(
         _ruleSetEntryHandle,
         filterType.ToKphSs(),
         number
         );
 }

 public FilterModel(string name, string columnName, string data, FilterType type = FilterType.String, bool stringEquals = false)
 {
     this.name = name;
       if (type == FilterType.String)
     this.SetStringFilter(columnName, data, stringEquals);
       else
     this.SetNumberFilter(columnName, data);
 }

		public Filter(FilterType filterType, float frequency, float bandwidth, float sampleRate)
		{
			this.filterType = filterType;
			this.frequency = frequency;
			this.bandwidth = bandwidth;
			this.sampleRate = sampleRate;

			CreateFilter();
		}

        public ActivitiesResponse GetAllActivities(int page, int count, FilterType filter, FeedType feed, string hash, string start)
		{
			var parameters = BuildPagingParametersWithCount(page, count);
			if (filter != FilterType.All) parameters.Add("filter", filter.ToString().ToLower());
            if (feed != FeedType.AuthenticatedUser) parameters.Add("feed", feed.ToString().ToLower());
            if (!string.IsNullOrEmpty(hash)) parameters.Add("hash", hash.ToString().ToLower());
            if (!string.IsNullOrEmpty(start)) parameters.Add("start", start.ToString().ToLower());
			return _restTemplate.GetForObject<ActivitiesResponse>(BuildUrl("activity", parameters));
		}

        public Biquad(FilterType filterType, double samplerate)
        {
            Type = filterType;
            Samplerate = samplerate;

            GainDB = 0.0;
            Frequency = samplerate / 4;
            Q = 0.5;
        }

        public static IImageFilter Get(FilterType filterType)
        {
            switch (filterType)
            {
                case FilterType.BlackAndWhite:
                    return new BlackAndWhiteFilter();

            }
            return new DefaultImageFilter();
        }