private void enableDataGridCopying(object sender, DataGridRowClipboardEventArgs e)
{
var currentCell = e.ClipboardRowContent[commitsDataGrid.CurrentCell.Column.DisplayIndex];
e.ClipboardRowContent.Clear();
e.ClipboardRowContent.Add(currentCell);
}
/// <summary>
/// Copy selected stream ID
/// </summary>
private void CopyStreamList(object sender, DataGridRowClipboardEventArgs e)
{
if (e.ClipboardRowContent.Count() > 1)
{
e.ClipboardRowContent.RemoveAt(0);
}
}
public void Copy(DataGrid dataGrid, DataGridRowClipboardEventArgs e)
{
var currentCell = e.ClipboardRowContent[dataGrid.CurrentCell.Column.DisplayIndex - 1];
e.ClipboardRowContent.Clear();
e.ClipboardRowContent.Add(currentCell);
}
/// <summary>
/// Permite copiar de celda
/// </summary>
private void ClientesDataGrid_CopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
var currenCell = e.ClipboardRowContent[ClientesDataGrid.CurrentCell.Column.DisplayIndex];
e.ClipboardRowContent.Clear();
e.ClipboardRowContent.Add(currenCell);
}
private void SurveyView_CopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
//Clipboard.SetData(DataFormats.Text, this.SurveyView.SelectedIndex);
var nek = Clipboard.GetText();
this.CopySelectedStations = new List <Station>(this.SurveyView.SelectedItems.Cast <Station>().ToList());
}
private void DataGridCopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
DataGridClipboardCellContent content = new DataGridClipboardCellContent(
e.Item, e.ClipboardRowContent[0].Column, ((FileSystemItem)e.Item).Name);
e.ClipboardRowContent.Clear();
e.ClipboardRowContent.Add(content);
}
private void DataGrid_OnCopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
var grid = (DataGrid)sender;
var currentCell = e.ClipboardRowContent[grid.CurrentCell.Column.DisplayIndex];
e.ClipboardRowContent.Clear();
e.ClipboardRowContent.Add(currentCell);
}
/// <summary>
/// gridCompounder_CopyingRowClipboardContent
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void gridCompounder_CopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
int columnIndex = gridCompounder.CurrentCell.Column.DisplayIndex;
var column = gridCompounder.Columns[columnIndex];
var companyName = ((ResultSetReinvestment)e.Item).Name;
var cellContent = new DataGridClipboardCellContent(e.Item, column, companyName);
e.ClipboardRowContent.Clear();
e.ClipboardRowContent.Add(cellContent);
}
/// <summary>
/// DataGrid の選択行の内容をクリップボードにコピー。
/// Ctrl + C での標準のコピーの内容を変更する。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void datagrid_CopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
e.ClipboardRowContent.Clear();
e.ClipboardRowContent.Add(
new DataGridClipboardCellContent(
e.Item,
(sender as DataGrid).Columns[0],
e.Item.ToString()
)
);
}
private void FillClipboardRowContent(DataGridRowClipboardEventArgs args)
{
if (args.IsColumnHeadersRow)
{
for (int i = args.StartColumnDisplayIndex; i <= args.EndColumnDisplayIndex; i++)
{
DataGridColumn column = ColumnFromDisplayIndex(i);
if (!(column.Visibility == Visibility.Visible))
{
continue;
}
args.ClipboardRowContent.Add(new DataGridClipboardCellContent(args.Item, column, column.Header));
}
}
else
{
int rowIndex = args.GetRowIndexHint();
if (rowIndex < 0)
{
rowIndex = Items.IndexOf(args.Item);
}
// If row has selection
if (this.SelectedCellsIntersects(rowIndex))
{
for (int i = args.StartColumnDisplayIndex; i <= args.EndColumnDisplayIndex; i++)
{
DataGridColumn column = ColumnFromDisplayIndex(i);
if (!(column.Visibility == Visibility.Visible))
{
continue;
}
object cellValue = null;
// Get cell value only if the cell is selected - otherwise leave it null
if (this.SelectedCellsContains(rowIndex, i))
{
cellValue = column.OnCopyingCellClipboardContent(args.Item);
}
args.ClipboardRowContent.Add(new DataGridClipboardCellContent(args.Item, column, cellValue));
}
}
}
}
private void DataGrid_CopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
var fieldNames = new Dictionary <string, string>();
var columns = new List <DataGridColumn>();
foreach (var column in DynamicDataGrid.Columns)
{
if (column.Header is ColumnMetadata columnMetadata)
{
if (!fieldNames.ContainsKey(columnMetadata.AliasedFieldName ?? columnMetadata.FieldName))
{
columns.Add(column);
fieldNames.Add(columnMetadata.AliasedFieldName ?? columnMetadata.FieldName, columnMetadata.FieldLabel);
}
}
}
if (fieldNames.Any())
{
if (e.IsColumnHeadersRow)
{
e.ClipboardRowContent.Clear();
var i = 0;
foreach (var label in fieldNames.Values)
{
e.ClipboardRowContent.Add(new DataGridClipboardCellContent(e.Item, columns[i++], label));
}
}
else
{
if (e.Item is GridRowViewModel rowViewModel)
{
e.ClipboardRowContent.Clear();
var i = 0;
foreach (var field in fieldNames.Keys)
{
e.ClipboardRowContent.Add(new DataGridClipboardCellContent(e.Item, columns[i++], rowViewModel.GetFieldViewModel(field).StringDisplay));
}
}
}
}
}
private void gridEvents_CopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
// Make sure we preserve the grid format when the user copies to the clipboard
for (int i = 0; i < e.ClipboardRowContent.Count; ++i)
{
var clipboardItem = e.ClipboardRowContent[i];
string header = clipboardItem.Column.Header as string;
if (header != null)
{
if (header == "TimeStamp" && clipboardItem.Content is DateTime)
{
DateTime content = (DateTime)clipboardItem.Content;
e.ClipboardRowContent[i] = new DataGridClipboardCellContent(clipboardItem.Item, clipboardItem.Column, content.ToString("0:HH:mm:ss.ffffff"));
}
else if (header == "Delta (ms)" && clipboardItem.Content is double)
{
double content = (double)clipboardItem.Content;
e.ClipboardRowContent[i] = new DataGridClipboardCellContent(clipboardItem.Item, clipboardItem.Column, string.Format("{0:0}", content));
}
}
}
}
/// <summary>
/// This method is called to prepare the clipboard content for each selected row.
/// If ClipboardCopyMode is set to ClipboardCopyMode, then it is also called to prepare the column headers
/// </summary>
/// <param name="args">Contains the necessary information for generating the row clipboard content.</param>
protected virtual void OnCopyingRowClipboardContent(DataGridRowClipboardEventArgs args)
{
if (args.IsColumnHeadersRow)
{
for (int i = args.StartColumnDisplayIndex; i <= args.EndColumnDisplayIndex; i++)
{
DataGridColumn column = ColumnFromDisplayIndex(i);
if (!column.IsVisible)
{
continue;
}
args.ClipboardRowContent.Add(new DataGridClipboardCellContent(args.Item, column, column.Header));
}
}
else
{
int rowIndex = args.RowIndexHint;
if (rowIndex < 0)
{
rowIndex = Items.IndexOf(args.Item);
}
// If row has selection
if (_selectedCells.Intersects(rowIndex))
{
for (int i = args.StartColumnDisplayIndex; i <= args.EndColumnDisplayIndex; i++)
{
DataGridColumn column = ColumnFromDisplayIndex(i);
if (!column.IsVisible)
{
continue;
}
object cellValue = null;
// Get cell value only if the cell is selected - otherwise leave it null
if (_selectedCells.Contains(rowIndex, i))
{
cellValue = column.OnCopyingCellClipboardContent(args.Item);
}
args.ClipboardRowContent.Add(new DataGridClipboardCellContent(args.Item, column, cellValue));
}
}
}
// Raise the event to give a chance to external listeners to modify row clipboard content (e.ClipboardRow)
if (CopyingRowClipboardContent != null)
{
CopyingRowClipboardContent(this, args);
}
}
/// <summary>
/// This virtual method is called when ApplicationCommands.Copy command is executed.
/// </summary>
/// <param name="args"></param>
protected virtual void OnExecutedCopy(ExecutedRoutedEventArgs args)
{
if (ClipboardCopyMode == DataGridClipboardCopyMode.None)
{
throw new NotSupportedException(SR.Get(SRID.ClipboardCopyMode_Disabled));
}
args.Handled = true;
// Supported default formats: Html, Text, UnicodeText and CSV
Collection<string> formats = new Collection<string>(new string[] { DataFormats.Html, DataFormats.Text, DataFormats.UnicodeText, DataFormats.CommaSeparatedValue });
Dictionary<string, StringBuilder> dataGridStringBuilders = new Dictionary<string, StringBuilder>(formats.Count);
foreach (string format in formats)
{
dataGridStringBuilders[format] = new StringBuilder();
}
int minRowIndex;
int maxRowIndex;
int minColumnDisplayIndex;
int maxColumnDisplayIndex;
// Get the bounding box of the selected cells
if (_selectedCells.GetSelectionRange(out minColumnDisplayIndex, out maxColumnDisplayIndex, out minRowIndex, out maxRowIndex))
{
// Add column headers if enabled
if (ClipboardCopyMode == DataGridClipboardCopyMode.IncludeHeader)
{
DataGridRowClipboardEventArgs preparingRowClipboardContentEventArgs = new DataGridRowClipboardEventArgs(null, minColumnDisplayIndex, maxColumnDisplayIndex, true /*IsColumnHeadersRow*/);
OnCopyingRowClipboardContent(preparingRowClipboardContentEventArgs);
foreach (string format in formats)
{
dataGridStringBuilders[format].Append(preparingRowClipboardContentEventArgs.FormatClipboardCellValues(format));
}
}
// Add each selected row
for (int i = minRowIndex; i <= maxRowIndex; i++)
{
object row = Items[i];
// Row has a selecion
if (_selectedCells.Intersects(i))
{
DataGridRowClipboardEventArgs preparingRowClipboardContentEventArgs = new DataGridRowClipboardEventArgs(row, minColumnDisplayIndex, maxColumnDisplayIndex, false /*IsColumnHeadersRow*/, i);
OnCopyingRowClipboardContent(preparingRowClipboardContentEventArgs);
foreach (string format in formats)
{
dataGridStringBuilders[format].Append(preparingRowClipboardContentEventArgs.FormatClipboardCellValues(format));
}
}
}
}
ClipboardHelper.GetClipboardContentForHtml(dataGridStringBuilders[DataFormats.Html]);
try
{
DataObject dataObject = new DataObject();
foreach (string format in formats)
{
dataObject.SetData(format, dataGridStringBuilders[format].ToString(), false /*autoConvert*/);
}
Clipboard.SetDataObject(dataObject);
}
catch (SecurityException)
{
// In partial trust we will have a security exception because clipboard operations require elevated permissions
// Bug: Once the security team fix Clipboard.SetText - we can remove this catch
// Temp: Use TextBox.Copy to have at least Text format in the clipboard
TextBox textBox = new TextBox();
textBox.Text = dataGridStringBuilders[DataFormats.Text].ToString();
textBox.SelectAll();
textBox.Copy();
}
}
public void CopyingRowClipboardContent(DataGrid source, DataGridRowClipboardEventArgs e)
{
System.Diagnostics.Debug.WriteLine(e.ClipboardRowContent[0]);
}
private void DataGrid_CopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
}
private void MainGrid__CopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
MessageBox.Show("D");
}
private void dg1_CopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
//For now allow single row copy. If multiple row copy required, then need to handle
copiedRows.Clear();
copiedRows.Add(e.Item as Person);
}
private void OnExecutedCopyInternal(ExecutedRoutedEventArgs args)
{
if (ClipboardCopyMode == DataGridClipboardCopyMode.None)
{
throw new NotSupportedException("Cannot perform copy if ClipboardCopyMode is None.");
}
args.Handled = true;
// Supported default formats: Html, Text, UnicodeText and CSV
Collection <string> formats = new Collection <string>(new string[] { DataFormats.Html, DataFormats.Text, DataFormats.UnicodeText, DataFormats.CommaSeparatedValue });
Dictionary <string, StringBuilder> dataGridStringBuilders = new Dictionary <string, StringBuilder>(formats.Count);
foreach (string format in formats)
{
dataGridStringBuilders[format] = new StringBuilder();
}
int minRowIndex;
int maxRowIndex;
int minColumnDisplayIndex;
int maxColumnDisplayIndex;
// Get the bounding box of the selected cells
if (this.GetSelectionRange(out minColumnDisplayIndex, out maxColumnDisplayIndex, out minRowIndex, out maxRowIndex))
{
// Add column headers if enabled
if (ClipboardCopyMode == DataGridClipboardCopyMode.IncludeHeader)
{
DataGridRowClipboardEventArgs preparingRowClipboardContentEventArgs = new DataGridRowClipboardEventArgs(null, minColumnDisplayIndex, maxColumnDisplayIndex, true /*IsColumnHeadersRow*/);
OnCopyingRowClipboardContent(preparingRowClipboardContentEventArgs);
foreach (string format in formats)
{
dataGridStringBuilders[format].Append(preparingRowClipboardContentEventArgs.FormatClipboardCellValues(format));
}
}
// Add each selected row
for (int i = minRowIndex; i <= maxRowIndex; i++)
{
object row = Items[i];
// Row has a selecion
if (this.SelectedCellsIntersects(i))
{
DataGridRowClipboardEventArgs preparingRowClipboardContentEventArgs = (DataGridRowClipboardEventArgs)CONSTRUCTORINFO_DATAGRIDROWCLIPBOARDEVENTARGS.Invoke(
new object[] { row, minColumnDisplayIndex, maxColumnDisplayIndex, false /*IsColumnHeadersRow*/, i });
OnCopyingRowClipboardContent(preparingRowClipboardContentEventArgs);
foreach (string format in formats)
{
dataGridStringBuilders[format].Append(preparingRowClipboardContentEventArgs.FormatClipboardCellValues(format));
}
}
}
}
DataGridBoldClipboardHelper.GetClipboardContentForHtml(dataGridStringBuilders[DataFormats.Html]);
DataObject dataObject;
bool hasPerms = SecurityHelper.CallerHasAllClipboardPermission() && SecurityHelper.CallerHasSerializationPermission();
// Copy unconditionally in full trust.
// Only copy in partial trust if user initiated.
if (hasPerms || args.GetUserInitiated())
{
(new UIPermission(UIPermissionClipboard.AllClipboard)).Assert();
try
{
dataObject = new DataObject();
}
finally
{
UIPermission.RevertAssert();
}
foreach (string format in formats)
{
if (dataGridStringBuilders[format] != null)
{
dataObject.SetData(format, dataGridStringBuilders[format].ToString(), false /*autoConvert*/);
}
}
// This assert is there for an OLE Callback to register CSV type for the clipboard
(new SecurityPermission(SecurityPermissionFlag.SerializationFormatter | SecurityPermissionFlag.UnmanagedCode)).Assert();
try
{
if (dataObject != null)
{
Clipboard.SetDataObject(dataObject, true /* Copy */);
}
}
finally
{
SecurityPermission.RevertAll();
}
}
}
private void DataGrid_OnCopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
//e.ClipboardRowContent.Clear();
//var cells = DataGrid.SelectedCells;
}
private void DataGrid_OnCopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
e.ClipboardRowContent.Clear();
e.ClipboardRowContent.Add(new DataGridClipboardCellContent(e.Item, ((DataGrid)sender).Columns[e.StartColumnDisplayIndex], "Abc-hello"));
}
private void DataGrid_CopyingRowClipboardContent(object sender, DataGridRowClipboardEventArgs e)
{
batFormLogic.Copy(sender as DataGrid, e);
}
public static int GetRowIndexHint(this DataGridRowClipboardEventArgs args)
{
return((int)PROPERTYINFO_ROWINDEXHINT.GetValue(args));
}
