Merge pull request #17 from MichaelTheShifter/shiftui_integration

Shiftui integration

1 files changed, 485 insertions, 0 deletions

diff --git a/source/ShiftUI/Internal/DataObject.cs b/source/ShiftUI/Internal/DataObject.cs
new file mode 100644
index 0000000..cfe74d5
--- /dev/null
+++ b/source/ShiftUI/Internal/DataObject.cs
@@ -0,0 +1,485 @@
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// Copyright (c) 2005 Novell, Inc. (http://www.novell.com)
+//
+// Authors:
+//	Peter Bartok	([email protected])
+//
+//
+
+// COMPLETE
+
+using System;
+using System.IO;
+using System.Drawing;
+using System.Collections;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+
+namespace ShiftUI {
+	[ClassInterface(ClassInterfaceType.None)]
+	public class DataObject : IDataObject, System.Runtime.InteropServices.ComTypes.IDataObject
+	 {
+		#region DataObject.Entry Class
+		private class Entry {
+			#region Local Variables
+			private string	type;
+			private object	data;
+			private bool	autoconvert;
+			internal Entry	next;
+			#endregion	// Local Variables
+
+			#region Constructors
+			internal Entry(string type, object data, bool autoconvert) {
+				this.type = type;
+				this.data = data;
+				this.autoconvert = autoconvert;
+			}
+			#endregion	// Constructors
+
+			#region Properties
+			public object Data {
+				get {
+					return data;
+				}
+
+				set {
+					data = value;
+				}
+			}
+			public bool AutoConvert {
+				get { 
+					return autoconvert;
+				}
+				set {
+					autoconvert = value;
+				}
+			}
+			#endregion	// Properties
+
+			#region Methods
+			public static int Count(Entry entries) {
+				int	result;
+
+				result = 0;
+
+				while (entries != null) {
+					result++;
+					entries = entries.next;
+				}
+
+				return result;
+			}
+
+			public static Entry Find (Entry entries, string type) {
+				return Find (entries, type, false);
+			}
+
+			public static Entry Find(Entry entries, string type, bool only_convertible) {
+				while (entries != null) {
+					bool available = true;
+					if (only_convertible && !entries.autoconvert)
+						available = false;
+					if (available && String.Compare (entries.type, type, true) == 0) {
+						return entries;
+					}
+					entries = entries.next;
+				}
+
+				return null;
+			}
+
+			public static Entry FindConvertible(Entry entries, string type) {
+				Entry e;
+
+				e = Find(entries, type);
+				if (e != null) {
+					return e;
+				}
+
+				// map to *any* other text format if needed
+				if (type == DataFormats.StringFormat || type == DataFormats.Text || type == DataFormats.UnicodeText) {
+					e = entries;
+					while (e != null) {
+						if (e.type == DataFormats.StringFormat || e.type == DataFormats.Text || e.type == DataFormats.UnicodeText)
+							return e;
+
+						e = e.next;
+					}
+				}
+
+				return null;
+			}
+
+			public static string[] Entries(Entry entries, bool convertible) {
+				Entry		e;
+				ArrayList	list;
+				string[]	result;
+
+				// Initially store into something that we can grow easily
+				list = new ArrayList(Entry.Count(entries));
+				e = entries;
+
+				if (convertible) {
+					// Add the convertibles
+					Entry text_entry = Entry.Find (entries, DataFormats.Text);
+					Entry utext_entry = Entry.Find (entries, DataFormats.UnicodeText);
+					Entry string_entry = Entry.Find (entries, DataFormats.StringFormat);
+					bool text_convertible = text_entry != null && text_entry.AutoConvert;
+					bool utext_convertible = utext_entry != null && utext_entry.AutoConvert;
+					bool string_convertible = string_entry != null && string_entry.AutoConvert;
+
+					if (text_convertible || utext_convertible || string_convertible) {
+						list.Add (DataFormats.StringFormat);
+						list.Add (DataFormats.UnicodeText);
+						list.Add (DataFormats.Text);
+					}
+				}
+
+				while (e != null) {
+					if (!list.Contains (e.type))
+						list.Add (e.type);
+					e = e.next;
+				}
+
+				// Copy the results into a string array
+				result = new string[list.Count];
+				for (int i = 0; i < list.Count; i++) {
+					result[i] = (string)list[i];
+				}
+
+				return result;
+			}
+			#endregion	// Methods
+		}
+		#endregion	// DataObject.Entry class
+
+		#region Local Variables
+		private Entry	entries;
+		#endregion	// Local Variables
+
+		#region Public Constructors
+		public DataObject() {
+			entries = null;
+		}
+
+		public DataObject(object data) {
+			SetData(data);
+		}
+
+		public DataObject(string format, object data) {
+			SetData(format, data);
+		}
+		#endregion	// Public Constructors
+
+		#region Public Instance Methods
+		public virtual bool ContainsAudio ()
+		{
+			return GetDataPresent (DataFormats.WaveAudio, true);
+		}
+		
+		public virtual bool ContainsFileDropList ()
+		{
+			return GetDataPresent (DataFormats.FileDrop, true);
+		}
+		
+		public virtual bool ContainsImage ()
+		{
+			return GetDataPresent (DataFormats.Bitmap, true);
+		}
+		
+		public virtual bool ContainsText ()
+		{
+			return GetDataPresent (DataFormats.UnicodeText, true);
+		}
+		
+		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);
+		}
+		
+		public virtual Stream GetAudioStream ()
+		{
+			return (Stream)GetData (DataFormats.WaveAudio, true);
+		}
+
+		public virtual object GetData(string format) {
+			return GetData(format, true);
+		}
+
+		public virtual object GetData(string format, bool autoConvert) {
+			Entry e;
+			if (autoConvert) {
+				e = Entry.FindConvertible(entries, format);
+			} else {
+				e = Entry.Find(entries, format);
+			}
+			if (e == null)
+				return null;
+			return e.Data;
+		}
+
+		public virtual object GetData(Type format) {
+			return GetData(format.FullName, true);
+		}
+
+		public virtual bool GetDataPresent(string format) {
+			return GetDataPresent(format, true);
+		}
+
+		public virtual bool GetDataPresent(string format, bool autoConvert) {
+			if (autoConvert) {
+				return Entry.FindConvertible(entries, format) != null;
+			} else {
+				return Entry.Find(entries, format) != null;
+			}
+		}
+
+		public virtual bool GetDataPresent(Type format) {
+			return GetDataPresent(format.FullName, true);
+		}
+
+		public virtual StringCollection GetFileDropList ()
+		{
+			return (StringCollection)GetData (DataFormats.FileDrop, true);
+		}
+		public virtual string[] GetFormats() {
+			return GetFormats(true);
+		}
+
+		public virtual string[] GetFormats(bool autoConvert) {
+			return Entry.Entries(entries, autoConvert);
+		}
+
+		public virtual Image GetImage ()
+		{
+			return (Image)GetData (DataFormats.Bitmap, true);
+		}
+
+		public virtual string GetText ()
+		{
+			return (string)GetData (DataFormats.UnicodeText, true);
+		}
+
+		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);
+		}
+
+		public virtual void SetAudio (byte[] audioBytes)
+		{
+			if (audioBytes == null)
+				throw new ArgumentNullException ("audioBytes");
+
+			MemoryStream ms = new MemoryStream (audioBytes);
+
+			SetAudio (ms);
+		}
+
+		public virtual void SetAudio (Stream audioStream)
+		{
+			if (audioStream == null)
+				throw new ArgumentNullException ("audioStream");
+
+			SetData (DataFormats.WaveAudio, audioStream);
+		}
+
+		public virtual void SetData(object data) {
+			SetData(data.GetType(), data); 
+		}
+
+		public virtual void SetData(string format, bool autoConvert, object data) {
+			Entry	entry;
+			Entry	e;
+
+			entry = Entry.Find(entries, format);
+
+			if (entry == null) {
+				entry = new DataObject.Entry(format, data, autoConvert);
+			} else {
+				entry.Data = data;
+				return;
+			}
+
+			lock (this) {
+				if (entries == null) {
+					entries = entry;
+				} else {
+					// Insert into the list of known/defined formats
+					e = entries;
+
+					while (e.next != null) {
+						e = e.next;
+					}
+					e.next = entry;
+				}
+			}
+		}
+
+		public virtual void SetData(string format, object data) {
+			SetData(format, true, data);
+		}
+
+		public virtual void SetData(Type format, object data) {
+			SetData(EnsureFormat(format), true, data);
+		}
+		
+		[MonoInternalNote ("Needs additional checks for valid paths, see MSDN")]
+		public virtual void SetFileDropList (StringCollection filePaths)
+		{
+			if (filePaths == null)
+				throw new ArgumentNullException ("filePaths");
+
+			SetData (DataFormats.FileDrop, filePaths);
+		}
+
+		public virtual void SetImage (Image image)
+		{
+			if (image == null)
+				throw new ArgumentNullException ("image");
+
+			SetData (DataFormats.Bitmap, image);
+		}
+
+		public virtual void SetText (string textData)
+		{
+			if (string.IsNullOrEmpty (textData))
+				throw new ArgumentNullException ("text");
+
+			SetData (DataFormats.UnicodeText, textData);
+		}
+
+		public virtual void SetText (string textData, TextDataFormat format)
+		{
+			if (string.IsNullOrEmpty (textData))
+				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, textData);
+					break;
+				case TextDataFormat.UnicodeText:
+					SetData (DataFormats.UnicodeText, textData);
+					break;
+				case TextDataFormat.Rtf:
+					SetData (DataFormats.Rtf, textData);
+					break;
+				case TextDataFormat.Html:
+					SetData (DataFormats.Html, textData);
+					break;
+				case TextDataFormat.CommaSeparatedValue:
+					SetData (DataFormats.CommaSeparatedValue, textData);
+					break;
+			}
+		}
+		#endregion	// Public Instance Methods
+
+		#region Private Methods
+		internal string EnsureFormat(string name) {
+			DataFormats.Format f;
+
+			f = DataFormats.Format.Find(name);
+			if (f == null) {
+				// Register the format
+				f = DataFormats.Format.Add(name);
+			}
+
+			return f.Name;
+		}
+
+		internal string EnsureFormat(Type type) {
+			return EnsureFormat(type.FullName);
+		}
+
+		private string TextFormatToDataFormat (TextDataFormat format)
+		{
+			switch (format) {
+				case TextDataFormat.Text:
+				default:
+					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;
+			}
+		}
+		#endregion	// Private Methods
+
+		#region IDataObject Members
+		int System.Runtime.InteropServices.ComTypes.IDataObject.DAdvise (ref System.Runtime.InteropServices.ComTypes.FORMATETC pFormatetc, System.Runtime.InteropServices.ComTypes.ADVF advf, System.Runtime.InteropServices.ComTypes.IAdviseSink adviseSink, out int connection)
+		{
+			throw new NotImplementedException ();
+		}
+
+		void System.Runtime.InteropServices.ComTypes.IDataObject.DUnadvise (int connection)
+		{
+			throw new NotImplementedException ();
+		}
+
+		int System.Runtime.InteropServices.ComTypes.IDataObject.EnumDAdvise (out System.Runtime.InteropServices.ComTypes.IEnumSTATDATA enumAdvise)
+		{
+			throw new NotImplementedException ();
+		}
+
+		System.Runtime.InteropServices.ComTypes.IEnumFORMATETC System.Runtime.InteropServices.ComTypes.IDataObject.EnumFormatEtc (System.Runtime.InteropServices.ComTypes.DATADIR direction)
+		{
+			throw new NotImplementedException ();
+		}
+
+		int System.Runtime.InteropServices.ComTypes.IDataObject.GetCanonicalFormatEtc (ref System.Runtime.InteropServices.ComTypes.FORMATETC formatIn, out System.Runtime.InteropServices.ComTypes.FORMATETC formatOut)
+		{
+			throw new NotImplementedException ();
+		}
+
+		void System.Runtime.InteropServices.ComTypes.IDataObject.GetData (ref System.Runtime.InteropServices.ComTypes.FORMATETC format, out System.Runtime.InteropServices.ComTypes.STGMEDIUM medium)
+		{
+			throw new NotImplementedException ();
+		}
+
+		void System.Runtime.InteropServices.ComTypes.IDataObject.GetDataHere (ref System.Runtime.InteropServices.ComTypes.FORMATETC format, ref System.Runtime.InteropServices.ComTypes.STGMEDIUM medium)
+		{
+			throw new NotImplementedException ();
+		}
+
+		int System.Runtime.InteropServices.ComTypes.IDataObject.QueryGetData (ref System.Runtime.InteropServices.ComTypes.FORMATETC format)
+		{
+			throw new NotImplementedException ();
+		}
+
+		void System.Runtime.InteropServices.ComTypes.IDataObject.SetData (ref System.Runtime.InteropServices.ComTypes.FORMATETC formatIn, ref System.Runtime.InteropServices.ComTypes.STGMEDIUM medium, bool release)
+		{
+			throw new NotImplementedException ();
+		}
+		#endregion
+	 }
+}