protected override void ExecuteResult(
FileSystemFinderResult result,
SearchContext context,
ContentWriterOptions writerOptions,
Match match,
string input,
Encoding encoding,
string baseDirectoryPath = null,
ColumnWidths columnWidths = null)
{
string indent = GetPathIndent(baseDirectoryPath);
if (!Options.OmitPath)
{
WritePath(context, result, baseDirectoryPath, indent, columnWidths);
}
if (ContentFilter.IsNegative)
{
WriteLineIf(!Options.OmitPath, Verbosity.Minimal);
}
else
{
WriteMatches(input, match, writerOptions, context);
}
AskToContinue(context, indent);
}
public bool SettingsEqual(ISettingsObject obj)
{
ColumnWidths other = obj as ColumnWidths;
if (other == null)
{
return(false);
}
if (m_columns.Count != other.m_columns.Count)
{
return(false);
}
IDictionaryEnumerator enumerator = m_columns.GetEnumerator();
while (enumerator.MoveNext())
{
object otherValue = other.m_columns[enumerator.Key];
if (otherValue == null || (int)enumerator.Value != (int)otherValue)
{
return(false);
}
}
return(true);
}
public void Help(Verb verb, string scope = Verb.DefaultImplementorName)
{
string command = verb.Name;
string aliases = string.Empty;
if (verb.Aliases.Length > 0)
{
aliases = formatAliases(verb.Aliases);
}
string indexer = string.Empty;
if (verb.Indexer > Verb.Tag._none)
{
indexer = (verb.Indexer == Verb.Tag.required ? indexString : optionalIndexString);
}
string arguments = verb.ArgumentHelp;
ColumnWidths columnWidths = widths[scope];
string indexerPart = string.Format("{{0,-{0}}}{{{{1}}}}", optionalIndexString.Length);
string syntaxPartFormat = string.Format("{0} {{0}} {1}", prompt, string.Format(indexerPart, indexer));
string optionPartFormat = string.Format("{{0,-{0}}} {{1,-{1}}}", columnWidths.Command, columnWidths.Alias);
string optionPart = string.Format(optionPartFormat, command, aliases);
console.WriteLineBicolor(syntax, option, syntaxPartFormat, optionPart, arguments);
}
public override int GetHashCode()
{
unchecked
{
int result = ColumnWidths.Aggregate(1, (c, v) => (c * 397) ^ v.GetHashCode());
result = (result * 397) ^ RowHeights.Aggregate(1, (c, v) => (c * 397) ^ v.GetHashCode());
return(result);
}
}
protected override void ExecuteResult(
FileSystemFinderResult result,
SearchContext context,
string baseDirectoryPath = null,
ColumnWidths columnWidths = null)
{
string indent = GetPathIndent(baseDirectoryPath);
if (!Options.OmitPath)
{
WritePath(context, result, baseDirectoryPath, indent, columnWidths);
}
bool deleted = false;
if (!Options.Ask || AskToExecute(context, (Options.ContentOnly) ? "Delete content?" : "Delete?", indent))
{
try
{
if (!Options.DryRun)
{
FileSystemHelpers.Delete(
result,
contentOnly: Options.ContentOnly,
includingBom: Options.IncludingBom,
filesOnly: Options.FilesOnly,
directoriesOnly: Options.DirectoriesOnly);
deleted = true;
}
if (result.IsDirectory)
{
context.Telemetry.ProcessedDirectoryCount++;
}
else
{
context.Telemetry.ProcessedFileCount++;
}
}
catch (Exception ex) when(ex is IOException ||
ex is UnauthorizedAccessException)
{
WriteFileError(ex, indent: indent);
}
}
if (result.IsDirectory &&
deleted)
{
OnDirectoryChanged(new DirectoryChangedEventArgs(result.Path, null));
}
}
protected override void ExecuteResult(
FileSystemFinderResult result,
SearchContext context,
ContentWriterOptions writerOptions,
Match match,
string input,
Encoding encoding,
string baseDirectoryPath = null,
ColumnWidths columnWidths = null)
{
ExecuteResult(result, context, baseDirectoryPath, columnWidths);
}
private List <string> GetTrimedColumnWidths()
{
List <string> widths = new List <string>();
foreach (string width in ColumnWidths.Split(' '))
{
string trimedWith = width.Trim();
if (!String.IsNullOrEmpty(trimedWith))
{
widths.Add(trimedWith);
}
}
return(widths);
}
protected TagBuilder ColumnWidths(TagBuilder label)
{
TagBuilder widthContainer = null;
ColumnWidths columnWidths = Config.ColumnWidths;
if (Config.ColumnWidths != null)
{
widthContainer = new TagBuilder("div");
widthContainer.AddCssClass(columnWidths.RightColumn.CssClass());
this.AddCssClass(columnWidths.LeftColumn.CssClass(), label != null, label);
}
return(widthContainer);
}
public PrintGridItem(ExDataGridView dgv, bool isFit, PrintPageEventArgs e)
{
_grid = dgv;
_newPage = true;
_fitToPageWidth = true;
_pageNo = 1;
_headerTitle = String.Empty;
_headerPrinter = String.Empty;
_rowPos = 0;
_rowsPerPage = 0;
_totalWidth = 0;
int CellWidth = 0;
int PageLeft = e.MarginBounds.Left;
foreach (DataGridViewColumn GridCol in dgv.Columns)
{
if (!GridCol.Visible)
{
continue;
}
_totalWidth += GridCol.Width;
}
foreach (DataGridViewColumn GridCol in dgv.Columns)
{
if (!GridCol.Visible)
{
continue;
}
if (isFit)
{
CellWidth = (int)(Math.Floor((double)((double)GridCol.Width / (double)TotalWidth * (double)TotalWidth * ((double)e.MarginBounds.Width / (double)TotalWidth))));
}
else
{
CellWidth = GridCol.Width;
}
HeaderHeight = (int)(e.Graphics.MeasureString(GridCol.HeaderText, GridCol.InheritedStyle.Font, CellWidth).Height) + 11;
ColumnLefts.Add(PageLeft);
ColumnWidths.Add(CellWidth);
ColumnTypes.Add(GridCol.GetType());
PageLeft += CellWidth;
}
}
/// <summary>
/// Reads column widths from a <see cref="ColumnWidths"/> object and applies them to the DataGrid.
/// </summary>
public void RestoreColumnWidths(ColumnWidths widths)
{
if (widths == null)
{
return;
}
DataGridTableStyle tableStyle = CurrentTableStyle;
if (tableStyle == null)
{
return;
}
widths.Apply(tableStyle);
}
private List <int> UpdateColumnWidths(IEnumerable <string> newCellValues)
{
List <int> newColumnWidths = new List <int>();
for (int i = 0; i < Header.Count; i++)
{
if (newCellValues.ElementAt(i).Length > ColumnWidths.ElementAt(i))
{
newColumnWidths.Add(newCellValues.ElementAt(i).Length);
}
else
{
newColumnWidths.Add(ColumnWidths.ElementAt(i));
}
}
return(newColumnWidths);
}
public void Print()
{
// Prepare line separators
string titleLine = "+";
string lineSeparator = "+";
string headerLine = "+";
foreach (int columnWidth in ColumnWidths)
{
titleLine += new string('-', columnWidth + 2);
titleLine += "-";
headerLine += new string('=', columnWidth + 2);
headerLine += "+";
lineSeparator += new string('-', columnWidth + 2);
lineSeparator += "+";
}
titleLine = titleLine.Remove(titleLine.Length - 1, 1) + "+";
// Prepare line template
string lineTemplate = "| ";
for (int i = 0; i < Header.Count; i++)
{
lineTemplate += "{" + i + "} | ";
}
// Print table title if needed
if (Title != null)
{
Logger.LogInformation(titleLine);
Logger.LogInformation(string.Format("| {0} |", Title.PadRight(ColumnWidths.Sum() + ColumnWidths.Count * 2)));
}
// Print table header
Logger.LogInformation(lineSeparator);
Logger.LogInformation(string.Format(lineTemplate, PadCellValues(Header, ColumnWidths)));
Logger.LogInformation(headerLine);
// Print table lines
foreach (HashSet <string> line in Lines)
{
Logger.LogInformation(lineTemplate, PadCellValues(line, ColumnWidths));
Logger.LogInformation(lineSeparator);
}
}
public static Grid Grid(RowHeights rowHeights, ColumnWidths columnWidths, params Xaml.UIElement[] children)
{
var grid = Grid(children);
foreach (var height in rowHeights.Lengths)
{
grid.UI.RowDefinitions.Add(new Controls.RowDefinition {
Height = height
});
}
foreach (var width in columnWidths.Lengths)
{
grid.UI.ColumnDefinitions.Add(new Controls.ColumnDefinition {
Width = width
});
}
return(grid);
}
protected override void ExecuteResult(
FileSystemFinderResult result,
SearchContext context,
ContentWriterOptions writerOptions,
Match match,
string input,
Encoding encoding,
string baseDirectoryPath = null,
ColumnWidths columnWidths = null)
{
string indent = GetPathIndent(baseDirectoryPath);
if (!Options.OmitPath)
{
WritePath(context, result, baseDirectoryPath, indent, columnWidths);
}
ReplaceMatches(result.Path, encoding, input, match, indent, writerOptions, context);
}
private IHtmlContent CommonRender(TagBuilder groupLabel, Func <object, IHtmlContent> radioBtnFunc)
{
TagBuilder group = new TagBuilder("div");
ColumnWidths columnWidths = _config.ColumnWidths;
TagBuilder widthContainer = null;
group.AddCssClass("form-group");
group.InnerHtml.AppendHtml(groupLabel);
if (columnWidths != null)
{
widthContainer = new TagBuilder("div");
widthContainer.AddCssClass(columnWidths.RightColumn.CssClass());
group.InnerHtml.AppendHtml(widthContainer);
}
this.AddCssClass(columnWidths?.LeftColumn.CssClass(), columnWidths != null && groupLabel != null, groupLabel);
foreach (RadioButtonConfig radioButtonConfig in _config.RadioButtons)
{
TagBuilder container = new TagBuilder("div");
TagBuilder radioButton = this.TagBuilderFromHtmlContent(radioBtnFunc(radioButtonConfig.Value), false);
TagBuilder label = new TagBuilder("label");
this.AddAttribute("disabled", _config.Disabled, radioButton);
radioButton.AddCssClass("form-check-input");
label.AddCssClass("form-check-label");
container.AddCssClass("form-check");
container.InnerHtml.AppendHtml(radioButton);
container.InnerHtml.AppendHtml(label);
this.AddCssClasses(radioButtonConfig.CssClasses, container);
this.AddCssClass("form-check-inline", _config.Horizontal, container);
if (!string.IsNullOrEmpty(radioButtonConfig.Label))
{
label.InnerHtml.Append(radioButtonConfig.Label);
}
(widthContainer ?? group).InnerHtml.AppendHtml(container);
TooltipRenderer.Render(radioButton, radioButtonConfig.Tooltip);
}
return(group);
}
protected override void ExecuteResult(
FileSystemFinderResult result,
SearchContext context,
string baseDirectoryPath,
ColumnWidths columnWidths)
{
string indent = GetPathIndent(baseDirectoryPath);
List <ReplaceItem> replaceItems = GetReplaceItems(result, context.CancellationToken);
string path = result.Path;
string newPath = GetNewPath(result, replaceItems);
bool changed = !string.Equals(path, newPath, StringComparison.Ordinal);
if (!Options.OmitPath &&
changed)
{
LogHelpers.WritePath(
result,
replaceItems,
baseDirectoryPath,
relativePath: Options.DisplayRelativePath,
colors: Colors.Matched_Path,
matchColors: (Options.HighlightMatch) ? Colors.Match : default,
public void Add(Verb verb)
{
string scope = verb.ImplementorName;
if (0 != string.Compare(scope, Verb.DefaultImplementorName))
{
if (!widths.ContainsKey(scope))
{
widths.Add(scope, new ColumnWidths()
{
Command = 0, Alias = 0
});
}
ColumnWidths scopedColumnWidths = widths[scope];
scopedColumnWidths.Command = Math.Max(scopedColumnWidths.Command, verb.Name.Length);
scopedColumnWidths.Alias = Math.Max(scopedColumnWidths.Alias, formatAliases(verb.Aliases).Length);
widths[scope] = scopedColumnWidths;
}
ColumnWidths allColumnWidths = widths[Verb.DefaultImplementorName];
allColumnWidths.Command = Math.Max(allColumnWidths.Command, verb.Name.Length);
allColumnWidths.Alias = Math.Max(allColumnWidths.Alias, formatAliases(verb.Aliases).Length);
widths[Verb.DefaultImplementorName] = allColumnWidths;
}
protected override void ExecuteResult(SearchResult result, SearchContext context, ColumnWidths columnWidths)
{
ExecuteResult(result.Result, context, result.BaseDirectoryPath, columnWidths);
}
protected override void ExecuteResult(FileSystemFinderResult result, SearchContext context, string baseDirectoryPath = null, ColumnWidths columnWidths = null)
{
string indent = GetPathIndent(baseDirectoryPath);
if (!Options.OmitPath)
{
WritePath(context, result, baseDirectoryPath, indent, columnWidths);
}
AskToContinue(context, indent);
}
protected override void ExecuteResult(FileSystemFinderResult result, SearchContext context, string baseDirectoryPath = null, ColumnWidths columnWidths = null)
{
string indent = GetPathIndent(baseDirectoryPath);
if (!Options.OmitPath)
{
WritePath(context, result, baseDirectoryPath, indent, columnWidths);
}
if (_storage != null &&
result.Match != null &&
!object.ReferenceEquals(result.Match, Match.Empty))
{
_storage.Add(result.Match.Value);
}
AskToContinue(context, indent);
}
protected sealed override void ExecuteResult(FileSystemFinderResult result, SearchContext context, string baseDirectoryPath = null, ColumnWidths columnWidths = null)
{
ExecuteOperation(result, context, baseDirectoryPath, GetPathIndent(baseDirectoryPath));
if (context.TerminationReason != TerminationReason.Canceled)
{
AskToContinue(context, GetPathIndent(baseDirectoryPath));
}
}
protected void WritePath(SearchContext context, FileSystemFinderResult result, string baseDirectoryPath, string indent, ColumnWidths columnWidths, ConsoleColors matchColors)
{
if (Options.PathDisplayStyle == PathDisplayStyle.Match &&
result.Match != null &&
!object.ReferenceEquals(result.Match, Match.Empty))
{
if (ShouldLog(Verbosity.Minimal))
{
Write(indent, Verbosity.Minimal);
Write(result.Match.Value, (Options.HighlightMatch) ? matchColors : default, Verbosity.Minimal);
protected abstract void ExecuteResult(FileSystemFinderResult result, SearchContext context, string baseDirectoryPath, ColumnWidths columnWidths);
protected abstract void ExecuteResult(SearchResult result, SearchContext context, ColumnWidths columnWidths);
public static Grid Grid(ColumnWidths columnWidths, params Xaml.UIElement[] children) => Grid(Rows(), columnWidths, children);
protected virtual void WritePath(SearchContext context, FileSystemFinderResult result, string baseDirectoryPath, string indent, ColumnWidths columnWidths)
{
WritePath(context, result, baseDirectoryPath, indent, columnWidths, Colors.Match);
WriteLine(Verbosity.Minimal);
}
private void ExecuteResults(SearchContext context)
{
IEnumerable <SearchResult> results = context.Results !;
SortOptions?sortOptions = Options.SortOptions;
if (sortOptions?.Descriptors.Any() == true)
{
PathDisplayStyle pathDisplayStyle = Options.PathDisplayStyle;
if (pathDisplayStyle == PathDisplayStyle.Match &&
NameFilter == null)
{
pathDisplayStyle = PathDisplayStyle.Full;
}
results = SortHelpers.SortResults(context.Results !, sortOptions, pathDisplayStyle);
if (sortOptions.MaxCount > 0)
{
results = results.Take(sortOptions.MaxCount);
}
}
ImmutableArray <FileProperty> fileProperties = Options.Format.FileProperties;
ColumnWidths?columnWidths = null;
if (fileProperties.Any() &&
Options.Format.AlignColumns)
{
List <SearchResult> resultList = results.ToList();
int maxNameWidth = resultList.Max(f => f.Path.Length);
int maxSizeWidth = 0;
if (fileProperties.Contains(FileProperty.Size))
{
long maxSize = 0;
foreach (SearchResult result in resultList)
{
long size = result.GetSize();
if (result.IsDirectory)
{
if (context.DirectorySizeMap == null)
{
context.DirectorySizeMap = new Dictionary <string, long>();
}
context.DirectorySizeMap[result.Path] = size;
}
if (size > maxSize)
{
maxSize = size;
}
}
maxSizeWidth = maxSize.ToString("n0").Length;
}
columnWidths = new ColumnWidths(maxNameWidth, maxSizeWidth);
results = resultList;
}
int i = 0;
try
{
foreach (SearchResult result in results)
{
ExecuteResult(result, context, columnWidths);
i++;
if (context.TerminationReason == TerminationReason.Canceled)
{
break;
}
context.CancellationToken.ThrowIfCancellationRequested();
}
}
catch (OperationCanceledException)
{
context.TerminationReason = TerminationReason.Canceled;
}
if (context.TerminationReason == TerminationReason.Canceled ||
context.CancellationToken.IsCancellationRequested)
{
OperationCanceled();
}
if (Options.Format.FileProperties.Contains(FileProperty.Size) &&
context.Telemetry.FilesTotalSize == 0)
{
foreach (SearchResult result in results.Take(i))
{
context.Telemetry.FilesTotalSize += result.GetSize();
}
}
}
protected override void ExecuteResult(FileSystemFinderResult result, SearchContext context, string baseDirectoryPath = null, ColumnWidths columnWidths = null)
{
base.ExecuteResult(result, context, baseDirectoryPath, columnWidths);
ExecuteOperation(result, context, baseDirectoryPath, GetPathIndent(baseDirectoryPath));
}
