private void CopyButtonClick(object sender, EventArgs e)
        {
            var dateTime = DateTime.Parse(DateTextBox.Text, DateTextBox.Culture, DateTimeStyles.AssumeLocal);

            var timeSpan = dateTime.ToUniversalTime() - Epoch;

            var dataObject = new DataObject();

            var messagePlain = string.Format(
                "[{0:hh:mm:ss}] {1}: {2}",
                dateTime,
                AuthorFullNameTextBox.Text,
                MessageTextBox.Text);
            var messageXml = string.Format(
                "<quote author=\"{0}\" timestamp=\"{1}\">{2}</quote>",
                AuthorTextBox.Text,
                timeSpan.TotalSeconds,
                MessageTextBox.Text);

            dataObject.SetData("System.String", messagePlain);
            dataObject.SetData("UnicodeText", messagePlain);
            dataObject.SetData("Text", messagePlain);
            dataObject.SetData("SkypeMessageFragment", new MemoryStream(Encoding.UTF8.GetBytes(messageXml)));
            dataObject.SetData("Locale", new MemoryStream(BitConverter.GetBytes(CultureInfo.CurrentCulture.LCID)));
            dataObject.SetData("OEMText", messagePlain);

            Clipboard.SetDataObject(dataObject, true);
        }

        private IDataObject CloneClipboard(IDataObject obj)
        {
            if (obj == null)
                return null;

            string[] formats = obj.GetFormats();
            if (formats.Length == 0)
                return null;

            IDataObject newObj = new DataObject();
            
            foreach (string format in formats)
            {
				if (format.Contains("EnhancedMetafile")) //Ignore this. Cannot be processed in .NET
					continue;

				object o = obj.GetData(format);

                if (o != null)
                {
                    newObj.SetData(o);
                }
            }

            return newObj;
        }

        private void label2_MouseDown(object sender, MouseEventArgs e)
        {
            // Start drag-and-drop if left mouse goes down over this label
              if (e.Button == MouseButtons.Left)
              {
            // Crete a new data object
            DataObject data = new DataObject();

            // Get the TextBox text
            string dragString = this.textBox1.Text;

            // If the TextBox text was empty then use a default string
            if (string.IsNullOrEmpty(dragString))
              dragString = "Empty string";

            // Set the DataOject's data to a new SampleCsDragData object which
            // can be serialized. If you use an object that does not support the
            // serialize interface then you will NOT be able to drag and drop the
            // item onto a different session of Rhino.
            data.SetData(new SampleCsDragData(dragString));

            // Start drag-and-drop
            this.DoDragDrop(data, DragDropEffects.Copy | DragDropEffects.Move);
              }
        }

		public void RtfTextTest ()
		{
			string rtf_text = @"{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fnil\fcharset0 Arial;}}{\*\generator Mono RichTextBox;}\pard\f0\fs16 hola\par}";
			string plain_text = "hola";

			Clipboard.SetText (rtf_text, TextDataFormat.Rtf);

			Assert.AreEqual (false, Clipboard.ContainsText (TextDataFormat.Text), "#A1");
			Assert.AreEqual (false, Clipboard.ContainsText (TextDataFormat.UnicodeText), "#A2");
			Assert.AreEqual (true, Clipboard.ContainsText (TextDataFormat.Rtf), "#A3");
			Assert.AreEqual (rtf_text, Clipboard.GetText (TextDataFormat.Rtf), "#A4");

			// Now use a IDataObject, so we can have more than one format at the time
			DataObject data = new DataObject ();
			data.SetData (DataFormats.Rtf, rtf_text);
			data.SetData (DataFormats.UnicodeText, plain_text);

			Clipboard.SetDataObject (data);

			Assert.AreEqual (true, Clipboard.ContainsText (TextDataFormat.Text), "#B1");
			Assert.AreEqual (true, Clipboard.ContainsText (TextDataFormat.UnicodeText), "#B2");
			Assert.AreEqual (true, Clipboard.ContainsText (TextDataFormat.Rtf), "#B3");
			Assert.AreEqual (rtf_text, Clipboard.GetText (TextDataFormat.Rtf), "#B4");
			Assert.AreEqual (plain_text, Clipboard.GetText (), "#B5");

			Clipboard.Clear ();
		}

 protected override IDataObject GetDataObjectFromText(string text)
 {
     DataObject obj2 = new DataObject();
     obj2.SetData(DataFormats.Text, text);
     obj2.SetData(DataFormats.Html, text);
     return obj2;
 }

        /// <summary>
        /// This method is called when the drag and drop operation is completed and
        /// the item being dragged was dropped on the Rhino layer list control.
        /// </summary>
        public override bool OnDropOnLayerListCtrl(IWin32Window layerListCtrl, int layerIndex, DataObject data, DragDropEffects dropEffect, Point point)
        {
            SampleCsDragData dragData = GetSampleCsDragData(data);
              if (null == dragData)
            return false;

              if (layerIndex < 0)
              {
            MessageBox.Show(
              RhUtil.RhinoApp().MainWnd(),
              "String \"" + dragData.DragString + "\" Dropped on layer list control, not on a layer",
              "SampleCsDragDrop",
              MessageBoxButtons.OK,
              MessageBoxIcon.Information
              );
              }
              else
              {
            MRhinoDoc doc = RhUtil.RhinoApp().ActiveDoc();
            if (null != doc && layerIndex < doc.m_layer_table.LayerCount())
            {
              MessageBox.Show(
            RhUtil.RhinoApp().MainWnd(),
            "String \"" + dragData.DragString + "\" Dropped on layer \"" + doc.m_layer_table[layerIndex].m_name + "\"",
            "SampleCsDragDrop",
            MessageBoxButtons.OK,
            MessageBoxIcon.Information
            );
            }
              }

              return true;
        }

        public static void copyToClipboard(List<Frame> frames)
        {
            if (frames.Count == 0)
            {
                return;
            }

            DataObject data = new DataObject();
            data.SetData(frames.ToArray());

            if (frames.Count == 1)
            {
                // Not necessary, but Microsoft recommends that we should
                // place data on the clipboard in as many formats possible.
                data.SetData(frames[0]);
            }

            StringBuilder sb = new StringBuilder();
            foreach (Frame frame in frames)
            {
                sb.AppendLine(frame.getTabSeparatedString());
            }
            data.SetText(sb.ToString());

            Clipboard.SetDataObject(data, true);
        }

 protected override void DeserializeFromData(DataObject data)
 {
     ConvertOperation convert = new ConvertOperation(data, ConvertOperation.Operation.Convert);
     if (convert.CanPerform(this.editedCmpType))
     {
         var refQuery = convert.Perform(this.editedCmpType);
         if (refQuery != null)
         {
             Component[] refArray = refQuery.Cast<Component>().ToArray();
             this.component = (refArray != null && refArray.Length > 0) ? refArray[0] : null;
             this.PerformSetValue();
             this.PerformGetValue();
             this.OnEditingFinished(FinishReason.LeapValue);
         }
     }
     else if (convert.CanPerform(typeof(GameObject)))
     {
         GameObject obj = convert.Perform<GameObject>().FirstOrDefault();
         Component cmp = obj != null ? obj.GetComponent(this.editedCmpType) : null;
         if (cmp != null)
         {
             this.component = cmp;
             this.PerformSetValue();
             this.PerformGetValue();
             this.OnEditingFinished(FinishReason.LeapValue);
         }
     }
 }

        private void treeView1_ItemDrag(object sender, ItemDragEventArgs e)
        {
            // gx2. jsx, jsc reflector
            // ?

            // http://support.microsoft.com/kb/307968

            // we can drag it into scite
            // DragDrop.DoDragDrop returns only after the complete drag-drop process is finished,
            // http://w3facility.org/question/dodragdrop-freezes-winforms-app-sometimes/
            // https://msdn.microsoft.com/en-us/library/ms649011(VS.85).aspx

            // http://www.codeproject.com/Articles/17266/Drag-and-Drop-Items-in-a-WPF-ListView

            Console.WriteLine("treeView1_ItemDrag"); ;

            // http://stackoverflow.com/questions/1772102/c-sharp-drag-and-drop-from-my-custom-app-to-notepad
            var x = new DataObject(
                "treeView1_ItemDrag " + new { e.Item }
            );


            // like props/ reg keys/ version nodes
            x.SetData("text/nodes/0", "hello");
            x.SetData("text/nodes/1", "world");

            // https://msdn.microsoft.com/en-us/library/system.windows.forms.control.dodragdrop(v=vs.110).aspx
            //this.DoDragDrop("treeView1_ItemDrag " + new { e.Item }, DragDropEffects.Copy);
            treeView1.DoDragDrop(x, DragDropEffects.Copy);

            // https://code.google.com/p/chromium/issues/detail?id=31037
            // https://searchcode.com/codesearch/view/32985148/
        }

 public void Copy()
 {
     IDataObject clips = new DataObject();
     clips.SetData(DataFormats.Bitmap, this.opened_image.get_bitmap());
     clips.SetData(DataFormats.Text, this.opened_image.get_file_name());
     Clipboard.SetDataObject(clips, true);
 }

        /// <summary>
        /// Copy selected text into Clipboard
        /// </summary>
        public static void Copy(FastColoredTextBox textbox)
        {
            if (textbox.Selection.IsEmpty)
            {
                textbox.Selection.Expand();
            }

            if (!textbox.Selection.IsEmpty)
            {
                var exp = new ExportToHTML();
                exp.UseBr = false;
                exp.UseNbsp = false;
                exp.UseStyleTag = true;
                string html = "<pre>" + exp.GetHtml(textbox.Selection.Clone()) + "</pre>";
                var data = new DataObject();
                data.SetData(DataFormats.UnicodeText, true, textbox.Selection.Text);
                data.SetData(DataFormats.Html, PrepareHtmlForClipboard(html));
                data.SetData(DataFormats.Rtf, new ExportToRTF().GetRtf(textbox.Selection.Clone()));
                //
                var thread = new Thread(() => SetClipboard(data));
                thread.SetApartmentState(ApartmentState.STA);
                thread.Start();
                thread.Join();
            }
        }

        /// <summary>
        /// Called when the tool is activated.
        /// </summary>
        protected override void OnActivateTool()
        {
            if(Selection.SelectedItems.Count == 0)
                return;

            try
            {
                //Clear the Anchors otherwise subsequent Copy operations will raise an exception due to the fact that the Anchors class is a static helper class
                Anchors.Clear();
                //this will create a volatile collection of entities, they need to be unwrapped!
                //I never managed to get things working by putting the serialized collection directly onto the Clipboad. Thanks to Leppie's suggestion it works by
                //putting the Stream onto the Clipboard, which is weird but it works.
                MemoryStream copy = Selection.SelectedItems.ToStream();
                DataFormats.Format format = DataFormats.GetFormat(typeof(CopyTool).FullName);
                IDataObject dataObject = new DataObject();
                dataObject.SetData(format.Name, false, copy);
                Clipboard.SetDataObject(dataObject, false);
            }
            catch (Exception exc)
            {
                throw new InconsistencyException("The Copy operation failed.", exc);
            }
            finally
            {
                DeactivateTool();
            }
        }

 public DataObject ToDataObject()
 {
     DataObject obj = new DataObject();
     obj.SetData(DataFormats.Serializable, this);
     obj.SetData(DataFormats.Text, Texte);
     return obj;
 }

        public void Send(string archiveFilename, CancellationToken cancellationToken, SimpleProgressCallback progressCallback = null)
        {
            // create drop effect memory stream
            byte[] moveEffect = new byte[] { (byte) (performCut ? 2 : 5), 0, 0, 0 };
            MemoryStream dropEffect = new MemoryStream();
            dropEffect.Write(moveEffect, 0, moveEffect.Length);

            // create file data object
            DataObject data = new DataObject();
            data.SetFileDropList(new StringCollection { archiveFilename });
            data.SetData("Preferred DropEffect", dropEffect);

            // create STA thread that'll work with Clipboard object
            Thread copyStaThread = new Thread(() =>
                {
                    Clipboard.Clear();
                    Clipboard.SetDataObject(data, true);
                })
                {
                    Name = "Clipboard copy thread"
                };

            copyStaThread.SetApartmentState(ApartmentState.STA);

            // start the thread and wait for it to finish
            copyStaThread.Start();
            copyStaThread.Join();
        }

        private void copyToolStripMenuItem_Click(object sender, EventArgs e)
        {
            /*
            SceneJS scene = (SceneJS)treeView1.Nodes[0].Tag;
            if (scene != null)
            {
                object obj = scene.GetSelectedObject();
                if( obj != null )
                {
                    Clipboard.SetData("WebGLSceneObject", obj);
                }
            }
            */

            Clipboard.Clear();
            List<object> selected = new List<object>();
            foreach (TreeNode n in treeView1.SelectedNodes)
            {
                selected.Add(n.Tag);
            }

            DataFormats.Format df = DataFormats.GetFormat(typeof(List<object>).FullName);
            IDataObject dato = new DataObject();
            dato.SetData(df.Name, false, selected);

            Clipboard.SetDataObject(dato, false);
        }

 public static bool CopyTextToClipboard(string stringToCopy)
 {
     if (stringToCopy.Length > 0)
     {   
         DataObject dataObject = new DataObject();
         dataObject.SetData(DataFormats.UnicodeText, true, stringToCopy);
         // Work around ExternalException bug. (SD2-426)
         // Best reproducable inside Virtual PC.
         try
         {
             Clipboard.SetDataObject(dataObject, true, 10, 50);
         }
         catch (ExternalException)
         {
             Application.DoEvents();
             try
             {
                 Clipboard.SetDataObject(dataObject, true, 10, 50);
             }
             catch (ExternalException) { }
         }
         return true;
     }
     else
     {
         return false;
     }
 }

        private void SETextBox_MouseDown(object sender, MouseEventArgs e)
        {
            if (MouseButtons == MouseButtons.Left && !string.IsNullOrEmpty(_dragText))
            {
                Point pt = new Point(e.X, e.Y);
                int index = GetCharIndexFromPosition(pt);
                if (index >= _dragStartFrom && index <= _dragStartFrom + _dragText.Length)
                {
                    // re-make selection
                    SelectionStart = _dragStartFrom;
                    SelectionLength = _dragText.Length;

                    DataObject dataObject = new DataObject();
                    dataObject.SetText(_dragText, TextDataFormat.UnicodeText);
                    dataObject.SetText(_dragText, TextDataFormat.Text);

                    _dragFromThis = true;
                    if (Control.ModifierKeys == Keys.Control)
                    {
                        _dragRemoveOld = false;
                        DoDragDrop(dataObject, DragDropEffects.Copy);
                    }
                    else if (Control.ModifierKeys == Keys.None)
                    {
                        _dragRemoveOld = true;
                        DoDragDrop(dataObject, DragDropEffects.Move);
                    }
                }
            }
        }

		bool CopyTextToClipboard(string stringToCopy, bool asLine)
		{
			if (stringToCopy.Length > 0) {
				DataObject dataObject = new DataObject();
				dataObject.SetData(DataFormats.UnicodeText, true, stringToCopy);
				if (asLine) {
					MemoryStream lineSelected = new MemoryStream(1);
					lineSelected.WriteByte(1);
					dataObject.SetData(LineSelectedType, false, lineSelected);
				}
				// Default has no highlighting, therefore we don't need RTF output
				if (textArea.Document.HighlightingStrategy.Name != "Default") {
					dataObject.SetData(DataFormats.Rtf, RtfWriter.GenerateRtf(textArea));
				}
				OnCopyText(new CopyTextEventArgs(stringToCopy));
				
				// Work around ExternalException bug. (SD2-426)
				// Best reproducable inside Virtual PC.
				try {
					Clipboard.SetDataObject(dataObject, true, 10, 50);
				} catch (ExternalException) {
					Application.DoEvents();
					try {
						Clipboard.SetDataObject(dataObject, true, 10, 50);
					} catch (ExternalException) {}
				}
				return true;
			} else {
				return false;
			}
		}

 private void copySelectedEntriesToolStripMenuItem_Click(object sender, EventArgs e)
 {
     if (SelectedEntries.Count == 0)
     return;
        StringBuilder csvText = new StringBuilder();
        StringBuilder rawText = new StringBuilder();
        DateTime sessionTime = (DateTime)filterSessionCombobox.SelectedItem;
        csvText.AppendLine(S._("Session: {0:F}", sessionTime));
        rawText.AppendLine(S._("Session: {0:F}", sessionTime));
        foreach (LogEntry entry in SelectedEntries.Values)
        {
     string timeStamp = entry.Timestamp.ToString("F", CultureInfo.CurrentCulture);
     string message = entry.Message;
     csvText.AppendFormat("\"{0}\",\"{1}\",\"{2}\"\n",
      timeStamp.Replace("\"", "\"\""), entry.Level.ToString(),
      message.Replace("\"", "\"\""));
     rawText.AppendFormat("{0}	{1}	{2}\n", timeStamp, entry.Level.ToString(),
      message);
        }
        if (csvText.Length > 0 || rawText.Length > 0)
        {
     DataObject tableText = new DataObject();
     tableText.SetText(rawText.ToString());
     byte[] bytes = Encoding.UTF8.GetBytes(csvText.ToString());
     MemoryStream tableStream = new MemoryStream(bytes);
     tableText.SetData(DataFormats.CommaSeparatedValue, tableStream);
     Clipboard.SetDataObject(tableText, true);
        }
 }

		bool CopyTextToClipboard(string stringToCopy)
		{
			if (stringToCopy.Length > 0) {
				DataObject dataObject = new DataObject();
				dataObject.SetData(DataFormats.UnicodeText, true, stringToCopy);
				// Default has no highlighting, therefore we don't need RTF output
				if (textArea.Document.HighlightingStrategy.Name != "Default") {
					dataObject.SetData(DataFormats.Rtf, RtfWriter.GenerateRtf(textArea));
				}
				OnCopyText(new CopyTextEventArgs(stringToCopy));
				
				// Work around ExternalException bug. (SD2-426)
				// Best reproducable inside Virtual PC.
				// SetDataObject has "retry" parameters, but apparently a call to "DoEvents"
				// is necessary for the workaround to work.
				int i = 0;
				while (true) {
					try {
						Clipboard.SetDataObject(dataObject, true, 5, 50);
						return true;
					} catch (ExternalException) {
						if (i++ > 5)
							throw;
					}
					System.Threading.Thread.Sleep(50);
					Application.DoEvents();
					System.Threading.Thread.Sleep(50);
				}
			} else {
				return false;
			}
		}