public void Execute(object parameter)
        {
            var layer        = (Data.Layer)parameter;
            var useSelection = Enumerable.Any(layer.Selection, item => item is Data.Point);

            var usePaths    = new List <Data.Path>();
            var retainPaths = new List <Data.Path>();

            Data.Path refPath = null;
            foreach (var path in layer.Paths)
            {
                if (path.IsOpen)
                {
                    retainPaths.Add(path);
                }
                //else
                //{
                if (refPath == null && Enumerable.Any(path.Points, point => point.IsSelected))
                {
                    refPath = path;
                }
                else
                {
                    usePaths.Add(path);
                }
                //}
            }
            // TODO: consider dropping this behavior, more confusing than useful
            if (refPath == null)
            {
                refPath = usePaths.Last();
                usePaths.RemoveAt(usePaths.Count - 1);
            }

            var refPathArray = new Data.Path[] { refPath };

            if (BooleanOps.HasOverlaps(usePaths, refPathArray))
            {
                var resultPaths = BooleanFunc(usePaths, refPathArray);

                using (var group = layer.CreateUndoGroup())
                {
                    layer.Paths.Clear();
                    layer.Paths.AddRange(resultPaths);
                    layer.Paths.AddRange(retainPaths);

                    ((App)Application.Current).InvalidateData();
                }
            }
        }
Example #2
0
        public void Execute(object parameter)
        {
            var layer        = (Data.Layer)parameter;
            var useSelection = Enumerable.Any(layer.Selection, item => item is Data.Point);

            var usePaths    = new List <Data.Path>();
            var retainPaths = new List <Data.Path>();

            foreach (var path in layer.Paths)
            {
                if (path.IsOpen)
                {
                    retainPaths.Add(path);
                }
                else
                {
                    if (useSelection && !Enumerable.Any(path.Points, point => point.IsSelected))
                    {
                        retainPaths.Add(path);
                    }
                    else
                    {
                        usePaths.Add(path);
                    }
                }
            }

            if (BooleanOps.HasOverlaps(usePaths))
            {
                var resultPaths = BooleanOps.Union(usePaths);

                using (var group = layer.CreateUndoGroup())
                {
                    layer.Paths.Clear();
                    layer.Paths.AddRange(resultPaths);
                    layer.Paths.AddRange(retainPaths);

                    ((App)Application.Current).InvalidateData();
                }
            }
        }
Example #3
0
        private string BuildFilter()
        {
            string       fieldName  = ((DBMap)dgvFilters.Rows[0].Cells["columnDBColumn"].Value).InternalField;
            string       searchText = (string)dgvFilters.Rows[0].Cells["columnCriteria"].Value;
            SqlOperators operation  = (SqlOperators)dgvFilters.Rows[0].Cells["columnOption"].Value;

            if (tableName.Equals("Survey"))
            {
                if (fieldName.Equals("county_id"))
                {
                    int countyID = RuntimeVars.Instance.Counties.Find(c => c.CountyName.ToLower().Contains(searchText.ToLower())).ID;
                    searchText = countyID.ToString();
                    operation  = SqlOperators.Like;
                }
            }

            //Always add the first row to the filter list.
            filters = new ArrayList
            {
                new Filter(fieldName, operation, searchText)
            };

            //If there are more rows, continue adding filters that build on each other.
            if (dgvFilters.Rows.Count > 1)
            {
                for (int i = 1; i < dgvFilters.Rows.Count; i++)
                {
                    DataGridViewRow currentRow = dgvFilters.Rows[i];

                    fieldName  = ((DBMap)currentRow.Cells["columnDBColumn"].Value).InternalField;
                    searchText = (string)currentRow.Cells["columnCriteria"].Value;
                    operation  = (SqlOperators)currentRow.Cells["columnOption"].Value;

                    if (tableName.Equals("Survey"))
                    {
                        if (fieldName.Equals("county_id"))
                        {
                            int countyID = RuntimeVars.Instance.Counties.Find(c => c.CountyName.ToLower().Contains(searchText.ToLower())).ID;
                            searchText = countyID.ToString();
                            operation  = SqlOperators.Like;
                        }
                    }

                    Filter f = new Filter(fieldName, operation, searchText);

                    BooleanOps op = (BooleanOps)currentRow.Cells["columnBoolean"].Value;
                    switch (op)
                    {
                    case BooleanOps.AND:
                        filters.Add(new ANDFilter((IFilter)filters[i - 1], f));
                        break;

                    case BooleanOps.OR:
                        filters.Add(new ORFilter((IFilter)filters[i - 1], f));
                        break;
                    }
                }
            }

            //Return the final filter string in the FilterExpressionList.
            return(((IFilter)filters[filters.Count - 1]).FilterString);
        }