private void btnApply_Click(object sender, EventArgs e)
{
IVirtualItemFilter filter = this.Filter;
if (this.OnApplyFilter != null)
{
this.OnApplyFilter(this, new ApplyFilterEventArgs(filter));
}
this.StoredFilter = filter;
this.filterControlComplex.SaveComponentSettings();
this.filterControlComplex.LoadComponentSettings();
this.btnApply.Enabled = false;
this.filterControlComplex.SelectFirst(false);
}
public SimpleCustomizeFolder(ICustomizeFolder source)
{
this.FAutoSizeColumns = source.AutoSizeColumns;
this.FColumns = source.Columns;
this.FIcon = source.Icon;
this.FFilter = source.Filter;
this.FSort = source.Sort;
this.FListColumnCount = source.ListColumnCount;
this.FThumbnailSize = source.ThumbnailSize;
this.FThumbnailSpacing = source.ThumbnailSpacing;
this.FView = source.View;
this.FBackColor = source.BackColor;
this.FForeColor = source.ForeColor;
}
public CopyWorker(IEnumerable<IVirtualItem> items, IVirtualFolder dest, CopySettings settings, CopyWorkerOptions copyOptions, IVirtualItemFilter filter, IRenameFilter renameFilter)
{
this.FSnapshotLock = new object();
this.FTotalProcessed = new ProcessedSize();
this.FStoredProgress = -1;
this.FCopyBufferSize = 0x40000;
if (items == null)
{
throw new ArgumentNullException("items");
}
if (dest == null)
{
throw new ArgumentNullException("dest");
}
if (!VirtualItemHelper.CanCreateInFolder(dest))
{
throw new ArgumentException(string.Format(Resources.sCannotCopyToBasicFolder, dest.FullName));
}
this.FContent = new AggregatedVirtualFolder(items);
ICloneable cloneable = dest as ICloneable;
if (cloneable != null)
{
this.FDest = (IVirtualFolder) cloneable.Clone();
}
else
{
this.FDest = dest;
}
this.FCopyOptions = copyOptions;
if (settings != null)
{
this.FCopyOptions |= settings.DefaultCopyOptions & (CopyWorkerOptions.CopyFolderTime | CopyWorkerOptions.ClearROFromCD);
this.FCopyBufferSize = settings.CopyBufferSize;
}
this.FFilter = filter;
this.FRenameFilter = renameFilter;
if (this.FRenameFilter != null)
{
this.FRenameContent = new Dictionary<IVirtualItem, int>();
foreach (IVirtualItem item in items)
{
this.FRenameContent.Add(item, 0);
}
}
this.Buffer1 = new byte[this.FCopyBufferSize];
}
public static bool HasContentFilter(IVirtualItemFilter filter)
{
if (filter is CustomContentFilter)
{
return true;
}
AggregatedVirtualItemFilter filter2 = filter as AggregatedVirtualItemFilter;
if (filter2 != null)
{
foreach (IVirtualItemFilter filter3 in filter2.Filters)
{
if (HasContentFilter(filter3))
{
return true;
}
}
}
return false;
}
public override object this[string propertyName]
{
get
{
return base[propertyName];
}
set
{
string str = propertyName;
if (str != null)
{
if (!(str == "HideSysHidItems") && !(str == "UseHiddenItemsList"))
{
if ((str == "HiddenItemsList") && this.UseHiddenItemsList)
{
this.FHiddenItemsFilter = null;
this.HasHidddenItemsFilter = false;
}
}
else
{
this.FHiddenItemsFilter = null;
this.HasHidddenItemsFilter = false;
}
}
base[propertyName] = value;
}
}
protected SimpleCustomizeFolder(SerializationInfo info, StreamingContext context)
{
this.FUpdatebleParts = (CustomizeFolderParts) info.GetValue("UpdateableParts", typeof(CustomizeFolderParts));
string str = null;
int iconIndex = 0;
SerializationInfoEnumerator enumerator = info.GetEnumerator();
while (enumerator.MoveNext())
{
SerializationEntry current = enumerator.Current;
switch (current.Name)
{
case "AutoSizeColumns":
this.FAutoSizeColumns = new bool?(Convert.ToBoolean(current.Value));
break;
case "Columns":
this.FColumns = (ListViewColumnInfo[]) current.Value;
break;
case "Filter":
this.FFilter = (IVirtualItemFilter) current.Value;
break;
case "Sort":
this.FSort = (VirtualItemComparer) current.Value;
break;
case "ListColumnCount":
this.FListColumnCount = new int?(Convert.ToInt32(current.Value));
break;
case "ThumbnailSize":
this.FThumbnailSize = (Size) current.Value;
break;
case "ThumbnailSpacing":
this.FThumbnailSpacing = (Size) current.Value;
break;
case "View":
this.FView = new PanelView?((PanelView) current.Value);
break;
case "IconFile":
str = current.Value as string;
break;
case "IconIndex":
iconIndex = Convert.ToInt32(current.Value);
break;
case "BackColor":
this.FBackColor = (Color) current.Value;
break;
case "ForeColor":
this.FForeColor = (Color) current.Value;
break;
}
}
if (!string.IsNullOrEmpty(str))
{
this.FIcon = new IconLocation(str, iconIndex);
}
}
public NamedFilter(string name, IVirtualItemFilter filter) : base(filter)
{
this.Name = name;
}
private void PopulateFilters(IVirtualItemFilter CustomFilter)
{
base.BeginUpdate();
try
{
this.Items.Clear();
string[] copyFilter = HistorySettings.Default.CopyFilter;
if ((copyFilter != null) && (copyFilter.Length > 0))
{
this.Items.AddRange(copyFilter);
this.Items.Add(string.Empty);
}
NamedFilter[] filters = Settings.Default.Filters;
if ((filters != null) && (filters.Length > 0))
{
this.Items.AddRange(filters);
this.Items.Add(string.Empty);
}
this.Items.Add(new NamedFilter(Resources.sCustomFilter, CustomFilter));
}
finally
{
base.EndUpdate();
}
}
public static bool FilterEquals(IVirtualItemFilter filter1, IVirtualItemFilter filter2)
{
return (((filter1 == null) && (filter2 == null)) || (((filter1 != null) && (filter2 != null)) && filter1.Equals(filter2)));
}
public bool Execute(IWin32Window owner)
{
this.cmbFilterTemplate.SetItems<NamedFilter>(Settings.Default.Filters, delegate (NamedFilter x) {
return x.Name;
});
this.StoredFilter = this.Filter;
if (this.StoredFilter != null)
{
for (int i = 0; i < this.cmbFilterTemplate.Items.Count; i++)
{
if (this.StoredFilter.Equals(this.cmbFilterTemplate.GetValue<FilterContainer>(i).Filter))
{
this.cmbFilterTemplate.SelectedIndex = i;
break;
}
}
}
if (base.ShowDialog(owner) == DialogResult.OK)
{
this.filterControlComplex.SaveComponentSettings();
return true;
}
return false;
}
public ListViewHighlighter(string name, IVirtualItemFilter filter) : base(name, filter)
{
this.ForeColor = Color.Empty;
}
public VirtualHighligher(string name, IVirtualItemFilter filter) : base(name, filter)
{
this.IconType = HighlighterIconType.ExtractedIcon;
this.BlendColor = Color.White;
this.BlendLevel = 0.5f;
}
public void SetFilter(IVirtualItemFilter filter)
{
base.CanRaiseFilterChanged = false;
try
{
VirtualItemDateFilter filter2 = filter as VirtualItemDateFilter;
if (filter2 != null)
{
this.cmbDate.SelectedIndex = (int) filter2.DatePart;
this.cmbDateOperation.SelectedIndex = (int) filter2.DateComparision;
this.dtpDateFrom.Value = filter2.FromDate;
this.dtpDateTo.Value = filter2.ToDate;
this.nudNotOlderThan.Value = filter2.NotOlderThan;
this.cmbDateMeasure.SelectedIndex = (int) filter2.DateMeasure;
}
else
{
VirtualItemTimeFilter filter3 = filter as VirtualItemTimeFilter;
if (filter3 != null)
{
this.cmbTime.SelectedIndex = (int) filter3.TimePart;
this.cmbTimeOperation.SelectedIndex = (int) filter3.TimeComparision;
DateTime date = DateTime.Now.Date;
this.dtpTimeFrom.Value = date.AddTicks(filter3.FromTime.Ticks);
this.dtpTimeTo.Value = date.AddTicks(filter3.ToTime.Ticks);
}
else
{
Nomad.Commons.SizeFilter filter4 = filter as Nomad.Commons.SizeFilter;
if (filter4 != null)
{
this.cmbSize.SelectedIndex = (int) filter4.SizeUnit;
this.cmbSizeOperation.SelectedIndex = (int) filter4.SizeComparision;
this.nudSizeFrom.Value = filter4.FromValue;
this.nudSizeTo.Value = filter4.ToValue;
}
}
}
}
finally
{
base.CanRaiseFilterChanged = true;
}
}
public ApplyFilterEventArgs(IVirtualItemFilter filter)
{
this.Filter = filter;
}
protected static Control CreateFilterControl(IVirtualItemFilter filter)
{
VirtualPropertyFilter filter2 = filter as VirtualPropertyFilter;
if (filter2 != null)
{
System.Type type;
VirtualProperty property = VirtualProperty.Get(filter2.PropertyId);
if (PropertyFilterMap.TryGetValue(property.PropertyType, out type))
{
return (Activator.CreateInstance(type, new object[] { filter2 }) as Control);
}
return null;
}
if (filter is NameFilter)
{
return new NameFilterControl((NameFilter) filter);
}
if (filter is AttributeFilter)
{
return new AttrFilterControl((AttributeFilter) filter);
}
if (filter is SizeFilter)
{
return new SizeFilterControl((SizeFilter) filter);
}
if (filter is VirtualItemDateFilter)
{
return new DateFilterControl((VirtualItemDateFilter) filter);
}
if (filter is VirtualItemTimeFilter)
{
return new TimeFilterControl((VirtualItemTimeFilter) filter);
}
if (filter is ContentFilter)
{
return new ContentFilterControl((ContentFilter) filter);
}
if (filter is HexContentFilter)
{
return new HexContentFilterControl((HexContentFilter) filter);
}
if (filter is AggregatedVirtualItemFilter)
{
return new ContainerFilterControl((AggregatedVirtualItemFilter) filter);
}
return null;
}
