public virtual bool ContainsText (TextDataFormat format)
{
if (!Enum.IsDefined (typeof (TextDataFormat), format))
throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for TextDataFormat", format));
return GetDataPresent (TextFormatToDataFormat (format), true);
}
private void CopyToClipboard(string context, TextDataFormat format = TextDataFormat.UnicodeText)
{
RunInThread(() =>
{
Clipboard.SetText(context, format);
});
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
/// <summary>
/// Convert TextDataFormat to Dataformats.
/// </summary>
internal static string ConvertToDataFormats(TextDataFormat textDataformat)
{
string dataFormat = DataFormats.UnicodeText;
switch (textDataformat)
{
case TextDataFormat.Text:
dataFormat = DataFormats.Text;
break;
case TextDataFormat.UnicodeText:
dataFormat = DataFormats.UnicodeText;
break;
case TextDataFormat.Rtf:
dataFormat = DataFormats.Rtf;
break;
case TextDataFormat.Html:
dataFormat = DataFormats.Html;
break;
case TextDataFormat.CommaSeparatedValue:
dataFormat = DataFormats.CommaSeparatedValue;
break;
case TextDataFormat.Xaml:
dataFormat = DataFormats.Xaml;
break;
}
return(dataFormat);
}
public virtual string GetText (TextDataFormat format)
{
if (!Enum.IsDefined (typeof (TextDataFormat), format))
throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for TextDataFormat", format));
return (string)GetData (TextFormatToDataFormat (format), false);
}
private void DumpContent(
string content, TextDataFormat format, string title = "CONTENT", bool fancy = false)
{
string preamble = null;
if (content.StartsWith("Version:"))
{
var start = content.IndexOf('<');
preamble = content.Substring(0, start);
// trim html preamble if it's present
content = content.Substring(start);
}
if (fancy)
{
content = XElement.Parse(content).ToString(SaveOptions.None);
}
ConsoleWrite($"{title}: ({format.ToString()}) [", ConsoleColor.Yellow);
if (preamble != null)
{
ConsoleWrite(preamble, ConsoleColor.DarkGray);
}
ConsoleWrite(content, ConsoleColor.DarkGray);
ConsoleWriteLine("]", ConsoleColor.DarkYellow);
Console.WriteLine();
}
public virtual bool ContainsText(TextDataFormat format)
{
//valid values are 0x0 to 0x4
SourceGenerated.EnumValidator.Validate(format, nameof(format));
return(GetDataPresent(ConvertToDataFormats(format), false));
}
public static void SetText(string text, TextDataFormat format)
{
if (string.IsNullOrEmpty(text))
{
throw new ArgumentNullException("text");
}
if (!Enum.IsDefined(typeof(TextDataFormat), format))
{
throw new InvalidEnumArgumentException(string.Format("Enum argument value '{0}' is not valid for TextDataFormat", format));
}
switch (format)
{
case TextDataFormat.Text:
SetData(DataFormats.Text, text);
break;
case TextDataFormat.UnicodeText:
SetData(DataFormats.UnicodeText, text);
break;
case TextDataFormat.Rtf:
SetData(DataFormats.Rtf, text);
break;
case TextDataFormat.Html:
SetData(DataFormats.Html, text);
break;
case TextDataFormat.CommaSeparatedValue:
SetData(DataFormats.CommaSeparatedValue, text);
break;
}
}
public static void SetText(string text, TextDataFormat format)
{
#if MONO
GtkSetText(text);
#else
Clipboard.SetText(text, format);
#endif
}
public static string GetText(TextDataFormat format)
{
#if MONO
return(GtkGetText());
#else
return(Clipboard.GetText(format));
#endif
}
/// <summary>
/// Determines whether the specified format contains text.
/// </summary>
/// <param name="format">The format.</param>
/// <returns>
/// <c>true</c> if the specified format contains text; otherwise, <c>false</c>.
/// </returns>
/// <exception cref="System.ComponentModel.InvalidEnumArgumentException">format</exception>
public bool ContainsText(TextDataFormat format)
{
if (!ClientUtils.IsEnumValid(format, (int)format, 0, 4))
{
throw new InvalidEnumArgumentException("format", (int)format, typeof(TextDataFormat));
}
return((DataObject != null) && DataObject.GetDataPresent(ConvertToDataFormats(format), false));
}
public override string GetText(TextDataFormat format)
{
if (FData != null)
{
return(FData.GetText(format));
}
return(base.GetText(format));
}
public override void SetText(string textData, TextDataFormat format)
{
if (FData != null)
{
FData.SetText(textData, format);
}
base.SetText(textData, format);
}
public static void SetText(string text, TextDataFormat format)
{
#if __MonoCS__
GtkSetText(text);
#else
Clipboard.SetText(text, format);
#endif
}
public static string GetText(TextDataFormat format)
{
#if __MonoCS__
return GtkGetText();
#else
return Clipboard.GetText(format);
#endif
}
public override bool ContainsText(TextDataFormat format)
{
if (FData != null)
{
return(FData.ContainsText(format));
}
return(base.ContainsText(format));
}
public static bool ContainsText(TextDataFormat format)
{
if (!System.Windows.Forms.ClientUtils.IsEnumValid(format, (int)format, 0, 4))
{
throw new InvalidEnumArgumentException("format", (int)format, typeof(TextDataFormat));
}
System.Windows.Forms.IDataObject dataObject = GetDataObject();
return((dataObject != null) && dataObject.GetDataPresent(ConvertToDataFormats(format), false));
}
public virtual void SetText(string textData, TextDataFormat format)
{
textData.ThrowIfNullOrEmpty();
//valid values are 0x0 to 0x4
SourceGenerated.EnumValidator.Validate(format, nameof(format));
SetData(ConvertToDataFormats(format), false, textData);
}
public string GetText(TextDataFormat format)
{
ClipboardAsync instance = new ClipboardAsync();
Thread staThread = new Thread(instance._thGetText);
staThread.SetApartmentState(ApartmentState.STA);
staThread.Start(format);
staThread.Join();
return instance._GetText;
}
public static bool ContainsText(TextDataFormat format)
{
if (!System.Windows.Forms.ClientUtils.IsEnumValid(format, (int) format, 0, 4))
{
throw new InvalidEnumArgumentException("format", (int) format, typeof(TextDataFormat));
}
System.Windows.Forms.IDataObject dataObject = GetDataObject();
return ((dataObject != null) && dataObject.GetDataPresent(ConvertToDataFormats(format), false));
}
/// <summary>
/// Return true if Clipboard contains the specified text data format which is unicode.
/// Otherwise, return false.
/// </summary>
public static bool ContainsText(TextDataFormat format)
{
if (!DataFormats.IsValidTextDataFormat(format))
{
throw new InvalidEnumArgumentException(nameof(format), (int)format, typeof(TextDataFormat));
}
return(ContainsDataInternal(DataFormats.ConvertToDataFormats(format)));
}
public static void SetText(string text, TextDataFormat format)
{
text.ThrowIfNullOrEmpty();
SourceGenerated.EnumValidator.Validate(format, nameof(format));
IDataObject dataObject = new DataObject();
dataObject.SetData(ConvertToDataFormats(format), false, text);
Clipboard.SetDataObject(dataObject, true);
}
public virtual bool ContainsText(TextDataFormat format)
{
//valid values are 0x0 to 0x4
if (!ClientUtils.IsEnumValid(format, (int)format, (int)TextDataFormat.Text, (int)TextDataFormat.CommaSeparatedValue))
{
throw new InvalidEnumArgumentException(nameof(format), (int)format, typeof(TextDataFormat));
}
return(GetDataPresent(ConvertToDataFormats(format), false));
}
public string GetText(TextDataFormat format)
{
ClipboardAsync instance = new ClipboardAsync();
Thread staThread = new Thread(instance._thGetText);
staThread.SetApartmentState(ApartmentState.STA);
staThread.Start(format);
staThread.Join();
return(instance._GetText);
}
public string GetText(TextDataFormat format)
{
var instance = new ThreadedClipboardUtility();
var staThread = new Thread(instance.ThreadedGetText);
staThread.SetApartmentState(ApartmentState.STA);
staThread.Start(format);
staThread.Join();
return(instance._getTextResult);
}
public void SetText(string text, TextDataFormat textDataFormat)
{
try
{
System.Windows.Clipboard.SetText(text, textDataFormat);
}
// ReSharper disable once EmptyGeneralCatchClause
catch
{
}
}
/// <summary>Gets the text from the native Clipboard in the specified format.</summary>
/// <param name="format">The format.</param>
/// <returns>The string value or <see langword="null"/> if the format is not available.</returns>
public string GetText(TextDataFormat format)
{
return(format switch
{
TextDataFormat.Text => StringHelper.GetString(GetClipboardData(CLIPFORMAT.CF_TEXT), CharSet.Ansi),
TextDataFormat.UnicodeText => StringHelper.GetString(GetClipboardData(CLIPFORMAT.CF_UNICODETEXT), CharSet.Unicode),
TextDataFormat.Rtf => StringHelper.GetString(DanagerousGetData(DataFormats.Rtf), CharSet.Ansi),
TextDataFormat.Html => GetHtml(DanagerousGetData(DataFormats.Html)),
TextDataFormat.CommaSeparatedValue => StringHelper.GetString(DanagerousGetData(DataFormats.CommaSeparatedValue), CharSet.Ansi),
_ => null,
});
private string PasteClipboard(TextDataFormat format)
{
string result = Clipboard.GetText(format);
// Restore the current state of the clipboard so the effect is seamless
if (objectSave != null)
{
Clipboard.SetDataObject(objectSave);
}
return(result);
}
public static string DataGridViewToText(DataGridView grid, TextDataFormat format)
{
string text = "";
try {
grid.SelectAll();
text = grid.GetClipboardContent().GetText(format);;
grid.ClearSelection();
} catch (Exception ex) { Errors.OnException(ex); }
return(text);
}
public static void SetText(string text, TextDataFormat format)
{
if (string.IsNullOrEmpty(text))
{
Clipboard.Clear();
}
else
{
Clipboard.SetText(text, format);
}
}
public void SetText(string text, TextDataFormat textDataFormat)
{
try
{
System.Windows.Clipboard.SetText(text, textDataFormat);
}
// ReSharper disable once EmptyGeneralCatchClause
catch
{
}
}
public static void SetText(string text, TextDataFormat format)
{
if (string.IsNullOrEmpty(text))
{
return;
}
DataObject obj = new DataObject();
obj.SetText(text, format);
SetClipboardData(obj);
}
public virtual void SetText(string textData, TextDataFormat format)
{
if (string.IsNullOrEmpty(textData))
{
throw new ArgumentNullException(nameof(textData));
}
//valid values are 0x0 to 0x4
SourceGenerated.EnumValidator.Validate(format, nameof(format));
SetData(ConvertToDataFormats(format), false, textData);
}
public virtual string GetText(TextDataFormat format)
{
//valid values are 0x0 to 0x4
SourceGenerated.EnumValidator.Validate(format, nameof(format));
if (GetData(ConvertToDataFormats(format), false) is string text)
{
return(text);
}
return(string.Empty);
}
private static String StartGetTextThread(TextDataFormat format)
{
TextGetData data = new TextGetData(format);
Thread t = new Thread(new ParameterizedThreadStart(GetTextThread));
// The whole reason for this class is because it's possible to need
// to put stuff on the clipboard and the thread isn't marked STA.
t.SetApartmentState(ApartmentState.STA);
t.Start(data);
t.Join();
return(data.Data);
}
private void lbClipboardEntries_Click(object sender, EventArgs e)
{
var snapshot = this.GetSelectedSnapshot();
if (snapshot != null)
{
this.textBox.Visible = false;
this.richTextBox.Visible = false;
TextDataFormat formatToDisplay = TextDataFormat.Text;
if (snapshot.TextFormatted.ContainsKey(ClipboardMonitor.CLIPBOARD_FORMAT_RTF))
{
formatToDisplay = TextDataFormat.Rtf;
}
else if (snapshot.TextFormatted.ContainsKey(ClipboardMonitor.CLIPBOARD_FORMAT_HTML))
{
formatToDisplay = TextDataFormat.Html;
}
else if (snapshot.TextFormatted.ContainsKey(ClipboardMonitor.CLIPBOARD_FORMAT_UNICODETEXT))
{
formatToDisplay = TextDataFormat.UnicodeText;
}
else if (snapshot.TextFormatted.ContainsKey(ClipboardMonitor.CLIPBOARD_FORMAT_TEXT))
{
formatToDisplay = TextDataFormat.Text;
}
switch (formatToDisplay)
{
case TextDataFormat.Rtf:
this.richTextBox.Visible = true;
this.richTextBox.Rtf = snapshot.TextFormatted[ClipboardMonitor.CLIPBOARD_FORMAT_RTF] as string;
break;
case TextDataFormat.Html:
this.textBox.Visible = true;
this.textBox.Text = snapshot.TextFormatted[ClipboardMonitor.CLIPBOARD_FORMAT_HTML] as string;
break;
case TextDataFormat.UnicodeText:
this.textBox.Visible = true;
this.textBox.Text = snapshot.TextFormatted[ClipboardMonitor.CLIPBOARD_FORMAT_UNICODETEXT] as string;
break;
default:
this.textBox.Visible = true;
this.textBox.Text = snapshot.TextFormatted[ClipboardMonitor.CLIPBOARD_FORMAT_TEXT] as string;
break;
}
}
}
/// <summary>
/// Adds text data to the Clipboard in the format indicated by the
/// specified <see cref="TextDataFormat "/> value.
/// </summary>
/// <param name="text">
/// The text to add to the Clipboard.
/// </param>
/// <param name="format">
/// One of the <see cref="TextDataFormat"/> values.
/// </param>
/// <exception cref="ArgumentException">
/// Thrown if <paramref name="text"/> is null or empty.
/// Thrown if <paramref name="format"/> is not in the appropriate
/// <see cref="TextDataFormat"/> range.
/// </exception>
public static void SetText(string text, TextDataFormat format)
{
if (string.IsNullOrEmpty(text))
throw new ArgumentException("Invalid parameter", "owner");
if (!IsEnumValid((int)format, 0, 4))
throw new ArgumentException("Invalid parameter", "format");
if (Thread.CurrentThread.GetApartmentState() != ApartmentState.STA)
{
// Everything should be good so package up the data and let the
// background thread get it to the clipboard.
IDataObject data = new DataObject(ConvertToDataFormats(format), text);
StartSetThread(data);
}
else Clipboard.SetText(text, format); // We're on an STA thread so I can do the call directly.
}
private static string ConvertToDataFormats(TextDataFormat format)
{
switch (format)
{
case TextDataFormat.Text:
return DataFormats.Text;
case TextDataFormat.UnicodeText:
return DataFormats.UnicodeText;
case TextDataFormat.Rtf:
return DataFormats.Rtf;
case TextDataFormat.Html:
return DataFormats.Html;
case TextDataFormat.CommaSeparatedValue:
return DataFormats.CommaSeparatedValue;
}
return DataFormats.UnicodeText;
}
public static string GetText (TextDataFormat format)
{
if (!Enum.IsDefined (typeof (TextDataFormat), format))
throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for TextDataFormat", format));
IDataObject data = GetDataObject ();
if (data == null)
return string.Empty;
string retval;
switch (format) {
case TextDataFormat.Text:
default:
retval = (string)data.GetData (DataFormats.Text, true);
break;
case TextDataFormat.UnicodeText:
retval = (string)data.GetData (DataFormats.UnicodeText, true);
break;
case TextDataFormat.Rtf:
retval = (string)data.GetData (DataFormats.Rtf, true);
break;
case TextDataFormat.Html:
retval = (string)data.GetData (DataFormats.Html, true);
break;
case TextDataFormat.CommaSeparatedValue:
retval = (string)data.GetData (DataFormats.CommaSeparatedValue, true);
break;
}
return retval == null ? string.Empty : retval;
}
/// <include file='doc\Clipboard.uex' path='docs/doc[@for="Clipboard.SetText1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public static void SetText(string text, TextDataFormat format) {
if (String.IsNullOrEmpty(text)) {
throw new ArgumentNullException("text");
}
//valid values are 0x0 to 0x4
if (!ClientUtils.IsEnumValid(format, (int)format, (int)TextDataFormat.Text, (int)TextDataFormat.CommaSeparatedValue))
{
throw new InvalidEnumArgumentException("format", (int)format, typeof(TextDataFormat));
}
IDataObject dataObject = new DataObject();
dataObject.SetData(ConvertToDataFormats(format), false, text);
Clipboard.SetDataObject(dataObject, true);
}
public bool ContainsText(TextDataFormat format)
{
return Clipboard.ContainsText(format);
}
/// <include file='doc\Clipboard.uex' path='docs/doc[@for="Clipboard.ContainsText1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public static bool ContainsText(TextDataFormat format) {
// valid values are 0x0-0x4 inclusive
if (!ClientUtils.IsEnumValid(format, (int)format, (int)TextDataFormat.Text, (int)TextDataFormat.CommaSeparatedValue)){
throw new InvalidEnumArgumentException("format", (int)format, typeof(TextDataFormat));
}
IDataObject dataObject = Clipboard.GetDataObject();
if (dataObject != null) {
return dataObject.GetDataPresent(ConvertToDataFormats(format), false);
}
return false;
}
/// <include file='doc\Clipboard.uex' path='docs/doc[@for="Clipboard.GetText1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public static string GetText(TextDataFormat format) {
// valid values are 0x0 to 0x4 inclusive
if (!ClientUtils.IsEnumValid(format, (int)format, (int)TextDataFormat.Text, (int)TextDataFormat.CommaSeparatedValue))
{
throw new InvalidEnumArgumentException("format", (int)format, typeof(TextDataFormat));
}
IDataObject dataObject = Clipboard.GetDataObject();
if (dataObject != null) {
string text = dataObject.GetData(ConvertToDataFormats(format), false) as string;
if (text != null) {
return text;
}
}
return String.Empty;
}
public static string GetText(TextDataFormat format)
{
if (!System.Windows.Forms.ClientUtils.IsEnumValid(format, (int) format, 0, 4))
{
throw new InvalidEnumArgumentException("format", (int) format, typeof(TextDataFormat));
}
System.Windows.Forms.IDataObject dataObject = GetDataObject();
if (dataObject != null)
{
string data = dataObject.GetData(ConvertToDataFormats(format), false) as string;
if (data != null)
{
return data;
}
}
return string.Empty;
}
public static string GetText(TextDataFormat format)
{
return ClipboardProxy.GetText(format);
}
/// <include file='doc\DataObject.uex' path='docs/doc[@for="DataObject.SetText1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public virtual void SetText(string textData, TextDataFormat format) {
if (String.IsNullOrEmpty(textData)) {
throw new ArgumentNullException("textData");
}
//valid values are 0x0 to 0x4
if (!ClientUtils.IsEnumValid(format, (int)format, (int)TextDataFormat.Text, (int)TextDataFormat.CommaSeparatedValue))
{
throw new InvalidEnumArgumentException("format", (int)format, typeof(TextDataFormat));
}
SetData(ConvertToDataFormats(format), false, textData);
}
/// <include file='doc\DataObject.uex' path='docs/doc[@for="DataObject.GetText1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public virtual string GetText(TextDataFormat format) {
//valid values are 0x0 to 0x4
if (!ClientUtils.IsEnumValid(format, (int)format, (int)TextDataFormat.Text, (int)TextDataFormat.CommaSeparatedValue)){
throw new InvalidEnumArgumentException("format", (int)format, typeof(TextDataFormat));
}
string text = GetData(ConvertToDataFormats(format), false) as string;
if (text != null) {
return text;
}
return String.Empty;
}
/// <include file='doc\DataObject.uex' path='docs/doc[@for="DataObject.ContainsText1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public virtual bool ContainsText(TextDataFormat format) {
//valid values are 0x0 to 0x4
if (!ClientUtils.IsEnumValid(format, (int)format, (int)TextDataFormat.Text, (int)TextDataFormat.CommaSeparatedValue)){
throw new InvalidEnumArgumentException("format", (int)format, typeof(TextDataFormat));
}
return GetDataPresent(ConvertToDataFormats(format), false);
}
public static void SetText(string text, TextDataFormat format)
{
if (_useSystemClipboard)
{
Clipboard.SetText(text, format);
}
else lock (_dataObject)
{
if (format != TextDataFormat.Text)
{
throw new ApplicationException(Resources.ClipboardEx_GetData_ClipboardEx_implementation_problem);
}
_dataObject.SetData(text, DataFormats.Text);
if (CHECK_VALUES)
{
Clipboard.SetText(text, format);
}
}
}
private void ExportDataGridViewData(string filename, TextDataFormat format = TextDataFormat.CommaSeparatedValue)
{
IDataObject objectSave = Clipboard.GetDataObject();
bool multiSelectAllowed = dataGridViewLearningTasks.MultiSelect;
DataGridViewClipboardCopyMode copyMode = dataGridViewLearningTasks.ClipboardCopyMode;
dataGridViewLearningTasks.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText;
dataGridViewLearningTasks.MultiSelect = true;
dataGridViewLearningTasks.SelectAll();
Clipboard.SetDataObject(dataGridViewLearningTasks.GetClipboardContent());
if (format == TextDataFormat.CommaSeparatedValue && Path.GetExtension(filename) != ".csv")
filename += ".csv";
File.WriteAllText(filename, Clipboard.GetText(format));
dataGridViewLearningTasks.MultiSelect = multiSelectAllowed;
dataGridViewLearningTasks.ClipboardCopyMode = copyMode;
if (objectSave != null)
Clipboard.SetDataObject(objectSave);
}
public static void SetText (string text, TextDataFormat format)
{
if (string.IsNullOrEmpty (text))
throw new ArgumentNullException ("text");
if (!Enum.IsDefined (typeof (TextDataFormat), format))
throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for TextDataFormat", format));
switch (format) {
case TextDataFormat.Text:
SetData (DataFormats.Text, text);
break;
case TextDataFormat.UnicodeText:
SetData (DataFormats.UnicodeText, text);
break;
case TextDataFormat.Rtf:
SetData (DataFormats.Rtf, text);
break;
case TextDataFormat.Html:
SetData (DataFormats.Html, text);
break;
case TextDataFormat.CommaSeparatedValue:
SetData (DataFormats.CommaSeparatedValue, text);
break;
}
}
public static bool ContainsText (TextDataFormat format)
{
switch (format) {
case TextDataFormat.Text:
return ClipboardContainsFormat (DataFormats.Text);
case TextDataFormat.UnicodeText:
return ClipboardContainsFormat (DataFormats.UnicodeText);
case TextDataFormat.Rtf:
return ClipboardContainsFormat (DataFormats.Rtf);
case TextDataFormat.Html:
return ClipboardContainsFormat (DataFormats.Html);
case TextDataFormat.CommaSeparatedValue:
return ClipboardContainsFormat (DataFormats.CommaSeparatedValue);
}
return false;
}
public static void SetText(string text, TextDataFormat format)
{
ClipboardProxy.SetText(text, format);
}
public static void SetText(string text, TextDataFormat format)
{
if (string.IsNullOrEmpty(text))
{
throw new ArgumentNullException("text");
}
if (!System.Windows.Forms.ClientUtils.IsEnumValid(format, (int) format, 0, 4))
{
throw new InvalidEnumArgumentException("format", (int) format, typeof(TextDataFormat));
}
System.Windows.Forms.IDataObject data = new DataObject();
data.SetData(ConvertToDataFormats(format), false, text);
SetDataObject(data, true);
}
public static bool ContainsText(TextDataFormat format)
{
return ClipboardProxy.ContainsText(format);
}
/// <summary>
/// Return true if Clipboard contains the specified text data format which is unicode.
/// Otherwise, return false.
/// </summary>
public static bool ContainsText(TextDataFormat format)
{
if (!DataFormats.IsValidTextDataFormat(format))
{
throw new InvalidEnumArgumentException("format", (int)format, typeof(TextDataFormat));
}
return ContainsDataInternal(DataFormats.ConvertToDataFormats(format));
}
/// <summary>
/// Get text from Clipboard.
/// </summary>
public static string GetText(TextDataFormat format)
{
if (!DataFormats.IsValidTextDataFormat(format))
{
throw new InvalidEnumArgumentException("format", (int)format, typeof(TextDataFormat));
}
string text;
text = (string)GetDataInternal(DataFormats.ConvertToDataFormats(format));
if (text != null)
{
return text;
}
return string.Empty;
}
public TextTransmissionData(string text, TextDataFormat dataFormat)
{
this.TextData = text;
DataFormat = dataFormat;
}
/// <summary>
/// Set the text data to Clipboard.
/// </summary>
public static void SetText(string text, TextDataFormat format)
{
if (text == null)
{
throw new ArgumentNullException("text");
}
if (!DataFormats.IsValidTextDataFormat(format))
{
throw new InvalidEnumArgumentException("format", (int)format, typeof(TextDataFormat));
}
SetDataInternal(DataFormats.ConvertToDataFormats(format), text);
}
public void SetText(string text, TextDataFormat format)
{
Clipboard.SetText(text,format);
}
public string GetText(TextDataFormat textDataFormat)
{
return System.Windows.Clipboard.GetText(textDataFormat);
}
