示例#1
0
 private snoop_form_info info(snoop_around_form self) {
     lock (this) {
         var find = snoops_.Values.FirstOrDefault(x => x.form == self);
         Debug.Assert(find != null);
         return find;
     }
 }
示例#2
0
 private void add_values(snoop_around_form snoop, ref bool stop) {
     logger.Debug("entered test_snoop_form.add_values");
     while (!stop) {
         Thread.Sleep(3000);
         if (stop)
             break;
         Dictionary<string, int> v;
         switch (add_snoop_idx++) {
         case 0:
             v = v0;
             break;
         case 1:
             v = v1;
             break;
         default:
             v = v2;
             break;
         }
         bool all_done = add_snoop_idx >= 3;
         snoop.set_values(v, all_done, all_done);
         if (all_done)
             break;
     }
     logger.Debug("exited test_snoop_form.add_values");
 }
示例#3
0
        public test_snoop_form()
        {
            InitializeComponent();
            var snoop_a = new snoop_around_form();

            snoop_a.set_parent_rect(this, new Rectangle(a.Location, a.Size) );
            snoop_a.on_snoop = add_values;
        }
示例#4
0
 internal snoop_filter(log_view view) {
     view_ = view;
     // add the most of possible snoops
     foreach ( info_type type in Enum.GetValues(typeof(info_type)))
         if (info_type_io.is_snoopable(type)) {
             var form = new snoop_around_form();
             form.on_apply = on_apply;
             form.on_snoop = on_snoop;
             unused_.Add( new snoop_form_info { form = form } );
         }
 }
示例#5
0
        private void on_snoop(snoop_around_form self, ref bool keep_running) {
            var info = this.info(self);
            if (info.snoop_selection.Count > 0) {
                // in this case, user selected at least something,
                // and then applied the selection - thus, no re-snooping
                self.reuse_last_values();
                return;
            }

            // we cannot be visible if users doesn't have any rows
            int sel = view_.sel_row_idx;
            if (sel <= 0)
                sel = 0;
            if ( info.snoop_sel >= 0)
                if (Math.Abs(info.snoop_sel - sel) <= app.inst.reuse_snoop_surrounding) {
                    // we already snooped near by, reuse that
                    self.reuse_last_values();
                    return;
                }

            // here, I know for sure I need to (re)snoop
            int all = view_.item_count;
            bool snoop_all = all <= app.inst.snoop_all_if_entries_less_than;
            int min = 0, max = all;
            if (!snoop_all) {
                var surrounding = util.surrounding(sel, app.inst.snoop_surrounding_entries, 0, all);
                min = surrounding.Item1;
                max = surrounding.Item2;
            }

            var type = info_key(self);
            int snoop_idx = 0;
            Dictionary< string, int> values = new Dictionary<string, int>();
            // update 
            int snoop_update_ui_step = (max - min) / app.inst.snoop_update_ui_times;
            for (int idx = min; idx < max; ++idx) {
                var i = view_.item_at(idx) as filter.match;
                var cur_value = i.line.part(type);
                if ( !values.ContainsKey(cur_value))
                    values.Add(cur_value, 0);
                ++values[cur_value];

                if (++snoop_idx % snoop_update_ui_step == 0)
                    if (keep_running) 
                        // ... set to a copy, since we're modifying this one
                        self.set_values(values.ToDictionary(x => x.Key, x => x.Value), false, false);
                    else 
                        break;
            }

            if (keep_running) {
                self.set_values(values, true, snoop_all);
                info.snoop_sel = sel;
            }
        }
示例#6
0
 private info_type info_key(snoop_around_form self) {
     lock (this) {
         var find = snoops_.FirstOrDefault(x => x.Value.form == self);
         return find.Key;
     }
 }
示例#7
0
        private void on_apply(snoop_around_form self, List<string> selection, bool used) {
            var new_sel = new HashSet<string>(selection);
            var info = this.info(self);
            bool same_snoop = info.snoop_selection.SetEquals(new_sel);
            if (same_snoop && info.selection_used == used)
                return; // nothing changed
            if (same_snoop && selection.Count == 0)
                // nothing is selected, it doesn't matter
                return;

            lock (this) {
                info.selection_used = used;
                info.snoop_selection = new_sel;

                if (!same_snoop) {
                    bool has_sel = new_sel.Count > 0;
                    if (info.apply_index >= 0)
                        // all snoops with a higher index, are cleared (the selection changed, thus, they need to be re-done)
                        foreach (var snoop in snoops_.Values)
                            if (snoop.apply_index > info.apply_index)
                                snoop.clear();

                    if (!has_sel)
                        // user cleared this snoop
                        info.clear();

                    if (has_sel && info.apply_index < 0) {
                        // need to find out the apply_index
                        int max_apply = snoops_.Values.Max(x => x.apply_index);
                        info.apply_index = max_apply + 1;
                    }

                    // all snoops that did not have a selection yet, they need re-doing
                    foreach (var snoop in snoops_.Values)
                        if (snoop.apply_index < 0)
                            snoop.clear();
                }
            }
            view_.reapply_quick_filter();
        }