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();
}
private info_type info_key(snoop_around_form self)
{
lock (this) {
var find = snoops_.FirstOrDefault(x => x.Value.form == self);
return(find.Key);
}
}
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");
}
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);
}
}
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;
}
public snoop_around_expander_ctrl(snoop_around_form parent) {
parent_ = parent;
InitializeComponent();
// don't ever steal focus http://stackoverflow.com/questions/785672/is-there-a-way-to-make-a-usercontrol-unfocussable
SetStyle(ControlStyles.Selectable, false);
control_width_ = expand.Width;
control_height_ = expand.Height;
BackColor = Color.White;
reapplyFilter.BackgroundImage = reapply_ ? filter_applied : filter_not_applied;
update_pos();
}
public snoop_around_expander_ctrl(snoop_around_form parent)
{
parent_ = parent;
InitializeComponent();
// don't ever steal focus http://stackoverflow.com/questions/785672/is-there-a-way-to-make-a-usercontrol-unfocussable
SetStyle(ControlStyles.Selectable, false);
control_width_ = expand.Width;
control_height_ = expand.Height;
BackColor = Color.White;
reapplyFilter.BackgroundImage = reapply_ ? filter_applied : filter_not_applied;
update_pos();
}
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
});
}
}
}
public snoop_around_form snoop_for(info_type type)
{
Debug.Assert(!disposed_);
Debug.Assert(info_type_io.is_snoopable(type));
lock (this) {
if (!snoops_.ContainsKey(type))
{
/*if(unused_.Count > 0) {
* var use_now = unused_[0];
* unused_.RemoveAt(0);
* use_now.clear();
* snoops_.Add(type, use_now);
* } else {*/
var form = new snoop_around_form();
form.on_apply = on_apply;
form.on_snoop = on_snoop;
snoops_.Add(type, new snoop_form_info {
form = form
});
//}
}
return(snoops_[type].form);
}
}
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;
}
}
new public void Dispose()
{
parent_ = null;
base.Dispose();
}
