diff options
Diffstat (limited to 'source/ShiftUI/Internal')
180 files changed, 71265 insertions, 0 deletions
diff --git a/source/ShiftUI/Internal/ApplicationHandler.cs b/source/ShiftUI/Internal/ApplicationHandler.cs new file mode 100644 index 0000000..df7d3d6 --- /dev/null +++ b/source/ShiftUI/Internal/ApplicationHandler.cs @@ -0,0 +1,78 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton <[email protected]> +// +// + +using System; + +namespace ShiftUI.CarbonInternal { + internal class ApplicationHandler : EventHandlerBase, IEventHandler { + internal const uint kEventAppActivated = 1; + internal const uint kEventAppDeactivated = 2; + internal const uint kEventAppQuit = 3; + internal const uint kEventAppLaunchNotification = 4; + internal const uint kEventAppLaunched = 5; + internal const uint kEventAppTerminated = 6; + internal const uint kEventAppFrontSwitched = 7; + internal const uint kEventAppFocusMenuBar = 8; + internal const uint kEventAppFocusNextDocumentWindow = 9; + internal const uint kEventAppFocusNextFloatingWindow = 10; + internal const uint kEventAppFocusToolbar = 11; + internal const uint kEventAppFocusDrawer = 12; + internal const uint kEventAppGetDockTileMenu = 20; + internal const uint kEventAppIsEventInInstantMouser = 104; + internal const uint kEventAppHidden = 107; + internal const uint kEventAppShown = 108; + internal const uint kEventAppSystemUIModeChanged = 109; + internal const uint kEventAppAvailableWindowBoundsChanged = 110; + internal const uint kEventAppActiveWindowChanged = 111; + + internal ApplicationHandler (XplatUICarbon driver) : base (driver) {} + + public bool ProcessEvent (IntPtr callref, IntPtr eventref, IntPtr handle, uint kind, ref MSG msg) { + switch (kind) { + case kEventAppActivated: { + foreach (IntPtr utility_window in XplatUICarbon.UtilityWindows) + if (!XplatUICarbon.IsWindowVisible (utility_window)) + XplatUICarbon.ShowWindow (utility_window); + break; + } + case kEventAppDeactivated: { + if (XplatUICarbon.FocusWindow != IntPtr.Zero) { + Driver.SendMessage (XplatUICarbon.FocusWindow, Msg.WM_KILLFOCUS, IntPtr.Zero, IntPtr.Zero); + } + if (XplatUICarbon.Grab.Hwnd != IntPtr.Zero) { + Driver.SendMessage (Hwnd.ObjectFromHandle (XplatUICarbon.Grab.Hwnd).Handle, Msg.WM_LBUTTONDOWN, (IntPtr)MsgButtons.MK_LBUTTON, (IntPtr) (Driver.MousePosition.X << 16 | Driver.MousePosition.Y)); + } + foreach (IntPtr utility_window in XplatUICarbon.UtilityWindows) + if (XplatUICarbon.IsWindowVisible (utility_window)) + XplatUICarbon.HideWindow (utility_window); + break; + } + } + + return true; + } + } +} diff --git a/source/ShiftUI/Internal/ArrangedElementCollection.cs b/source/ShiftUI/Internal/ArrangedElementCollection.cs new file mode 100644 index 0000000..61f5e52 --- /dev/null +++ b/source/ShiftUI/Internal/ArrangedElementCollection.cs @@ -0,0 +1,173 @@ +// +// ArrangedElementCollection.cs +// +// 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) 2006 Jonathan Pobst +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +using System.Collections; +using System; + +namespace ShiftUI.Layout +{ + public class ArrangedElementCollection : IList, ICollection, IEnumerable + { + internal ArrayList list; + + internal ArrangedElementCollection () + { + this.list = new ArrayList (); + } + + #region Public Properties + public virtual int Count { get { return list.Count; } } + public virtual bool IsReadOnly { get { return list.IsReadOnly; } } + #endregion + + #region Public Methods + public void CopyTo (Array array, int index) + { + list.CopyTo (array, index); + } + + public override bool Equals (object obj) + { + if (obj is ArrangedElementCollection && this == obj) + return (true); + else + return (false); + } + + public virtual IEnumerator GetEnumerator () + { + return list.GetEnumerator (); + } + + public override int GetHashCode () + { + return base.GetHashCode (); + } + #endregion + + #region IList Members + int IList.Add (object value) + { + return Add (value); + } + + internal int Add (object value) + { + return list.Add (value); + } + + void IList.Clear () + { + Clear (); + } + + internal void Clear () + { + list.Clear (); + } + + bool IList.Contains (object value) + { + return Contains (value); + } + + internal bool Contains (object value) + { + return list.Contains (value); + } + + int IList.IndexOf (object value) + { + return IndexOf (value); + } + + internal int IndexOf (object value) + { + return list.IndexOf (value); + } + + void IList.Insert (int index, object value) + { + throw new NotSupportedException (); + } + + internal void Insert (int index, object value) + { + list.Insert (index, value); + } + + bool IList.IsFixedSize { + get { return this.IsFixedSize; } + } + + internal bool IsFixedSize { + get { return list.IsFixedSize; } + } + + void IList.Remove (object value) + { + Remove (value); + } + + internal void Remove (object value) + { + list.Remove (value); + } + + void IList.RemoveAt (int index) + { + list.RemoveAt (index); + } + + internal void InternalRemoveAt (int index) + { + list.RemoveAt (index); + } + + object IList.this[int index] { + get { return this[index]; } + set { this[index] = value; } + } + + internal object this[int index] { + get { return list[index]; } + set { list[index] = value; } + } + #endregion + + #region ICollection Members + bool ICollection.IsSynchronized { + get { return list.IsSynchronized; } + } + + object ICollection.SyncRoot { + get { return list.IsSynchronized; } + } + #endregion + } +} diff --git a/source/ShiftUI/Internal/AsyncMethodData.cs b/source/ShiftUI/Internal/AsyncMethodData.cs new file mode 100644 index 0000000..707ce62 --- /dev/null +++ b/source/ShiftUI/Internal/AsyncMethodData.cs @@ -0,0 +1,41 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) + + +using System; +using System.Threading; + + +namespace ShiftUI { + + internal class AsyncMethodData { + public IntPtr Handle; + public Delegate Method; + public object [] Args; + public AsyncMethodResult Result; + public ExecutionContext Context; + public SynchronizationContext SyncContext; + } + +} diff --git a/source/ShiftUI/Internal/AsyncMethodResult.cs b/source/ShiftUI/Internal/AsyncMethodResult.cs new file mode 100644 index 0000000..48c480d --- /dev/null +++ b/source/ShiftUI/Internal/AsyncMethodResult.cs @@ -0,0 +1,108 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) + + +using System; +using System.Threading; + +namespace ShiftUI { + + internal class AsyncMethodResult : IAsyncResult { + + private ManualResetEvent handle; + private object state; + private bool completed; + private object return_value; + private Exception exception; + + public AsyncMethodResult () + { + handle = new ManualResetEvent (false); + } + + public virtual WaitHandle AsyncWaitHandle { + get { + lock (this) { + return handle; + } + } + } + + public object AsyncState { + get { return state; } + set { state = value; } + } + + public bool CompletedSynchronously { + get { return false; } + } + + public bool IsCompleted { + get { + lock (this) { + return completed; + } + } + } + + public object EndInvoke () + { + lock (this) { + if (completed) { + if (exception == null) + return return_value; + else + throw exception; + } + } + handle.WaitOne (); + + if (exception != null) + throw exception; + + return return_value; + } + + public void Complete (object result) + { + lock (this) { + completed = true; + return_value = result; + handle.Set (); + } + } + + public void CompleteWithException (Exception ex) + { + lock (this) { + completed = true; + exception = ex; + handle.Set (); + } + } + } + +} + + diff --git a/source/ShiftUI/Internal/AutoCompleteSource.cs b/source/ShiftUI/Internal/AutoCompleteSource.cs new file mode 100644 index 0000000..ab2fc6a --- /dev/null +++ b/source/ShiftUI/Internal/AutoCompleteSource.cs @@ -0,0 +1,44 @@ +// +// AutoCompleteSource.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + + +namespace ShiftUI +{ + public enum AutoCompleteSource + { + FileSystem = 1, + HistoryList = 2, + RecentlyUsedList = 4, + AllUrl = 6, + AllSystemSources = 7, + FileSystemDirectories = 32, + CustomSource = 64, + None = 128, + ListItems = 256 + } +} diff --git a/source/ShiftUI/Internal/AutoCompleteStringCollection.cs b/source/ShiftUI/Internal/AutoCompleteStringCollection.cs new file mode 100644 index 0000000..2142d47 --- /dev/null +++ b/source/ShiftUI/Internal/AutoCompleteStringCollection.cs @@ -0,0 +1,203 @@ +// +// AutoCompleteStringCollection.cs +// +// 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) 2006 Daniel Nauck +// +// Author: +// Daniel Nauck (dna(at)mono-project(dot)de) + + +using System; +using System.Collections; +using System.ComponentModel; +using System.Reflection; + +namespace ShiftUI +{ + public class AutoCompleteStringCollection : IList, ICollection, IEnumerable + { + private ArrayList list = null; + + public AutoCompleteStringCollection () + { + list = new ArrayList (); + } + + public event CollectionChangeEventHandler CollectionChanged; + + protected void OnCollectionChanged (CollectionChangeEventArgs e) + { + if(CollectionChanged == null) + return; + + CollectionChanged (this, e); + } + + #region IEnumerable Members + + public IEnumerator GetEnumerator () + { + return list.GetEnumerator (); + } + + #endregion + + #region ICollection Members + + void ICollection.CopyTo (Array array, int index) + { + list.CopyTo (array, index); + } + + public void CopyTo (string[] array, int index) + { + list.CopyTo (array, index); + } + + public int Count + { + get { return list.Count; } + } + + public bool IsSynchronized + { + get { return false; } + } + + public object SyncRoot + { + get { return this; } + } + + #endregion + + #region IList Members + + int IList.Add (object value) + { + return Add ((string)value); + } + + public int Add (string value) + { + int index = list.Add (value); + OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Add, value)); + return index; + } + + public void AddRange (string[] value) + { + if (value == null) + throw new ArgumentNullException ("value", "Argument cannot be null!"); + + list.AddRange (value); + OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Refresh, null)); + } + + public void Clear () + { + list.Clear (); + OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Refresh, null)); + } + + bool IList.Contains (object value) + { + return Contains ((string)value); + } + + public bool Contains (string value) + { + return list.Contains (value); + } + + int IList.IndexOf (object value) + { + return IndexOf ((string)value); + } + + public int IndexOf (string value) + { + return list.IndexOf (value); + } + + void IList.Insert (int index, object value) + { + Insert (index, (string)value); + } + + public void Insert (int index, string value) + { + list.Insert (index, value); + OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Add, value)); + } + + bool IList.IsFixedSize + { + get { return false; } + } + + bool IList.IsReadOnly + { + get { return false; } + } + + public bool IsReadOnly + { + get { return false; } + } + + void IList.Remove (object value) + { + Remove((string)value); + } + + public void Remove (string value) + { + list.Remove (value); + OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Remove, value)); + } + + public void RemoveAt (int index) + { + string value = this[index]; + list.RemoveAt (index); + OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Remove, value)); + } + + object IList.this[int index] + { + get { return this[index]; } + set { this[index] = (string)value; } + } + + public string this[int index] + { + get { return (string)list[index]; } + set { + OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Remove, list[index])); + list[index] = value; + OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Add, value)); + } + } + #endregion + } +} diff --git a/source/ShiftUI/Internal/BaseCollection.cs b/source/ShiftUI/Internal/BaseCollection.cs new file mode 100644 index 0000000..91b3661 --- /dev/null +++ b/source/ShiftUI/Internal/BaseCollection.cs @@ -0,0 +1,99 @@ +// 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) 2004-2005 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// + + +// COMPLETE + +using System; +using System.Collections; +using System.ComponentModel; + +namespace ShiftUI { + public class BaseCollection : MarshalByRefObject, ICollection, IEnumerable { + internal ArrayList list; + + #region Public Constructors + public BaseCollection () + { + } + #endregion // Public Constructors + + #region Public Instance Properties + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Advanced)] + public virtual int Count { + get { + return List.Count; + } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Advanced)] + public bool IsReadOnly { + get { + return false; + } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Advanced)] + public bool IsSynchronized { + get { + return false; + } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Advanced)] + public object SyncRoot { + get { + return this; + } + } + #endregion // Public Instance Properties + + #region Protected Instance Properties + protected virtual ArrayList List { + get { + if (list == null) + list = new ArrayList (); + return list; + } + } + #endregion // Protected Instance Properties + + #region Public Instance Methods + public void CopyTo (Array ar, int index) + { + List.CopyTo (ar, index); + } + + public IEnumerator GetEnumerator () + { + return List.GetEnumerator (); + } + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/Binding.cs b/source/ShiftUI/Internal/Binding.cs new file mode 100644 index 0000000..7b6ccc7 --- /dev/null +++ b/source/ShiftUI/Internal/Binding.cs @@ -0,0 +1,578 @@ +// 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) 2004-2005 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// Jackson Harper [email protected] +// + + +using System.ComponentModel; +using System; + +namespace ShiftUI { + + [TypeConverter (typeof (ListBindingConverter))] + public class Binding { + + private string property_name; + private object data_source; + private string data_member; + + private bool is_binding; + private bool checked_isnull; + + private BindingMemberInfo binding_member_info; + private IBindableComponent control; + + private BindingManagerBase manager; + private PropertyDescriptor control_property; + private PropertyDescriptor is_null_desc; + + private object data; + private Type data_type; + + private DataSourceUpdateMode datasource_update_mode; + private ControlUpdateMode control_update_mode; + private object datasource_null_value = Convert.DBNull; + private object null_value; + private IFormatProvider format_info; + private string format_string; + private bool formatting_enabled; + #region Public Constructors + public Binding (string propertyName, object dataSource, string dataMember) + : this (propertyName, dataSource, dataMember, false, DataSourceUpdateMode.OnValidation, null, string.Empty, null) + { + } + + public Binding (string propertyName, object dataSource, string dataMember, bool formattingEnabled) + : this (propertyName, dataSource, dataMember, formattingEnabled, DataSourceUpdateMode.OnValidation, null, string.Empty, null) + { + } + + public Binding (string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode dataSourceUpdateMode) + : this (propertyName, dataSource, dataMember, formattingEnabled, dataSourceUpdateMode, null, string.Empty, null) + { + } + + public Binding (string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode dataSourceUpdateMode, object nullValue) + : this (propertyName, dataSource, dataMember, formattingEnabled, dataSourceUpdateMode, nullValue, string.Empty, null) + { + } + + public Binding (string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode dataSourceUpdateMode, object nullValue, string formatString) + : this (propertyName, dataSource, dataMember, formattingEnabled, dataSourceUpdateMode, nullValue, formatString, null) + { + } + + public Binding (string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode dataSourceUpdateMode, object nullValue, string formatString, IFormatProvider formatInfo) + { + property_name = propertyName; + data_source = dataSource; + data_member = dataMember; + binding_member_info = new BindingMemberInfo (dataMember); + datasource_update_mode = dataSourceUpdateMode; + null_value = nullValue; + format_string = formatString; + format_info = formatInfo; + } + #endregion // Public Constructors + + #region Public Instance Properties + [DefaultValue (null)] + public IBindableComponent BindableComponent { + get { + return control; + } + } + + public BindingManagerBase BindingManagerBase { + get { + return manager; + } + } + + public BindingMemberInfo BindingMemberInfo { + get { + return binding_member_info; + } + } + + [DefaultValue (null)] + public Widget Widget { + get { + return control as Widget; + } + } + + [DefaultValue (ControlUpdateMode.OnPropertyChanged)] + public ControlUpdateMode ControlUpdateMode { + get { + return control_update_mode; + } + set { + control_update_mode = value; + } + } + + public object DataSource { + get { + return data_source; + } + } + + [DefaultValue (DataSourceUpdateMode.OnValidation)] + public DataSourceUpdateMode DataSourceUpdateMode { + get { + return datasource_update_mode; + } + set { + datasource_update_mode = value; + } + } + + public object DataSourceNullValue { + get { + return datasource_null_value; + } + set { + datasource_null_value = value; + } + } + + [DefaultValue (false)] + public bool FormattingEnabled { + get { + return formatting_enabled; + } + set { + if (formatting_enabled == value) + return; + + formatting_enabled = value; + PushData (); + } + } + + [DefaultValue (null)] + public IFormatProvider FormatInfo { + get { + return format_info; + } + set { + if (value == format_info) + return; + + format_info = value; + if (formatting_enabled) + PushData (); + } + } + + public string FormatString { + get { + return format_string; + } + set { + if (value == null) + value = String.Empty; + if (value == format_string) + return; + + format_string = value; + if (formatting_enabled) + PushData (); + } + } + + public bool IsBinding { + get { + if (manager == null || manager.IsSuspended) + return false; + + return is_binding; + } + } + + public object NullValue { + get { + return null_value; + } + set { + if (value == null_value) + return; + + null_value = value; + if (formatting_enabled) + PushData (); + } + } + + [DefaultValue ("")] + public string PropertyName { + get { + return property_name; + } + } + #endregion // Public Instance Properties + + public void ReadValue () + { + PushData (true); + } + + public void WriteValue () + { + PullData (true); + } + + #region Protected Instance Methods + protected virtual void OnBindingComplete (BindingCompleteEventArgs e) + { + if (BindingComplete != null) + BindingComplete (this, e); + } + + protected virtual void OnFormat (ConvertEventArgs cevent) + { + if (Format!=null) + Format (this, cevent); + } + + protected virtual void OnParse (ConvertEventArgs cevent) + { + if (Parse!=null) + Parse (this, cevent); + } + #endregion // Protected Instance Methods + + internal string DataMember { + get { return data_member; } + } + + internal void SetWidget (IBindableComponent control) + { + if (control == this.control) + return; + + control_property = TypeDescriptor.GetProperties (control).Find (property_name, true); + + if (control_property == null) + throw new ArgumentException (String.Concat ("Cannot bind to property '", property_name, "' on target control.")); + if (control_property.IsReadOnly) + throw new ArgumentException (String.Concat ("Cannot bind to property '", property_name, "' because it is read only.")); + + data_type = control_property.PropertyType; // Getting the PropertyType is kinda slow and it should never change, so it is cached + + Widget ctrl = control as Widget; + if (ctrl != null) { + ctrl.Validating += new CancelEventHandler (ControlValidatingHandler); + if (!ctrl.IsHandleCreated) + ctrl.HandleCreated += new EventHandler (ControlCreatedHandler); + } + + EventDescriptor prop_changed_event = GetPropertyChangedEvent (control, property_name); + if (prop_changed_event != null) + prop_changed_event.AddEventHandler (control, new EventHandler (ControlPropertyChangedHandler)); + this.control = control; + UpdateIsBinding (); + } + + internal void Check () + { + if (control == null || control.BindingContext == null) + return; + + if (manager == null) { + manager = control.BindingContext [data_source, binding_member_info.BindingPath]; + + if (manager.Position > -1 && binding_member_info.BindingField != String.Empty && + TypeDescriptor.GetProperties (manager.Current).Find (binding_member_info.BindingField, true) == null) + throw new ArgumentException ("Cannot bind to property '" + binding_member_info.BindingField + "' on DataSource.", + "dataMember"); + + manager.AddBinding (this); + manager.PositionChanged += new EventHandler (PositionChangedHandler); + + if (manager is PropertyManager) { // Match .net, which only watchs simple objects + EventDescriptor prop_changed_event = GetPropertyChangedEvent (manager.Current, binding_member_info.BindingField); + if (prop_changed_event != null) + prop_changed_event.AddEventHandler (manager.Current, new EventHandler (SourcePropertyChangedHandler)); + } + } + + if (manager.Position == -1) + return; + + if (!checked_isnull) { + is_null_desc = TypeDescriptor.GetProperties (manager.Current).Find (property_name + "IsNull", false); + checked_isnull = true; + } + + PushData (); + } + + internal bool PullData () + { + return PullData (false); + } + + // Return false ONLY in case of error - and return true even in cases + // where no update was possible + bool PullData (bool force) + { + if (IsBinding == false || manager.Current == null) + return true; + if (!force && datasource_update_mode == DataSourceUpdateMode.Never) + return true; + + data = control_property.GetValue (control); + if (data == null) + data = datasource_null_value; + + try { + SetPropertyValue (data); + } catch (Exception e) { + if (formatting_enabled) { + FireBindingComplete (BindingCompleteContext.DataSourceUpdate, e, e.Message); + return false; + } + throw e; + } + + if (formatting_enabled) + FireBindingComplete (BindingCompleteContext.DataSourceUpdate, null, null); + return true; + } + + internal void PushData () + { + PushData (false); + } + + void PushData (bool force) + { + if (manager == null || manager.IsSuspended || manager.Count == 0 || manager.Position == -1) + return; + if (!force && control_update_mode == ControlUpdateMode.Never) + return; + + if (is_null_desc != null) { + bool is_null = (bool) is_null_desc.GetValue (manager.Current); + if (is_null) { + data = Convert.DBNull; + return; + } + } + + PropertyDescriptor pd = TypeDescriptor.GetProperties (manager.Current).Find (binding_member_info.BindingField, true); + if (pd == null) { + data = manager.Current; + } else { + data = pd.GetValue (manager.Current); + } + + if ((data == null || data == DBNull.Value) && null_value != null) + data = null_value; + + try { + data = FormatData (data); + SetControlValue (data); + } catch (Exception e) { + if (formatting_enabled) { + FireBindingComplete (BindingCompleteContext.ControlUpdate, e, e.Message); + return; + } + throw e; + } + + if (formatting_enabled) + FireBindingComplete (BindingCompleteContext.ControlUpdate, null, null); + } + + internal void UpdateIsBinding () + { + is_binding = false; + if (control == null || (control is Widget && !((Widget)control).IsHandleCreated)) + return; + + is_binding = true; + PushData (); + } + + private void SetControlValue (object data) + { + control_property.SetValue (control, data); + } + + private void SetPropertyValue (object data) + { + PropertyDescriptor pd = TypeDescriptor.GetProperties (manager.Current).Find (binding_member_info.BindingField, true); + if (pd.IsReadOnly) + return; + data = ParseData (data, pd.PropertyType); + pd.SetValue (manager.Current, data); + } + + private void ControlValidatingHandler (object sender, CancelEventArgs e) + { + if (datasource_update_mode != DataSourceUpdateMode.OnValidation) + return; + + bool ok = true; + // If the data doesn't seem to be valid (it can't be converted, + // is the wrong type, etc, we reset to the old data value. + // If Formatting is enabled, no exception is fired, but we get a false value + try { + ok = PullData (); + } catch { + ok = false; + } + + e.Cancel = !ok; + } + + private void ControlCreatedHandler (object o, EventArgs args) + { + UpdateIsBinding (); + } + + private void PositionChangedHandler (object sender, EventArgs e) + { + Check (); + PushData (); + } + + EventDescriptor GetPropertyChangedEvent (object o, string property_name) + { + if (o == null || property_name == null || property_name.Length == 0) + return null; + + string event_name = property_name + "Changed"; + Type event_handler_type = typeof (EventHandler); + + EventDescriptor prop_changed_event = null; + foreach (EventDescriptor event_desc in TypeDescriptor.GetEvents (o)) { + if (event_desc.Name == event_name && event_desc.EventType == event_handler_type) { + prop_changed_event = event_desc; + break; + } + } + + return prop_changed_event; + } + + void SourcePropertyChangedHandler (object o, EventArgs args) + { + PushData (); + } + + void ControlPropertyChangedHandler (object o, EventArgs args) + { + if (datasource_update_mode != DataSourceUpdateMode.OnPropertyChanged) + return; + + PullData (); + } + + private object ParseData (object data, Type data_type) + { + ConvertEventArgs e = new ConvertEventArgs (data, data_type); + + OnParse (e); + if (data_type.IsInstanceOfType (e.Value)) + return e.Value; + if (e.Value == Convert.DBNull) + return e.Value; + if (e.Value == null) { + bool nullable = data_type.IsGenericType && !data_type.ContainsGenericParameters && + data_type.GetGenericTypeDefinition () == typeof (Nullable<>); + return data_type.IsValueType && !nullable ? Convert.DBNull : null; + } + + return ConvertData (e.Value, data_type); + } + + private object FormatData (object data) + { + ConvertEventArgs e = new ConvertEventArgs (data, data_type); + + OnFormat (e); + if (data_type.IsInstanceOfType (e.Value)) + return e.Value; + + if (formatting_enabled) { + if ((e.Value == null || e.Value == Convert.DBNull) && null_value != null) + return null_value; + + if (e.Value is IFormattable && data_type == typeof (string)) { + IFormattable formattable = (IFormattable) e.Value; + return formattable.ToString (format_string, format_info); + } + } + + if (e.Value == null && data_type == typeof (object)) + return Convert.DBNull; + + return ConvertData (data, data_type); + } + + private object ConvertData (object data, Type data_type) + { + if (data == null) + return null; + + TypeConverter converter = TypeDescriptor.GetConverter (data.GetType ()); + if (converter != null && converter.CanConvertTo (data_type)) + return converter.ConvertTo (data, data_type); + + converter = TypeDescriptor.GetConverter (data_type); + if (converter != null && converter.CanConvertFrom (data.GetType())) + return converter.ConvertFrom (data); + + if (data is IConvertible) { + object res = Convert.ChangeType (data, data_type); + if (data_type.IsInstanceOfType (res)) + return res; + } + + return null; + } + void FireBindingComplete (BindingCompleteContext context, Exception exc, string error_message) + { + BindingCompleteEventArgs args = new BindingCompleteEventArgs (this, + exc == null ? BindingCompleteState.Success : BindingCompleteState.Exception, + context); + if (exc != null) { + args.SetException (exc); + args.SetErrorText (error_message); + } + + OnBindingComplete (args); + } + + #region Events + public event ConvertEventHandler Format; + public event ConvertEventHandler Parse; + public event BindingCompleteEventHandler BindingComplete; + #endregion // Events + } +} diff --git a/source/ShiftUI/Internal/BindingCompleteContext.cs b/source/ShiftUI/Internal/BindingCompleteContext.cs new file mode 100644 index 0000000..44d7347 --- /dev/null +++ b/source/ShiftUI/Internal/BindingCompleteContext.cs @@ -0,0 +1,37 @@ +// +// BindingCompleteContext.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + + +namespace ShiftUI +{ + public enum BindingCompleteContext + { + ControlUpdate = 0, + DataSourceUpdate = 1 + } +} diff --git a/source/ShiftUI/Internal/BindingContext.cs b/source/ShiftUI/Internal/BindingContext.cs new file mode 100644 index 0000000..fbf461a --- /dev/null +++ b/source/ShiftUI/Internal/BindingContext.cs @@ -0,0 +1,257 @@ +// 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) 2004-2005 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// Jackson Harper [email protected] + + +using System.Data; +using System.Collections; +using System.Globalization; +using System.ComponentModel; +using System; + +namespace ShiftUI { + + [DefaultEvent("CollectionChanged")] + public class BindingContext : ICollection, IEnumerable { + + private Hashtable managers; + private EventHandler onCollectionChangedHandler; + + private class HashKey { + public object source; + public string member; + + public HashKey (object source, string member) + { + this.source = source; + this.member = member; + } + + public override int GetHashCode () + { + return source.GetHashCode() ^ member.GetHashCode (); + } + + public override bool Equals (object o) + { + HashKey hk = o as HashKey; + if (hk == null) + return false; + return hk.source == source && hk.member == member; + } + } + + public BindingContext () + { + managers = new Hashtable (); + onCollectionChangedHandler = null; + } + + public bool IsReadOnly { + get { return false; } + } + + public BindingManagerBase this [object dataSource] { + get { return this [dataSource, String.Empty]; } + } + + public BindingManagerBase this [object dataSource, string dataMember] { + get { + if (dataSource == null) + throw new ArgumentNullException ("dataSource"); + if (dataMember == null) + dataMember = String.Empty; + + ICurrencyManagerProvider cm_provider = dataSource as ICurrencyManagerProvider; + if (cm_provider != null) { + if (dataMember.Length == 0) + return cm_provider.CurrencyManager; + + return cm_provider.GetRelatedCurrencyManager (dataMember); + } + + HashKey key = new HashKey (dataSource, dataMember); + BindingManagerBase res = managers [key] as BindingManagerBase; + + if (res != null) + return res; + + res = CreateBindingManager (dataSource, dataMember); + if (res == null) + return null; + managers [key] = res; + return res; + } + } + + private BindingManagerBase CreateBindingManager (object data_source, string data_member) + { + if (data_member == "") { + if (IsListType (data_source.GetType ())) + return new CurrencyManager (data_source); + else + return new PropertyManager (data_source); + } + else { + BindingMemberInfo info = new BindingMemberInfo (data_member); + + BindingManagerBase parent_manager = this[data_source, info.BindingPath]; + + PropertyDescriptor pd = parent_manager == null ? null : parent_manager.GetItemProperties ().Find (info.BindingField, true); + + if (pd == null) + throw new ArgumentException (String.Format ("Cannot create a child list for field {0}.", info.BindingField)); + + if (IsListType (pd.PropertyType)) + return new RelatedCurrencyManager (parent_manager, pd); + else + return new RelatedPropertyManager (parent_manager, info.BindingField); + } + } + + bool IsListType (Type t) + { + return (typeof (IList).IsAssignableFrom (t) + || typeof (IListSource).IsAssignableFrom (t)); + } + + #region Public Instance Methods + public bool Contains(object dataSource) + { + return Contains (dataSource, String.Empty); + } + + public bool Contains (object dataSource, string dataMember) + { + if (dataSource == null) + throw new ArgumentNullException ("dataSource"); + if (dataMember == null) + dataMember = String.Empty; + + HashKey key = new HashKey (dataSource, dataMember); + return managers [key] != null; + } + #endregion // Public Instance Methods + + #region Protected Instance Methods + + protected internal void Add (object dataSource, BindingManagerBase listManager) + { + AddCore (dataSource, listManager); + OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Add, dataSource)); + } + + protected virtual void AddCore (object dataSource, BindingManagerBase listManager) + { + if (dataSource == null) + throw new ArgumentNullException ("dataSource"); + if (listManager == null) + throw new ArgumentNullException ("listManager"); + + HashKey key = new HashKey (dataSource, String.Empty); + managers [key] = listManager; + } + + protected internal void Clear () + { + ClearCore(); + OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Refresh, null)); + } + + protected virtual void ClearCore () + { + managers.Clear (); + } + + protected virtual void OnCollectionChanged (CollectionChangeEventArgs ccevent) + { + if (onCollectionChangedHandler != null) { + onCollectionChangedHandler (this, ccevent); + } + } + + protected internal void Remove (object dataSource) + { + if (dataSource == null) + throw new ArgumentNullException ("dataSource"); + + RemoveCore (dataSource); + OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Remove, dataSource)); + } + + protected virtual void RemoveCore (object dataSource) + { + HashKey[] keys = new HashKey [managers.Keys.Count]; + managers.Keys.CopyTo (keys, 0); + + for (int i = 0; i < keys.Length; i ++) { + if (keys[i].source == dataSource) + managers.Remove (keys[i]); + } + } + + [MonoTODO ("Stub, does nothing")] + public static void UpdateBinding (BindingContext newBindingContext, Binding binding) + { + } + + #endregion // Protected Instance Methods + + #region Events + [Browsable (false)] + //[EditorBrowsable (EditorBrowsableState.Never)] + public event CollectionChangeEventHandler CollectionChanged { + add { throw new NotImplementedException (); } + remove { /* nothing to do here.. */ } + } + #endregion // Events + + #region ICollection Interfaces + void ICollection.CopyTo (Array ar, int index) + { + managers.CopyTo (ar, index); + } + + int ICollection.Count { + get { return managers.Count; } + } + + bool ICollection.IsSynchronized { + get { return false; } + } + + object ICollection.SyncRoot { + get { return null; } + } + + #endregion // ICollection Interfaces + + #region IEnumerable Interfaces + [MonoInternalNote ("our enumerator is slightly different. in MS's implementation the Values are WeakReferences to the managers.")] + IEnumerator IEnumerable.GetEnumerator() { + return managers.GetEnumerator (); + } + #endregion // IEnumerable Interfaces + } +} diff --git a/source/ShiftUI/Internal/BindingManagerBase.cs b/source/ShiftUI/Internal/BindingManagerBase.cs new file mode 100644 index 0000000..c2b0392 --- /dev/null +++ b/source/ShiftUI/Internal/BindingManagerBase.cs @@ -0,0 +1,204 @@ +// 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) 2004-2005 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// Jackson Harper [email protected] +// + + +// NOT COMPLETE + +using System.ComponentModel; +using System.Collections; +using System; + +namespace ShiftUI +{ + public abstract class BindingManagerBase + { + private BindingsCollection bindings; + internal bool transfering_data; /* true if we're pushing or pulling data */ + + #region Public Constructors + public BindingManagerBase() + { + } + #endregion // Public Constructors + + #region Protected Instance Fields + protected EventHandler onCurrentChangedHandler; + protected EventHandler onPositionChangedHandler; + internal EventHandler onCurrentItemChangedHandler; + #endregion // Protected Instance Fields + + #region Public Instance Properties + public BindingsCollection Bindings { + get { + if (bindings == null) { + bindings = new BindingsCollection (); + } + return bindings; + } + } + + public abstract int Count { + get; + } + + public abstract object Current { + get; + } + + public bool IsBindingSuspended { + get { + return IsSuspended; + } + } + + public abstract int Position { + get; set; + } + #endregion // Public Instance Properties + + #region Public Instance Methods + public abstract void AddNew(); + + public abstract void CancelCurrentEdit(); + + public abstract void EndCurrentEdit(); + + public virtual PropertyDescriptorCollection GetItemProperties() + { + return GetItemPropertiesInternal (); + } + + internal virtual PropertyDescriptorCollection GetItemPropertiesInternal () + { + throw new NotImplementedException (); + } + + public abstract void RemoveAt(int index); + + public abstract void ResumeBinding(); + + public abstract void SuspendBinding(); + #endregion // Public Instance Methods + + internal virtual bool IsSuspended { + get { + return false; + } + } + + #region Protected Instance Methods + [MonoTODO ("Not implemented, will throw NotImplementedException")] + protected internal virtual PropertyDescriptorCollection GetItemProperties (ArrayList dataSources, ArrayList listAccessors) + { + throw new NotImplementedException(); + } + + [MonoTODO ("Not implemented, will throw NotImplementedException")] + protected virtual PropertyDescriptorCollection GetItemProperties (Type listType, int offset, ArrayList dataSources, ArrayList listAccessors) + { + throw new NotImplementedException(); + } + + protected internal abstract string GetListName (ArrayList listAccessors); + + protected internal abstract void OnCurrentChanged (EventArgs e); + + protected void PullData() + { + try { + if (!transfering_data) { + transfering_data = true; + UpdateIsBinding (); + } + foreach (Binding binding in Bindings) { + binding.PullData (); + } + } finally { + transfering_data = false; + } + } + + protected void PushData() + { + try { + if (!transfering_data) { + transfering_data = true; + UpdateIsBinding (); + } + foreach (Binding binding in Bindings) { + binding.PushData (); + } + } finally { + transfering_data = false; + } + } + + + protected void OnBindingComplete (BindingCompleteEventArgs args) + { + if (BindingComplete != null) + BindingComplete (this, args); + } + + protected abstract void OnCurrentItemChanged (EventArgs e); + + protected void OnDataError (Exception e) + { + if (DataError != null) + DataError (this, new BindingManagerDataErrorEventArgs (e)); + } + + protected abstract void UpdateIsBinding(); + #endregion // Protected Instance Methods + + internal void AddBinding (Binding binding) + { + if (Bindings.Contains (binding)) + return; + Bindings.Add (binding); + } + + #region Events + public event EventHandler CurrentChanged { + add { onCurrentChangedHandler += value; } + remove { onCurrentChangedHandler -= value; } + } + + public event EventHandler PositionChanged { + add { onPositionChangedHandler += value; } + remove { onPositionChangedHandler -= value; } + } + + public event EventHandler CurrentItemChanged { + add { onCurrentItemChangedHandler += value; } + remove { onCurrentItemChangedHandler -= value; } + } + + public event BindingCompleteEventHandler BindingComplete; + public event BindingManagerDataErrorEventHandler DataError; + #endregion // Events + } +} diff --git a/source/ShiftUI/Internal/BindingMemberInfo.cs b/source/ShiftUI/Internal/BindingMemberInfo.cs new file mode 100644 index 0000000..3f7ae11 --- /dev/null +++ b/source/ShiftUI/Internal/BindingMemberInfo.cs @@ -0,0 +1,107 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// + + +// COMPLETE +using System; + +namespace ShiftUI { + public struct BindingMemberInfo { + private string data_member; + private string data_field; + private string data_path; + + #region Public Constructors + public BindingMemberInfo(string dataMember) { + int i; + + if (dataMember!=null) { + this.data_member=dataMember; + } else { + this.data_member=String.Empty; + } + + // Break out our components + i=data_member.LastIndexOf('.'); + if (i!=-1) { + data_field=data_member.Substring(i+1); + data_path=data_member.Substring(0, i); + } else { + data_field=data_member; + data_path=String.Empty; + } + } + #endregion // Public Constructors + + #region Public Instance Properties + public string BindingField { + get { + return this.data_field; + } + } + + public string BindingMember { + get { + return this.data_member; + } + } + + public string BindingPath { + get { + return this.data_path; + } + } + #endregion // Public Instance Properties + + #region Public Instance Methods + public override bool Equals(object otherObject) { + if (otherObject is BindingMemberInfo) { + return ((this.data_field == ((BindingMemberInfo)otherObject).data_field) && + (this.data_path == ((BindingMemberInfo)otherObject).data_path) && + (this.data_member == ((BindingMemberInfo)otherObject).data_member)); + } else { + return false; + } + } + + public override int GetHashCode() { + return this.data_member.GetHashCode(); + } + #endregion // Public Instance Methods + + #region Public Static Methods + public static bool operator == (BindingMemberInfo a, BindingMemberInfo b) + { + return (a.Equals (b)); + } + + public static bool operator != (BindingMemberInfo a, BindingMemberInfo b) + { + return !(a.Equals (b)); + } + #endregion // Public Static Methods + + } +} diff --git a/source/ShiftUI/Internal/BindingsCollection.cs b/source/ShiftUI/Internal/BindingsCollection.cs new file mode 100644 index 0000000..11f4fe9 --- /dev/null +++ b/source/ShiftUI/Internal/BindingsCollection.cs @@ -0,0 +1,136 @@ +// 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) 2004-2005 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// Jackson Harper [email protected] +// + + +// COMPLETE + +using System.Collections; +using System.ComponentModel; + +namespace ShiftUI { + [DefaultEvent("CollectionChanged")] + public class BindingsCollection : BaseCollection { + +#region Public Constructors + internal BindingsCollection () + { + } + #endregion // Public Constructors + + #region Public Instance Properties + public override int Count { + get { + return base.Count; + } + } + + public Binding this[int index] { + get { + return (Binding)(base.List[index]); + } + } + #endregion // Public Instance Properties + + #region Protected Instance Properties + protected override ArrayList List { + get { + return base.List; + } + } + #endregion // Protected Instance Properties + + #region Protected Instance Methods + protected internal void Add(Binding binding) { + AddCore(binding); + } + + protected virtual void AddCore (Binding dataBinding) + { + CollectionChangeEventArgs args = new CollectionChangeEventArgs (CollectionChangeAction.Add, dataBinding); + OnCollectionChanging (args); + base.List.Add(dataBinding); + OnCollectionChanged (args); + } + + protected internal void Clear() { + ClearCore(); + } + + protected virtual void ClearCore() + { + CollectionChangeEventArgs args = new CollectionChangeEventArgs(CollectionChangeAction.Refresh, null); + OnCollectionChanging (args); + base.List.Clear(); + OnCollectionChanged (args); + } + + protected virtual void OnCollectionChanged(System.ComponentModel.CollectionChangeEventArgs ccevent) { + if (CollectionChanged!=null) CollectionChanged(this, ccevent); + } + + protected virtual void OnCollectionChanging (CollectionChangeEventArgs e) + { + if (CollectionChanging != null) + CollectionChanging (this, e); + } + + protected internal void Remove(Binding binding) { + RemoveCore(binding); + } + + protected internal void RemoveAt(int index) { + base.List.RemoveAt(index); + OnCollectionChanged(new CollectionChangeEventArgs(CollectionChangeAction.Remove, base.List)); + } + + protected virtual void RemoveCore(Binding dataBinding) + { + CollectionChangeEventArgs args = new CollectionChangeEventArgs(CollectionChangeAction.Remove, dataBinding); + OnCollectionChanging (args); + base.List.Remove(dataBinding); + OnCollectionChanged (args); + } + + protected internal bool ShouldSerializeMyAll() { + if (this.Count>0) { + return(true); + } else { + return(false); + } + } + #endregion // Public Instance Methods + + internal bool Contains (Binding binding) + { + return List.Contains (binding); + } + + #region Events + public event CollectionChangeEventHandler CollectionChanged; + public event CollectionChangeEventHandler CollectionChanging; + #endregion // Events + } +} diff --git a/source/ShiftUI/Internal/BootMode.cs b/source/ShiftUI/Internal/BootMode.cs new file mode 100644 index 0000000..495d678 --- /dev/null +++ b/source/ShiftUI/Internal/BootMode.cs @@ -0,0 +1,39 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jordi Mas i Hernandez, [email protected] +// + +//COMPLETE + + +namespace ShiftUI +{ + + public enum BootMode + { + Normal = 0, + FailSafe = 1, + FailSafeWithNetwork = 2 + } +} + diff --git a/source/ShiftUI/Internal/BoundsSpecified.cs b/source/ShiftUI/Internal/BoundsSpecified.cs new file mode 100644 index 0000000..7acc040 --- /dev/null +++ b/source/ShiftUI/Internal/BoundsSpecified.cs @@ -0,0 +1,43 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// + +// COMPLETE +using System; + +namespace ShiftUI +{ + [Flags] + public enum BoundsSpecified + { + None = 0x00000000, + X = 0x00000001, + Y = 0x00000002, + Location = 0x00000003, + Width = 0x00000004, + Height = 0x00000008, + Size = 0x0000000c, + All = 0x0000000f + } +} diff --git a/source/ShiftUI/Internal/ButtonBase.cs b/source/ShiftUI/Internal/ButtonBase.cs new file mode 100644 index 0000000..7f8c894 --- /dev/null +++ b/source/ShiftUI/Internal/ButtonBase.cs @@ -0,0 +1,747 @@ +// 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) 2004-2006 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// + +using System.ComponentModel; +using System.ComponentModel.Design; +using System.Drawing; +using System.Drawing.Text; +using System.Runtime.InteropServices; +using System; + +namespace ShiftUI { + [ClassInterface (ClassInterfaceType.AutoDispatch)] + [ComVisible (true)] + //[Designer ("ShiftUI.Design.ButtonBaseDesigner, " + Consts.AssemblySystem_Design, + //"System.ComponentModel.Design.IDesigner")] + public abstract class ButtonBase : Widget + { + #region Local Variables + private FlatStyle flat_style; + private int image_index; + internal Image image; + internal ImageList image_list; + private ContentAlignment image_alignment; + internal ContentAlignment text_alignment; + private bool is_default; + internal bool is_pressed; +// private bool enter_state; + internal StringFormat text_format; + internal bool paint_as_acceptbutton; + + // Properties are 2.0, but variables used in 1.1 for common drawing code + private bool auto_ellipsis; + private FlatButtonAppearance flat_button_appearance; + private string image_key; + private TextImageRelation text_image_relation; + private TextFormatFlags text_format_flags; + private bool use_mnemonic; + private bool use_visual_style_back_color; + #endregion // Local Variables + + #region Public Constructors + protected ButtonBase() : base() + { + flat_style = FlatStyle.Standard; + flat_button_appearance = new FlatButtonAppearance (this); + this.image_key = string.Empty; + this.text_image_relation = TextImageRelation.Overlay; + this.use_mnemonic = true; + use_visual_style_back_color = true; + image_index = -1; + image = null; + image_list = null; + image_alignment = ContentAlignment.MiddleCenter; + ImeMode = ImeMode.Disable; + text_alignment = ContentAlignment.MiddleCenter; + is_default = false; + is_pressed = false; + text_format = new StringFormat(); + text_format.Alignment = StringAlignment.Center; + text_format.LineAlignment = StringAlignment.Center; + text_format.HotkeyPrefix = HotkeyPrefix.Show; + text_format.FormatFlags |= StringFormatFlags.LineLimit; + + text_format_flags = TextFormatFlags.HorizontalCenter; + text_format_flags |= TextFormatFlags.VerticalCenter; + text_format_flags |= TextFormatFlags.TextBoxControl; + + SetStyle (Widgetstyles.ResizeRedraw | + Widgetstyles.Opaque | + Widgetstyles.UserMouse | + Widgetstyles.SupportsTransparentBackColor | + Widgetstyles.CacheText | + Widgetstyles.OptimizedDoubleBuffer, true); + SetStyle (Widgetstyles.StandardClick, false); + } + #endregion // Public Constructors + + #region Public Properties + [Browsable (true)] + [DefaultValue (false)] + //[EditorBrowsable (EditorBrowsableState.Always)] + [MWFCategory("Behavior")] + public bool AutoEllipsis { + get { return this.auto_ellipsis; } + set + { + if (this.auto_ellipsis != value) { + this.auto_ellipsis = value; + + if (this.auto_ellipsis) { + text_format_flags |= TextFormatFlags.EndEllipsis; + text_format_flags &= ~TextFormatFlags.WordBreak; + } else { + text_format_flags &= ~TextFormatFlags.EndEllipsis; + text_format_flags |= TextFormatFlags.WordBreak; + } + + if (Parent != null) + Parent.PerformLayout (this, "AutoEllipsis"); + this.Invalidate (); + } + } + } + + [Browsable (true)] + //[EditorBrowsable (EditorBrowsableState.Always)] + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Visible)] + [MWFCategory("Layout")] + public override bool AutoSize { + get { return base.AutoSize; } + set { base.AutoSize = value; } + } + + public override Color BackColor { + get { return base.BackColor; } + set { base.BackColor = value; } + } + + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)] + [Browsable (true)] + [MWFCategory("Appearance")] + public FlatButtonAppearance FlatAppearance { + get { return flat_button_appearance; } + } + + [Localizable(true)] + [DefaultValue(FlatStyle.Standard)] + [MWFDescription("Determines look of button"), MWFCategory("Appearance")] + public FlatStyle FlatStyle { + get { return flat_style; } + set { + if (flat_style != value) { + flat_style = value; + + if (Parent != null) + Parent.PerformLayout (this, "FlatStyle"); + Invalidate(); + } + } + } + + [Localizable(true)] + [MWFDescription("Sets image to be displayed on button face"), MWFCategory("Appearance")] + public Image Image { + get { + if (this.image != null) + return this.image; + + if (this.image_index >= 0) + if (this.image_list != null) + return this.image_list.Images[this.image_index]; + + if (!string.IsNullOrEmpty (this.image_key)) + if (this.image_list != null) + return this.image_list.Images[this.image_key]; + return null; + } + set { + if (this.image != value) { + this.image = value; + this.image_index = -1; + this.image_key = string.Empty; + this.image_list = null; + + if (this.AutoSize && this.Parent != null) + this.Parent.PerformLayout (this, "Image"); + + Invalidate (); + } + } + } + + internal bool ShouldSerializeImage () + { + return this.Image != null; + } + + [Localizable(true)] + [DefaultValue(ContentAlignment.MiddleCenter)] + [MWFDescription("Sets the alignment of the image to be displayed on button face"), MWFCategory("Appearance")] + public ContentAlignment ImageAlign { + get { return image_alignment; } + set { + if (image_alignment != value) { + image_alignment = value; + Invalidate (); + } + } + } + + [Localizable(true)] + [DefaultValue(-1)] + //[Editor("ShiftUI.Design.ImageIndexEditor, " + Consts.AssemblySystem_Design, typeof(System.Drawing.Design.UITypeEditor))] + [TypeConverter(typeof(ImageIndexConverter))] + [MWFDescription("Index of image to display, if ImageList is used for button face images"), MWFCategory("Appearance")] + [RefreshProperties (RefreshProperties.Repaint)] + public int ImageIndex { + get { + if (image_list == null) + return -1; + + return image_index; + } + set { + if (this.image_index != value) { + this.image_index = value; + this.image = null; + this.image_key = string.Empty; + Invalidate (); + } + } + } + + [Localizable (true)] + [DefaultValue ("")] + //[Editor ("ShiftUI.Design.ImageIndexEditor, " + Consts.AssemblySystem_Design, typeof (System.Drawing.Design.UITypeEditor))] + [RefreshProperties (RefreshProperties.Repaint)] + [TypeConverter (typeof (ImageKeyConverter))] + [MWFCategory("Appearance")] + public string ImageKey { + get { return this.image_key; } + set { + if (this.image_key != value) { + this.image = null; + this.image_index = -1; + this.image_key = value; + this.Invalidate (); + } + } + } + + [DefaultValue(null)] + [MWFDescription("ImageList used for ImageIndex"), MWFCategory("Appearance")] + [RefreshProperties (RefreshProperties.Repaint)] + public ImageList ImageList { + get { return image_list; } + set { + if (image_list != value) { + image_list = value; + + if (value != null && image != null) + image = null; + + Invalidate (); + } + } + } + + [Browsable(false)] + //[EditorBrowsable (EditorBrowsableState.Never)] + public new ImeMode ImeMode { + get { return base.ImeMode; } + set { base.ImeMode = value; } + } + + [SettingsBindable (true)] + //[Editor ("System.ComponentModel.Design.MultilineStringEditor, " + Consts.AssemblySystem_Design, + //"System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)] + public override string Text { + get { return base.Text; } + set { base.Text = value; } + } + + [Localizable(true)] + [DefaultValue(ContentAlignment.MiddleCenter)] + [MWFDescription("Alignment for button text"), MWFCategory("Appearance")] + public virtual ContentAlignment TextAlign { + get { return text_alignment; } + set { + if (text_alignment != value) { + text_alignment = value; + + text_format_flags &= ~TextFormatFlags.Bottom; + text_format_flags &= ~TextFormatFlags.Top; + text_format_flags &= ~TextFormatFlags.Left; + text_format_flags &= ~TextFormatFlags.Right; + text_format_flags &= ~TextFormatFlags.HorizontalCenter; + text_format_flags &= ~TextFormatFlags.VerticalCenter; + + switch (text_alignment) { + case ContentAlignment.TopLeft: + text_format.Alignment=StringAlignment.Near; + text_format.LineAlignment=StringAlignment.Near; + break; + + case ContentAlignment.TopCenter: + text_format.Alignment=StringAlignment.Center; + text_format.LineAlignment=StringAlignment.Near; + text_format_flags |= TextFormatFlags.HorizontalCenter; + break; + + case ContentAlignment.TopRight: + text_format.Alignment=StringAlignment.Far; + text_format.LineAlignment=StringAlignment.Near; + text_format_flags |= TextFormatFlags.Right; + break; + + case ContentAlignment.MiddleLeft: + text_format.Alignment=StringAlignment.Near; + text_format.LineAlignment=StringAlignment.Center; + text_format_flags |= TextFormatFlags.VerticalCenter; + break; + + case ContentAlignment.MiddleCenter: + text_format.Alignment=StringAlignment.Center; + text_format.LineAlignment=StringAlignment.Center; + text_format_flags |= TextFormatFlags.VerticalCenter | TextFormatFlags.HorizontalCenter; + break; + + case ContentAlignment.MiddleRight: + text_format.Alignment=StringAlignment.Far; + text_format.LineAlignment=StringAlignment.Center; + text_format_flags |= TextFormatFlags.VerticalCenter | TextFormatFlags.Right; + break; + + case ContentAlignment.BottomLeft: + text_format.Alignment=StringAlignment.Near; + text_format.LineAlignment=StringAlignment.Far; + text_format_flags |= TextFormatFlags.Bottom; + break; + + case ContentAlignment.BottomCenter: + text_format.Alignment=StringAlignment.Center; + text_format.LineAlignment=StringAlignment.Far; + text_format_flags |= TextFormatFlags.HorizontalCenter | TextFormatFlags.Bottom; + break; + + case ContentAlignment.BottomRight: + text_format.Alignment=StringAlignment.Far; + text_format.LineAlignment=StringAlignment.Far; + text_format_flags |= TextFormatFlags.Bottom | TextFormatFlags.Right; + break; + } + + Invalidate(); + } + } + } + + [Localizable (true)] + [DefaultValue (TextImageRelation.Overlay)] + [MWFCategory("Appearance")] + public TextImageRelation TextImageRelation { + get { return this.text_image_relation; } + set { + if (!Enum.IsDefined (typeof (TextImageRelation), value)) + throw new InvalidEnumArgumentException (string.Format ("Enum argument value '{0}' is not valid for TextImageRelation", value)); + + if (this.text_image_relation != value) { + this.text_image_relation = value; + + if (this.AutoSize && this.Parent != null) + this.Parent.PerformLayout (this, "TextImageRelation"); + + this.Invalidate (); + } + } + } + + [DefaultValue (false)] + [MWFCategory("Behavior")] + public bool UseCompatibleTextRendering { + get { return use_compatible_text_rendering; } + set { + if (use_compatible_text_rendering != value) { + use_compatible_text_rendering = value; + if (Parent != null) + Parent.PerformLayout (this, "UseCompatibleTextRendering"); + Invalidate (); + } + } + } + + [DefaultValue (true)] + [MWFCategory("Appearance")] + public bool UseMnemonic { + get { return this.use_mnemonic; } + set { + if (this.use_mnemonic != value) { + this.use_mnemonic = value; + + if (this.use_mnemonic) + text_format_flags &= ~TextFormatFlags.NoPrefix; + else + text_format_flags |= TextFormatFlags.NoPrefix; + + this.Invalidate (); + } + } + } + + [MWFCategory("Appearance")] + public bool UseVisualStyleBackColor { + get { return use_visual_style_back_color; } + set { + if (use_visual_style_back_color != value) { + use_visual_style_back_color = value; + Invalidate (); + } + } + } + #endregion // Public Instance Properties + + #region Protected Properties + protected override CreateParams CreateParams { + get { return base.CreateParams; } + } + + protected override ImeMode DefaultImeMode { + get { return ImeMode.Disable; } + } + + protected override Size DefaultSize { + get { return ThemeEngine.Current.ButtonBaseDefaultSize; } + } + + protected internal bool IsDefault { + get { return is_default; } + set { + if (is_default != value) { + is_default = value; + Invalidate (); + } + } + } + #endregion // Public Instance Properties + + #region Public Methods + // The base calls into GetPreferredSizeCore, which we will override in our subclasses + public override Size GetPreferredSize (Size proposedSize) + { + return base.GetPreferredSize (proposedSize); + } + #endregion + + #region Protected Methods + protected override AccessibleObject CreateAccessibilityInstance () + { + return new ButtonBaseAccessibleObject (this); + } + + protected override void Dispose (bool disposing) + { + base.Dispose (disposing); + } + + protected override void OnEnabledChanged (EventArgs e) + { + base.OnEnabledChanged (e); + } + + protected override void OnGotFocus (EventArgs e) + { + Invalidate (); + base.OnGotFocus (e); + } + + protected override void OnKeyDown (KeyEventArgs kevent) + { + if (kevent.KeyData == Keys.Space) { + is_pressed = true; + Invalidate (); + kevent.Handled = true; + } + + base.OnKeyDown (kevent); + } + + protected override void OnKeyUp (KeyEventArgs kevent) + { + if (kevent.KeyData == Keys.Space) { + is_pressed = false; + Invalidate (); + OnClick (EventArgs.Empty); + kevent.Handled = true; + } + + base.OnKeyUp (kevent); + } + + protected override void OnLostFocus (EventArgs e) + { + Invalidate (); + base.OnLostFocus (e); + } + + protected override void OnMouseDown (MouseEventArgs mevent) + { + if ((mevent.Button & MouseButtons.Left) != 0) { + is_pressed = true; + Invalidate (); + } + + base.OnMouseDown (mevent); + } + + protected override void OnMouseEnter (EventArgs eventargs) + { + is_entered = true; + Invalidate (); + base.OnMouseEnter (eventargs); + } + + protected override void OnMouseLeave (EventArgs eventargs) + { + is_entered = false; + Invalidate (); + base.OnMouseLeave (eventargs); + } + + protected override void OnMouseMove (MouseEventArgs mevent) { + bool inside = false; + bool redraw = false; + + if (ClientRectangle.Contains (mevent.Location)) + inside = true; + + // If the button was pressed and we leave, release the button press and vice versa + if ((mevent.Button & MouseButtons.Left) != 0) { + if (this.Capture && (inside != is_pressed)) { + is_pressed = inside; + redraw = true; + } + } + + if (is_entered != inside) { + is_entered = inside; + redraw = true; + } + + if (redraw) + Invalidate (); + + base.OnMouseMove (mevent); + } + + protected override void OnMouseUp (MouseEventArgs mevent) + { + if (this.Capture && ((mevent.Button & MouseButtons.Left) != 0)) { + this.Capture = false; + + if (is_pressed) { + is_pressed = false; + Invalidate (); + } else if ((this.flat_style == FlatStyle.Flat) || (this.flat_style == FlatStyle.Popup)) { + Invalidate (); + } + + if (ClientRectangle.Contains (mevent.Location)) + if (!ValidationFailed) { + OnClick (EventArgs.Empty); + OnMouseClick (mevent); + } + } + + base.OnMouseUp (mevent); + } + + protected override void OnPaint (PaintEventArgs pevent) + { + Draw (pevent); + base.OnPaint (pevent); + } + + protected override void OnParentChanged (EventArgs e) + { + base.OnParentChanged (e); + } + + protected override void OnTextChanged (EventArgs e) + { + Invalidate (); + base.OnTextChanged (e); + } + + protected override void OnVisibleChanged (EventArgs e) + { + if (!Visible) { + is_pressed = false; + is_entered = false; + } + + base.OnVisibleChanged (e); + } + + protected void ResetFlagsandPaint () + { + // Nothing to do; MS internal + // Should we do Invalidate (); ? + } + + protected override void WndProc (ref Message m) + { + switch ((Msg)m.Msg) { + case Msg.WM_LBUTTONDBLCLK: { + HaveDoubleClick (); + break; + } + + case Msg.WM_MBUTTONDBLCLK: { + HaveDoubleClick (); + break; + } + + case Msg.WM_RBUTTONDBLCLK: { + HaveDoubleClick (); + break; + } + } + + base.WndProc (ref m); + } + #endregion // Public Instance Properties + + #region Public Events + [Browsable (true)] + //[EditorBrowsable (EditorBrowsableState.Always)] + public new event EventHandler AutoSizeChanged { + add { base.AutoSizeChanged += value; } + remove { base.AutoSizeChanged -= value; } + } + + [Browsable (false)] + //[EditorBrowsable (EditorBrowsableState.Never)] + public new event EventHandler ImeModeChanged { + add { base.ImeModeChanged += value; } + remove { base.ImeModeChanged -= value; } + } + #endregion // Events + + #region Internal Properties + internal ButtonState ButtonState { + get { + ButtonState ret = ButtonState.Normal; + + if (Enabled) { + // Popup style is only followed as long as the mouse isn't "in" the control + if (is_entered) { + if (flat_style == FlatStyle.Flat) { + ret |= ButtonState.Flat; + } + } else { + if (flat_style == FlatStyle.Flat || flat_style == FlatStyle.Popup) { + ret |= ButtonState.Flat; + } + } + + if (is_entered && is_pressed) { + ret |= ButtonState.Pushed; + } + } else { + ret |= ButtonState.Inactive; + if ((flat_style == FlatStyle.Flat) || (flat_style == FlatStyle.Popup)) { + ret |= ButtonState.Flat; + } + } + return ret; + } + } + + internal bool Pressed { + get { return this.is_pressed; } + } + + // The flags to be used for MeasureText and DrawText + internal TextFormatFlags TextFormatFlags { + get { return this.text_format_flags; } + } + #endregion + + #region Internal Methods + // Derived classes should override Draw method and we dont want + // to break the control signature, hence this approach. + internal virtual void Draw (PaintEventArgs pevent) + { + ThemeEngine.Current.DrawButtonBase (pevent.Graphics, pevent.ClipRectangle, this); + } + + internal virtual void HaveDoubleClick () + { + // override me + } + + internal override void OnPaintBackgroundInternal (PaintEventArgs e) + { + base.OnPaintBackground (e); + } + #endregion // Internal Methods + + #region ButtonBaseAccessibleObject sub-class + [ComVisible (true)] + public class ButtonBaseAccessibleObject : WidgetAccessibleObject + { + #region ButtonBaseAccessibleObject Local Variables + private new Widget owner; + #endregion // ButtonBaseAccessibleObject Local Variables + + #region ButtonBaseAccessibleObject Constructors + public ButtonBaseAccessibleObject (Widget owner) : base (owner) + { + if (owner == null) + throw new ArgumentNullException ("owner"); + + this.owner = owner; + default_action = "Press"; + role = AccessibleRole.PushButton; + } + #endregion // ButtonBaseAccessibleObject Constructors + + #region Public Properties + public override AccessibleStates State { + get { return base.State; } + } + #endregion + + #region ButtonBaseAccessibleObject Methods + public override void DoDefaultAction () + { + ((ButtonBase)owner).OnClick (EventArgs.Empty); + } + #endregion // ButtonBaseAccessibleObject Methods + } + #endregion // ButtonBaseAccessibleObject sub-class + } +} diff --git a/source/ShiftUI/Internal/ButtonRenderer.cs b/source/ShiftUI/Internal/ButtonRenderer.cs new file mode 100644 index 0000000..a2e4237 --- /dev/null +++ b/source/ShiftUI/Internal/ButtonRenderer.cs @@ -0,0 +1,153 @@ +// +// ButtonRenderer.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +using System.Drawing; +using ShiftUI.VisualStyles; +using System; + +namespace ShiftUI +{ + public sealed class ButtonRenderer + { + private static bool always_use_visual_styles = false; + + #region Private Constructor + private ButtonRenderer () { } + #endregion + + #region Public Static Methods + public static void DrawButton (Graphics g, Rectangle bounds, PushButtonState state) + { + DrawButton (g, bounds, String.Empty, null, TextFormatFlags.Default, null, Rectangle.Empty, false, state); + } + + public static void DrawButton (Graphics g, Rectangle bounds, bool focused, PushButtonState state) + { + DrawButton (g, bounds, String.Empty, null, TextFormatFlags.Default, null, Rectangle.Empty, focused, state); + } + + public static void DrawButton (Graphics g, Rectangle bounds, Image image, Rectangle imageBounds, bool focused, PushButtonState state) + { + DrawButton (g, bounds, String.Empty, null, TextFormatFlags.Default, image, imageBounds, focused, state); + } + + public static void DrawButton (Graphics g, Rectangle bounds, string buttonText, Font font, bool focused, PushButtonState state) + { + DrawButton (g, bounds, buttonText, font, TextFormatFlags.HorizontalCenter, null, Rectangle.Empty, focused, state); + } + + public static void DrawButton (Graphics g, Rectangle bounds, string buttonText, Font font, TextFormatFlags flags, bool focused, PushButtonState state) + { + DrawButton (g, bounds, buttonText, font, flags, null, Rectangle.Empty, focused, state); + } + + public static void DrawButton (Graphics g, Rectangle bounds, string buttonText, Font font, Image image, Rectangle imageBounds, bool focused, PushButtonState state) + { + DrawButton (g, bounds, buttonText, font, TextFormatFlags.HorizontalCenter, image, imageBounds, focused, state); + } + + public static void DrawButton (Graphics g, Rectangle bounds, string buttonText, Font font, TextFormatFlags flags, Image image, Rectangle imageBounds, bool focused, PushButtonState state) + { + if (Application.RenderWithVisualStyles || always_use_visual_styles == true) { + VisualStyleRenderer vsr = GetPushButtonRenderer (state); + + vsr.DrawBackground (g, bounds); + + if (image != null) + vsr.DrawImage (g, imageBounds, image); + } else { + if (state == PushButtonState.Pressed) + WidgetPaint.DrawButton (g, bounds, ButtonState.Pushed); + else + WidgetPaint.DrawButton (g, bounds, ButtonState.Normal); + + if (image != null) + g.DrawImage (image, imageBounds); + } + + Rectangle focus_rect = bounds; + focus_rect.Inflate (-3, -3); + + if (focused) + WidgetPaint.DrawFocusRectangle (g, focus_rect); + + if (buttonText != String.Empty) + if (state == PushButtonState.Disabled) + TextRenderer.DrawText (g, buttonText, font, focus_rect, SystemColors.GrayText, flags); + else + TextRenderer.DrawText (g, buttonText, font, focus_rect, SystemColors.ControlText, flags); + } + + public static bool IsBackgroundPartiallyTransparent (PushButtonState state) + { + if (!VisualStyleRenderer.IsSupported) + return false; + + VisualStyleRenderer vsr = GetPushButtonRenderer (state); + + return vsr.IsBackgroundPartiallyTransparent (); + } + + public static void DrawParentBackground (Graphics g, Rectangle bounds, Widget childControl) + { + if (!VisualStyleRenderer.IsSupported) + return; + + VisualStyleRenderer vsr = new VisualStyleRenderer (VisualStyleElement.Button.PushButton.Default); + + vsr.DrawParentBackground (g, bounds, childControl); + } + #endregion + + #region Private Static Methods + internal static VisualStyleRenderer GetPushButtonRenderer (PushButtonState state) + { + switch (state) { + case PushButtonState.Normal: + return new VisualStyleRenderer (VisualStyleElement.Button.PushButton.Normal); + case PushButtonState.Hot: + return new VisualStyleRenderer (VisualStyleElement.Button.PushButton.Hot); + case PushButtonState.Pressed: + return new VisualStyleRenderer (VisualStyleElement.Button.PushButton.Pressed); + case PushButtonState.Disabled: + return new VisualStyleRenderer (VisualStyleElement.Button.PushButton.Disabled); + case PushButtonState.Default: + default: + return new VisualStyleRenderer (VisualStyleElement.Button.PushButton.Default); + } + } + #endregion + + #region Public Static Properties + public static bool RenderMatchingApplicationState { + get { return !always_use_visual_styles; } + set { always_use_visual_styles = !value; } + } + #endregion + } +}
\ No newline at end of file diff --git a/source/ShiftUI/Internal/CheckBoxRenderer.cs b/source/ShiftUI/Internal/CheckBoxRenderer.cs new file mode 100644 index 0000000..8800aa0 --- /dev/null +++ b/source/ShiftUI/Internal/CheckBoxRenderer.cs @@ -0,0 +1,194 @@ +// +// CheckBoxRenderer.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +using System.Drawing; +using ShiftUI.VisualStyles; +using System; + +namespace ShiftUI +{ + public sealed class CheckBoxRenderer + { + private static bool always_use_visual_styles = false; + + #region Private Constructor + private CheckBoxRenderer () {} + #endregion + + #region Public Static Methods + public static void DrawCheckBox (Graphics g, Point glyphLocation, CheckBoxState state) + { + DrawCheckBox (g, glyphLocation, Rectangle.Empty, String.Empty, null, TextFormatFlags.HorizontalCenter, null, Rectangle.Empty, false, state); + } + + public static void DrawCheckBox (Graphics g, Point glyphLocation, Rectangle textBounds, string checkBoxText, Font font, bool focused, CheckBoxState state) + { + DrawCheckBox (g, glyphLocation, textBounds, checkBoxText, font, TextFormatFlags.HorizontalCenter, null, Rectangle.Empty, focused, state); + } + + public static void DrawCheckBox (Graphics g, Point glyphLocation, Rectangle textBounds, string checkBoxText, Font font, TextFormatFlags flags, bool focused, CheckBoxState state) + { + DrawCheckBox (g, glyphLocation, textBounds, checkBoxText, font, flags, null, Rectangle.Empty, focused, state); + } + + public static void DrawCheckBox (Graphics g, Point glyphLocation, Rectangle textBounds, string checkBoxText, Font font, Image image, Rectangle imageBounds, bool focused, CheckBoxState state) + { + DrawCheckBox (g, glyphLocation, textBounds, checkBoxText, font, TextFormatFlags.HorizontalCenter, image, imageBounds, focused, state); + } + + public static void DrawCheckBox (Graphics g, Point glyphLocation, Rectangle textBounds, string checkBoxText, Font font, TextFormatFlags flags, Image image, Rectangle imageBounds, bool focused, CheckBoxState state) + { + Rectangle bounds = new Rectangle (glyphLocation, GetGlyphSize (g, state)); + + if (Application.RenderWithVisualStyles || always_use_visual_styles == true) { + VisualStyleRenderer vsr = GetCheckBoxRenderer (state); + + vsr.DrawBackground (g, bounds); + + if (image != null) + vsr.DrawImage (g, imageBounds, image); + + if (focused) + WidgetPaint.DrawFocusRectangle (g, textBounds); + + if (checkBoxText != String.Empty) + if (state == CheckBoxState.CheckedDisabled || state == CheckBoxState.MixedDisabled || state == CheckBoxState.UncheckedDisabled) + TextRenderer.DrawText (g, checkBoxText, font, textBounds, SystemColors.GrayText, flags); + else + TextRenderer.DrawText (g, checkBoxText, font, textBounds, SystemColors.ControlText, flags); + } else { + switch (state) { + case CheckBoxState.CheckedDisabled: + case CheckBoxState.MixedDisabled: + case CheckBoxState.MixedPressed: + WidgetPaint.DrawCheckBox (g, bounds, ButtonState.Inactive | ButtonState.Checked); + break; + case CheckBoxState.CheckedHot: + case CheckBoxState.CheckedNormal: + WidgetPaint.DrawCheckBox (g, bounds, ButtonState.Checked); + break; + case CheckBoxState.CheckedPressed: + WidgetPaint.DrawCheckBox (g, bounds, ButtonState.Pushed | ButtonState.Checked); + break; + case CheckBoxState.MixedHot: + case CheckBoxState.MixedNormal: + WidgetPaint.DrawMixedCheckBox (g, bounds, ButtonState.Checked); + break; + case CheckBoxState.UncheckedDisabled: + case CheckBoxState.UncheckedPressed: + WidgetPaint.DrawCheckBox (g, bounds, ButtonState.Inactive); + break; + case CheckBoxState.UncheckedHot: + case CheckBoxState.UncheckedNormal: + WidgetPaint.DrawCheckBox (g, bounds, ButtonState.Normal); + break; + } + + if (image != null) + g.DrawImage (image, imageBounds); + + if (focused) + WidgetPaint.DrawFocusRectangle (g, textBounds); + + if (checkBoxText != String.Empty) + TextRenderer.DrawText (g, checkBoxText, font, textBounds, SystemColors.ControlText, flags); + } + } + + public static bool IsBackgroundPartiallyTransparent (CheckBoxState state) + { + if (!VisualStyleRenderer.IsSupported) + return false; + + VisualStyleRenderer vsr = GetCheckBoxRenderer (state); + + return vsr.IsBackgroundPartiallyTransparent (); + } + + public static void DrawParentBackground (Graphics g, Rectangle bounds, Widget childControl) + { + if (!VisualStyleRenderer.IsSupported) + return; + + VisualStyleRenderer vsr = new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.UncheckedNormal); + + vsr.DrawParentBackground (g, bounds, childControl); + } + + public static Size GetGlyphSize (Graphics g, CheckBoxState state) + { + if (!VisualStyleRenderer.IsSupported) + return new Size (13, 13); + + VisualStyleRenderer vsr = GetCheckBoxRenderer (state); + + return vsr.GetPartSize (g, ThemeSizeType.Draw); + } + #endregion + + #region Private Static Methods + private static VisualStyleRenderer GetCheckBoxRenderer (CheckBoxState state) + { + switch (state) { + case CheckBoxState.CheckedDisabled: + return new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.CheckedDisabled); + case CheckBoxState.CheckedHot: + return new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.CheckedHot); + case CheckBoxState.CheckedNormal: + return new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.CheckedNormal); + case CheckBoxState.CheckedPressed: + return new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.CheckedPressed); + case CheckBoxState.MixedDisabled: + return new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.MixedDisabled); + case CheckBoxState.MixedHot: + return new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.MixedHot); + case CheckBoxState.MixedNormal: + return new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.MixedNormal); + case CheckBoxState.MixedPressed: + return new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.MixedPressed); + case CheckBoxState.UncheckedDisabled: + return new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.UncheckedDisabled); + case CheckBoxState.UncheckedHot: + return new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.UncheckedHot); + case CheckBoxState.UncheckedNormal: + default: + return new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.UncheckedNormal); + case CheckBoxState.UncheckedPressed: + return new VisualStyleRenderer (VisualStyleElement.Button.CheckBox.UncheckedPressed); + } + } + #endregion + + #region Public Static Properties + public static bool RenderMatchingApplicationState { + get { return !always_use_visual_styles; } + set { always_use_visual_styles = !value; } + } + #endregion + } +}
\ No newline at end of file diff --git a/source/ShiftUI/Internal/Clipboard.cs b/source/ShiftUI/Internal/Clipboard.cs new file mode 100644 index 0000000..9c832a8 --- /dev/null +++ b/source/ShiftUI/Internal/Clipboard.cs @@ -0,0 +1,433 @@ +// 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.Drawing; +using System.IO; +using System.Runtime.InteropServices; +using System.Runtime.Serialization; +using System.Collections; +using System.Collections.Specialized; +using System.ComponentModel; +using System.Threading; + +namespace ShiftUI { + public sealed class Clipboard { + #region Local Variables + #endregion // Local Variables + + #region Constructors + private Clipboard() { + } + #endregion // Constructors + + #region Private Methods + private static bool ConvertToClipboardData(ref int type, object obj, out byte[] data) { + data = null; + return false; + } + + private static bool ConvertFromClipboardData(int type, IntPtr data, out object obj) { + obj = null; + if (data == IntPtr.Zero) { + return false; + } + return false; + } + #endregion // Private Methods + + #region Public Static Methods + public static void Clear () + { + IntPtr clipboard_handle; + + clipboard_handle = XplatUI.ClipboardOpen (false); + XplatUI.ClipboardStore (clipboard_handle, null, 0, null, false); + } + + public static bool ContainsAudio () + { + return ClipboardContainsFormat (DataFormats.WaveAudio); + } + + public static bool ContainsData (string format) + { + return ClipboardContainsFormat (format); + } + + public static bool ContainsFileDropList () + { + return ClipboardContainsFormat (DataFormats.FileDrop); + } + + public static bool ContainsImage () + { + return ClipboardContainsFormat (DataFormats.Bitmap); + } + + public static bool ContainsText () + { + return ClipboardContainsFormat (DataFormats.Text, DataFormats.UnicodeText); + } + + 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 Stream GetAudioStream () + { + IDataObject data = GetDataObject (); + + if (data == null) + return null; + + return (Stream)data.GetData (DataFormats.WaveAudio, true); + } + + public static Object GetData (string format) + { + IDataObject data = GetDataObject (); + + if (data == null) + return null; + + return data.GetData (format, true); + } + + public static IDataObject GetDataObject () + { + return GetDataObject (false); + } + + public static StringCollection GetFileDropList () + { + IDataObject data = GetDataObject (); + + if (data == null) + return null; + + return (StringCollection)data.GetData (DataFormats.FileDrop, true); + } + + public static Image GetImage () + { + IDataObject data = GetDataObject (); + + if (data == null) + return null; + + return (Image)data.GetData (DataFormats.Bitmap, true); + } + + public static string GetText () + { + return GetText (TextDataFormat.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; + } + + public static void SetAudio (byte[] audioBytes) + { + if (audioBytes == null) + throw new ArgumentNullException ("audioBytes"); + + MemoryStream ms = new MemoryStream (audioBytes); + + SetAudio (ms); + } + + public static void SetAudio (Stream audioStream) + { + if (audioStream == null) + throw new ArgumentNullException ("audioStream"); + + SetData (DataFormats.WaveAudio, audioStream); + } + + public static void SetData (string format, Object data) + { + if (data == null) + throw new ArgumentNullException ("data"); + + DataObject data_object = new DataObject (format, data); + SetDataObject (data_object); + } + + public static void SetDataObject(object data) { + SetDataObject(data, false); // MSDN says default behavior is to place non-persistent data to clipboard + } + + public static void SetDataObject(object data, bool copy) { + SetDataObject(data, copy, 10, 100); // MSDN says default behavior is to try 10 times with 100 ms delay + } + + internal static void SetDataObjectImpl(object data, bool copy) { + IntPtr clipboard_handle; + XplatUI.ObjectToClipboard converter; + int native_format; + DataFormats.Format item_format; + + converter = new XplatUI.ObjectToClipboard(ConvertToClipboardData); + + clipboard_handle = XplatUI.ClipboardOpen(false); + XplatUI.ClipboardStore(clipboard_handle, null, 0, null, copy); // Empty clipboard + + native_format = -1; + + if (data is IDataObject) { + string[] formats; + + IDataObject data_object = data as IDataObject; + formats = data_object.GetFormats(); + for (int i = 0; i < formats.Length; i++) { + item_format = DataFormats.GetFormat(formats[i]); + if ((item_format != null) && (item_format.Name != DataFormats.StringFormat)) { + native_format = item_format.Id; + } + + object obj = data_object.GetData (formats [i]); + + // this is used only by custom formats + if (IsDataSerializable (obj)) + item_format.is_serializable = true; + + XplatUI.ClipboardStore(clipboard_handle, obj, native_format, converter, copy); + } + } else { + item_format = DataFormats.Format.Find(data.GetType().FullName); + if ((item_format != null) && (item_format.Name != DataFormats.StringFormat)) { + native_format = item_format.Id; + } + + XplatUI.ClipboardStore(clipboard_handle, data, native_format, converter, copy); + } + XplatUI.ClipboardClose(clipboard_handle); + } + + static bool IsDataSerializable (object obj) + { + if (obj is ISerializable) + return true; + + AttributeCollection attrs = TypeDescriptor.GetAttributes (obj); + return attrs [typeof (SerializableAttribute)] != null; + } + + public static void SetDataObject(object data, bool copy, int retryTimes, int retryDelay) + { + if (data == null) + throw new ArgumentNullException("data"); + if (retryTimes < 0) + throw new ArgumentOutOfRangeException("retryTimes"); + if (retryDelay < 0) + throw new ArgumentOutOfRangeException("retryDelay"); + + // MS implementation actually puts data to clipboard even when retryTimes == 0 + bool retry = true; + do + { + retry = false; + --retryTimes; + try + { + SetDataObjectImpl(data, copy); + } catch (ExternalException) { + if (retryTimes <= 0) + throw; + retry = true; + Thread.Sleep(retryDelay); + } + } while (retry && retryTimes > 0); + } + + [MonoInternalNote ("Needs additional checks for valid paths, see MSDN")] + public static void SetFileDropList (StringCollection filePaths) + { + if (filePaths == null) + throw new ArgumentNullException ("filePaths"); + + SetData (DataFormats.FileDrop, filePaths); + } + + public static void SetImage (Image image) + { + if (image == null) + throw new ArgumentNullException ("image"); + + SetData (DataFormats.Bitmap, image); + } + + public static void SetText (string text) + { + if (string.IsNullOrEmpty (text)) + throw new ArgumentNullException ("text"); + + SetData (DataFormats.UnicodeText, text); + } + + 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; + } + } + #endregion // Public Static Methods + + #region Internal Static Methods + internal static IDataObject GetDataObject (bool primary_selection) + { + DataObject clipboard; + IntPtr clipboard_handle; + int[] native_formats; + DataFormats.Format item_format; + object managed_clipboard_item; + XplatUI.ClipboardToObject converter; + + converter = new XplatUI.ClipboardToObject (ConvertFromClipboardData); + + clipboard_handle = XplatUI.ClipboardOpen (primary_selection); + native_formats = XplatUI.ClipboardAvailableFormats (clipboard_handle); + if (native_formats == null) { + return null; // Clipboard empty + } + + // Build the IDataObject + clipboard = new DataObject (); + for (int i = 0; i < native_formats.Length; i++) { + // We might get a format we don't understand or know + item_format = DataFormats.GetFormat (native_formats[i]); + + if (item_format != null) { + managed_clipboard_item = XplatUI.ClipboardRetrieve (clipboard_handle, native_formats[i], converter); + + if (managed_clipboard_item != null) { + clipboard.SetData (item_format.Name, managed_clipboard_item); + // We don't handle 'bitmap' since it involves handles, so we'll equate it to dib + if (item_format.Name == DataFormats.Dib) { + clipboard.SetData (DataFormats.Bitmap, managed_clipboard_item); + } + } + } + } + + XplatUI.ClipboardClose (clipboard_handle); + + return clipboard; + } + + internal static bool ClipboardContainsFormat (params string[] formats) + { + IntPtr clipboard_handle; + int[] native_formats; + DataFormats.Format item_format; + + clipboard_handle = XplatUI.ClipboardOpen (false); + native_formats = XplatUI.ClipboardAvailableFormats (clipboard_handle); + + if (native_formats == null) + return false; + + foreach (int i in native_formats) { + // We might get a format we don't understand or know + item_format = DataFormats.GetFormat (i); + + if (item_format != null) + if (((IList)formats).Contains (item_format.Name)) + return true; + } + + return false; + } + #endregion + } +} diff --git a/source/ShiftUI/Internal/Consts.cs b/source/ShiftUI/Internal/Consts.cs new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/source/ShiftUI/Internal/Consts.cs diff --git a/source/ShiftUI/Internal/ContextMenuStrip.cs b/source/ShiftUI/Internal/ContextMenuStrip.cs new file mode 100644 index 0000000..052bb04 --- /dev/null +++ b/source/ShiftUI/Internal/ContextMenuStrip.cs @@ -0,0 +1,80 @@ +// +// ContextMenuStrip.cs +// +// 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) 2006 Jonathan Pobst +// +// Authors: +// Jonathan Pobst ([email protected]) +// +using System.ComponentModel; +using System.Runtime.InteropServices; + +namespace ShiftUI +{ + [ComVisible (true)] + [ClassInterface (ClassInterfaceType.AutoDispatch)] + [DefaultEvent ("Opening")] + public class ContextMenuStrip : ToolStripDropDownMenu + { + Widget source_Widget; + internal Widget container; + + #region Public Construtors + public ContextMenuStrip () : base () + { + source_Widget = null; + } + + public ContextMenuStrip (IContainer container) : base () + { + source_Widget = null; + } + #endregion + + #region Public Properties + [Browsable (false)] + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)] + public Widget SourceWidget { + get { return this.source_Widget; } + } + #endregion + + #region Protected Methods + protected override void Dispose (bool disposing) + { + base.Dispose (disposing); + } + + protected override void SetVisibleCore (bool visible) + { + base.SetVisibleCore (visible); + if (visible) + XplatUI.SetTopmost (this.Handle, true); + } + #endregion + + internal void SetSourceWidget (Widget source_Widget) + { + container = this.source_Widget = source_Widget; + } + } +} diff --git a/source/ShiftUI/Internal/ControlBindingsCollection.cs b/source/ShiftUI/Internal/ControlBindingsCollection.cs new file mode 100644 index 0000000..345efee --- /dev/null +++ b/source/ShiftUI/Internal/ControlBindingsCollection.cs @@ -0,0 +1,204 @@ +// 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) 2004-2005 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) + + +using System; +using System.Collections; +using System.ComponentModel; +using System.Reflection; + + +namespace ShiftUI { + [DefaultEvent("CollectionChanged")] + public class WidgetBindingsCollection : BindingsCollection { + #region Fields + private Widget control; + private IBindableComponent bindable_component; + private DataSourceUpdateMode default_datasource_update_mode; + #endregion // Fields + + #region Constructors + internal WidgetBindingsCollection (Widget control) { + this.control = control; + bindable_component = this.control as IBindableComponent; + default_datasource_update_mode = DataSourceUpdateMode.OnValidation; + } + + public WidgetBindingsCollection (IBindableComponent control) + { + bindable_component = control; + control = control as Widget; + default_datasource_update_mode = DataSourceUpdateMode.OnValidation; + } + #endregion // Constructors + + #region Public Instance Properties + public Widget Widget { + get { + return control; + } + } + + public Binding this[string propertyName] { + get { + foreach (Binding b in base.List) { + if (b.PropertyName == propertyName) { + return b; + } + } + return null; + } + } + + public IBindableComponent BindableComponent { + get { + return bindable_component; + } + } + + public DataSourceUpdateMode DefaultDataSourceUpdateMode { + get { + return default_datasource_update_mode; + } + set { + default_datasource_update_mode = value; + } + } + #endregion // Public Instance Properties + + #region Public Instance Methods + public new void Add (Binding binding) + { + AddCore (binding); + OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Add, binding)); + } + + public Binding Add (string propertyName, object dataSource, string dataMember) + { + if (dataSource == null) + throw new ArgumentNullException ("dataSource"); + + Binding res = new Binding (propertyName, dataSource, dataMember); + res.DataSourceUpdateMode = default_datasource_update_mode; + Add (res); + return res; + } + + public Binding Add (string propertyName, object dataSource, string dataMember, bool formattingEnabled) + { + return Add (propertyName, dataSource, dataMember, formattingEnabled, default_datasource_update_mode, null, String.Empty, null); + } + + public Binding Add (string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode updateMode) + { + return Add (propertyName, dataSource, dataMember, formattingEnabled, updateMode, null, String.Empty, null); + } + + public Binding Add (string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode updateMode, + object nullValue) + { + return Add (propertyName, dataSource, dataMember, formattingEnabled, updateMode, nullValue, String.Empty, null); + } + + public Binding Add (string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode updateMode, + object nullValue, string formatString) + { + return Add (propertyName, dataSource, dataMember, formattingEnabled, updateMode, nullValue, formatString, null); + } + + public Binding Add (string propertyName, object dataSource, string dataMember, bool formattingEnabled, DataSourceUpdateMode updateMode, + object nullValue, string formatString, IFormatProvider formatInfo) + { + if (dataSource == null) + throw new ArgumentNullException ("dataSource"); + + Binding res = new Binding (propertyName, dataSource, dataMember); + res.FormattingEnabled = formattingEnabled; + res.DataSourceUpdateMode = updateMode; + res.NullValue = nullValue; + res.FormatString = formatString; + res.FormatInfo = formatInfo; + + Add (res); + return res; + } + + public new void Clear() { + base.Clear(); + } + + public new void Remove (Binding binding) { + if (binding == null) + throw new NullReferenceException("The binding is null"); + + base.Remove(binding); + } + + public new void RemoveAt(int index) { + if (index < 0 || index >= base.List.Count) + throw new ArgumentOutOfRangeException("index"); + + base.RemoveAt(index); + } + #endregion // Public Instance Methods + + #region Protected Instance Methods + protected override void AddCore (Binding dataBinding) + { + if (dataBinding == null) + throw new ArgumentNullException ("dataBinding"); + + if (dataBinding.Widget != null && dataBinding.BindableComponent != bindable_component) + throw new ArgumentException ("dataBinding belongs to another BindingsCollection"); + + for (int i = 0; i < Count; i++) { + Binding bnd = this [i]; + if (bnd == null || bnd.PropertyName.Length == 0 || dataBinding.PropertyName.Length == 0) { + continue; + } + + if (String.Compare (bnd.PropertyName, dataBinding.PropertyName, true) == 0) { + throw new ArgumentException ("The binding is already in the collection"); + } + } + + dataBinding.SetWidget (bindable_component); + dataBinding.Check (); + base.AddCore (dataBinding); + } + + protected override void ClearCore() { + base.ClearCore (); + } + + protected override void RemoveCore (Binding dataBinding) { + if (dataBinding == null) + throw new ArgumentNullException ("dataBinding"); + + base.RemoveCore (dataBinding); + } + #endregion // Protected Instance Methods + } +} + diff --git a/source/ShiftUI/Internal/ControlEventArgs.cs b/source/ShiftUI/Internal/ControlEventArgs.cs new file mode 100644 index 0000000..17eb992 --- /dev/null +++ b/source/ShiftUI/Internal/ControlEventArgs.cs @@ -0,0 +1,49 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// +// + + +// COMPLETE +using System; + +namespace ShiftUI { + public class WidgetEventArgs : EventArgs { + private Widget control; + + #region Public Constructors + public WidgetEventArgs(Widget control) { + this.control=control; + } + #endregion // Public Constructors + + #region Public Instance Properties + public Widget Widget { + get { + return this.control; + } + } + #endregion // Public Instance Properties + } +} diff --git a/source/ShiftUI/Internal/ControlEventHandler.cs b/source/ShiftUI/Internal/ControlEventHandler.cs new file mode 100644 index 0000000..faed044 --- /dev/null +++ b/source/ShiftUI/Internal/ControlEventHandler.cs @@ -0,0 +1,32 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// +// + + +// COMPLETE + +namespace ShiftUI { + public delegate void WidgetEventHandler (object sender, WidgetEventArgs e); +} diff --git a/source/ShiftUI/Internal/ControlHandler.cs b/source/ShiftUI/Internal/ControlHandler.cs new file mode 100644 index 0000000..08be9bd --- /dev/null +++ b/source/ShiftUI/Internal/ControlHandler.cs @@ -0,0 +1,229 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton <[email protected]> +// +// + +using System; +using System.Drawing; +using System.Runtime.InteropServices; + +namespace ShiftUI.CarbonInternal { + internal class WidgetHandler : EventHandlerBase, IEventHandler { + internal const uint kEventWidgetInitialize = 1000; + internal const uint kEventWidgetDispose = 1001; + internal const uint kEventWidgetGetOptimalBounds = 1003; + internal const uint kEventWidgetDefInitialize = kEventWidgetInitialize; + internal const uint kEventWidgetDefDispose = kEventWidgetDispose; + internal const uint kEventWidgetHit = 1; + internal const uint kEventWidgetsimulateHit = 2; + internal const uint kEventWidgetHitTest = 3; + internal const uint kEventWidgetDraw = 4; + internal const uint kEventWidgetApplyBackground = 5; + internal const uint kEventWidgetApplyTextColor = 6; + internal const uint kEventWidgetsetFocusPart = 7; + internal const uint kEventWidgetGetFocusPart = 8; + internal const uint kEventWidgetActivate = 9; + internal const uint kEventWidgetDeactivate = 10; + internal const uint kEventWidgetsetCursor = 11; + internal const uint kEventWidgetContextualMenuClick = 12; + internal const uint kEventWidgetClick = 13; + internal const uint kEventWidgetGetNextFocusCandidate = 14; + internal const uint kEventWidgetGetAutoToggleValue = 15; + internal const uint kEventWidgetInterceptSubviewClick = 16; + internal const uint kEventWidgetGetClickActivation = 17; + internal const uint kEventWidgetDragEnter = 18; + internal const uint kEventWidgetDragWithin = 19; + internal const uint kEventWidgetDragLeave = 20; + internal const uint kEventWidgetDragReceive = 21; + internal const uint kEventWidgetInvalidateForSizeChange = 22; + internal const uint kEventWidgetTrackingAreaEntered = 23; + internal const uint kEventWidgetTrackingAreaExited = 24; + internal const uint kEventWidgetTrack = 51; + internal const uint kEventWidgetGetScrollToHereStartPoint = 52; + internal const uint kEventWidgetGetIndicatorDragConstraint = 53; + internal const uint kEventWidgetIndicatorMoved = 54; + internal const uint kEventWidgetGhostingFinished = 55; + internal const uint kEventWidgetGetActionProcPart = 56; + internal const uint kEventWidgetGetPartRegion = 101; + internal const uint kEventWidgetGetPartBounds = 102; + internal const uint kEventWidgetsetData = 103; + internal const uint kEventWidgetGetData = 104; + internal const uint kEventWidgetGetSizeConstraints= 105; + internal const uint kEventWidgetGetFrameMetrics = 106; + internal const uint kEventWidgetValueFieldChanged = 151; + internal const uint kEventWidgetAddedSubWidget = 152; + internal const uint kEventWidgetRemovingSubWidget = 153; + internal const uint kEventWidgetBoundsChanged = 154; + internal const uint kEventWidgetVisibilityChanged = 157; + internal const uint kEventWidgetTitleChanged = 158; + internal const uint kEventWidgetOwningWindowChanged = 159; + internal const uint kEventWidgetHiliteChanged = 160; + internal const uint kEventWidgetEnabledStateChanged = 161; + internal const uint kEventWidgetLayoutInfoChanged = 162; + internal const uint kEventWidgetArbitraryMessage = 201; + + internal const uint kEventParamCGContextRef = 1668183160; + internal const uint kEventParamDirectObject = 757935405; + internal const uint kEventParamWidgetPart = 1668313716; + internal const uint kEventParamWidgetLikesDrag = 1668047975; + internal const uint kEventParamRgnHandle = 1919381096; + internal const uint typeWidgetRef = 1668575852; + internal const uint typeCGContextRef = 1668183160; + internal const uint typeQDPoint = 1363439732; + internal const uint typeQDRgnHandle = 1919381096; + internal const uint typeWidgetPartCode = 1668313716; + internal const uint typeBoolean = 1651470188; + + internal WidgetHandler (XplatUICarbon driver) : base (driver) {} + + public bool ProcessEvent (IntPtr callref, IntPtr eventref, IntPtr handle, uint kind, ref MSG msg) { + Hwnd hwnd; + bool client; + + GetEventParameter (eventref, kEventParamDirectObject, typeWidgetRef, IntPtr.Zero, (uint) Marshal.SizeOf (typeof (IntPtr)), IntPtr.Zero, ref handle); + hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd == null) + return false; + + msg.hwnd = hwnd.Handle; + client = (hwnd.ClientWindow == handle ? true : false); + + switch (kind) { + case kEventWidgetDraw: { + IntPtr rgn = IntPtr.Zero; + HIRect bounds = new HIRect (); + + GetEventParameter (eventref, kEventParamRgnHandle, typeQDRgnHandle, IntPtr.Zero, (uint) Marshal.SizeOf (typeof (IntPtr)), IntPtr.Zero, ref rgn); + + if (rgn != IntPtr.Zero) { + Rect rbounds = new Rect (); + + GetRegionBounds (rgn, ref rbounds); + + bounds.origin.x = rbounds.left; + bounds.origin.y = rbounds.top; + bounds.size.width = rbounds.right - rbounds.left; + bounds.size.height = rbounds.bottom - rbounds.top; + } else { + HIViewGetBounds (handle, ref bounds); + } + + if (!hwnd.visible) { + if (client) { + hwnd.expose_pending = false; + } else { + hwnd.nc_expose_pending = false; + } + return false; + } + + if (!client) { + DrawBorders (hwnd); + } + + Driver.AddExpose (hwnd, client, bounds); + + return true; + } + case kEventWidgetVisibilityChanged: { + if (client) { + msg.message = Msg.WM_SHOWWINDOW; + msg.lParam = (IntPtr) 0; + msg.wParam = (HIViewIsVisible (handle) ? (IntPtr)1 : (IntPtr)0); + return true; + } + return false; + } + case kEventWidgetBoundsChanged: { + HIRect view_frame = new HIRect (); + + HIViewGetFrame (handle, ref view_frame); + if (!client) { + hwnd.X = (int) view_frame.origin.x; + hwnd.Y = (int) view_frame.origin.y; + hwnd.Width = (int) view_frame.size.width; + hwnd.Height = (int) view_frame.size.height; + Driver.PerformNCCalc (hwnd); + } + + msg.message = Msg.WM_WINDOWPOSCHANGED; + msg.hwnd = hwnd.Handle; + + return true; + } + case kEventWidgetGetFocusPart: { + short pcode = 0; + SetEventParameter (eventref, kEventParamWidgetPart, typeWidgetPartCode, (uint)Marshal.SizeOf (typeof (short)), ref pcode); + return false; + } + case kEventWidgetDragEnter: + case kEventWidgetDragWithin: + case kEventWidgetDragLeave: + case kEventWidgetDragReceive: + return Dnd.HandleEvent (callref, eventref, handle, kind, ref msg); + } + return false; + } + + private void DrawBorders (Hwnd hwnd) { + switch (hwnd.border_style) { + case FormBorderStyle.Fixed3D: { + Graphics g; + + g = Graphics.FromHwnd(hwnd.whole_window); + if (hwnd.border_static) + WidgetPaint.DrawBorder3D(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Border3DStyle.SunkenOuter); + else + WidgetPaint.DrawBorder3D(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Border3DStyle.Sunken); + g.Dispose(); + break; + } + + case FormBorderStyle.FixedSingle: { + Graphics g; + + g = Graphics.FromHwnd(hwnd.whole_window); + WidgetPaint.DrawBorder(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Color.Black, ButtonBorderStyle.Solid); + g.Dispose(); + break; + } + } + } + + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int GetRegionBounds (IntPtr rgnhandle, ref Rect region); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int GetEventParameter (IntPtr eventref, uint name, uint type, IntPtr outtype, uint size, IntPtr outsize, ref IntPtr data); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int SetEventParameter (IntPtr eventref, uint name, uint type, uint size, ref short data); + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int HIViewGetBounds (IntPtr handle, ref HIRect rect); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int HIViewGetFrame (IntPtr handle, ref HIRect rect); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static bool HIViewIsVisible (IntPtr vHnd); + } +} diff --git a/source/ShiftUI/Internal/ControlPaint.cs b/source/ShiftUI/Internal/ControlPaint.cs new file mode 100644 index 0000000..d469f51 --- /dev/null +++ b/source/ShiftUI/Internal/ControlPaint.cs @@ -0,0 +1,495 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// + + +// NOT COMPLETE + +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Drawing.Imaging; +using System; + +namespace ShiftUI { + public sealed class WidgetPaint { + #region Local Variables + static int RGBMax=255; + static int HLSMax=255; + #endregion // Local Variables + + #region Private Enumerations + + + #region Constructor + // Prevent a public constructor from being created + private WidgetPaint() { + } + #endregion // Constructor + + + #endregion // Private Enumerations + + #region Helpers + internal static void Color2HBS(Color color, out int h, out int l, out int s) { + int r; + int g; + int b; + int cMax; + int cMin; + int rDelta; + int gDelta; + int bDelta; + + r=color.R; + g=color.G; + b=color.B; + + cMax = Math.Max(Math.Max(r, g), b); + cMin = Math.Min(Math.Min(r, g), b); + + l = (((cMax+cMin)*HLSMax)+RGBMax)/(2*RGBMax); + + if (cMax==cMin) { // Achromatic + h=0; // h undefined + s=0; + return; + } + + /* saturation */ + if (l<=(HLSMax/2)) { + s=(((cMax-cMin)*HLSMax)+((cMax+cMin)/2))/(cMax+cMin); + } else { + s=(((cMax-cMin)*HLSMax)+((2*RGBMax-cMax-cMin)/2))/(2*RGBMax-cMax-cMin); + } + + /* hue */ + rDelta=(((cMax-r)*(HLSMax/6))+((cMax-cMin)/2))/(cMax-cMin); + gDelta=(((cMax-g)*(HLSMax/6))+((cMax-cMin)/2))/(cMax-cMin); + bDelta=(((cMax-b)*(HLSMax/6))+((cMax-cMin)/2))/(cMax-cMin); + + if (r == cMax) { + h=bDelta - gDelta; + } else if (g == cMax) { + h=(HLSMax/3) + rDelta - bDelta; + } else { /* B == cMax */ + h=((2*HLSMax)/3) + gDelta - rDelta; + } + + if (h<0) { + h+=HLSMax; + } + + if (h>HLSMax) { + h-=HLSMax; + } + } + + private static int HueToRGB(int n1, int n2, int hue) { + if (hue<0) { + hue+=HLSMax; + } + + if (hue>HLSMax) { + hue -= HLSMax; + } + + /* return r,g, or b value from this tridrant */ + if (hue<(HLSMax/6)) { + return(n1+(((n2-n1)*hue+(HLSMax/12))/(HLSMax/6))); + } + + if (hue<(HLSMax/2)) { + return(n2); + } + + if (hue<((HLSMax*2)/3)) { + return(n1+(((n2-n1)*(((HLSMax*2)/3)-hue)+(HLSMax/12))/(HLSMax/6))); + } else { + return(n1); + } + } + + internal static Color HBS2Color(int hue, int lum, int sat) { + int R; + int G; + int B; + int Magic1; + int Magic2; + + if (sat == 0) { /* Achromatic */ + R=G=B=(lum*RGBMax)/HLSMax; + // FIXME : Should throw exception if hue!=0 + } else { + if (lum<=(HLSMax/2)) { + Magic2=(lum*(HLSMax+sat)+(HLSMax/2))/HLSMax; + } else { + Magic2=sat+lum-((sat*lum)+(HLSMax/2))/HLSMax; + } + Magic1=2*lum-Magic2; + + R = Math.Min(255, (HueToRGB(Magic1,Magic2,hue+(HLSMax/3))*RGBMax+(HLSMax/2))/HLSMax); + G = Math.Min(255, (HueToRGB(Magic1,Magic2,hue)*RGBMax+(HLSMax/2))/HLSMax); + B = Math.Min(255, (HueToRGB(Magic1,Magic2,hue-(HLSMax/3))*RGBMax+(HLSMax/2))/HLSMax); + } + return (Color.FromArgb(R, G, B)); + } + #endregion // Helpers + + #region Public Static Properties + public static Color ContrastControlDark { + get { return(SystemColors.ControlDark); } + } + #endregion // Public Static Properties + + #region Public Static Methods + [MonoTODO ("Not implemented, will throw NotImplementedException")] + public static IntPtr CreateHBitmap16Bit (Bitmap bitmap, Color background) + { + throw new NotImplementedException (); + } + + [MonoTODO ("Not implemented, will throw NotImplementedException")] + public static IntPtr CreateHBitmapColorMask (Bitmap bitmap, IntPtr monochromeMask) + { + throw new NotImplementedException (); + } + + [MonoTODO ("Not implemented, will throw NotImplementedException")] + public static IntPtr CreateHBitmapTransparencyMask (Bitmap bitmap) + { + throw new NotImplementedException (); + } + + public static Color Light(Color baseColor) { + return Light(baseColor, 0.5f); + } + + public static Color Light (Color baseColor, float percOfLightLight) + { + if (baseColor.ToArgb () == ThemeEngine.Current.ColorControl.ToArgb ()) { + int r_sub, g_sub, b_sub; + Color color; + + if (percOfLightLight <= 0f) + return ThemeEngine.Current.ColorControlLight; + + if (percOfLightLight == 1.0f) + return ThemeEngine.Current.ColorControlLightLight; + + r_sub = ThemeEngine.Current.ColorControlLightLight.R - ThemeEngine.Current.ColorControlLight.R; + g_sub = ThemeEngine.Current.ColorControlLightLight.G - ThemeEngine.Current.ColorControlLight.G; + b_sub = ThemeEngine.Current.ColorControlLightLight.B - ThemeEngine.Current.ColorControlLight.B; + + color = Color.FromArgb (ThemeEngine.Current.ColorControlLight.A, + (int) (ThemeEngine.Current.ColorControlLight.R + (r_sub * percOfLightLight)), + (int) (ThemeEngine.Current.ColorControlLight.G + (g_sub * percOfLightLight)), + (int) (ThemeEngine.Current.ColorControlLight.B + (b_sub * percOfLightLight))); + return color; + } + + int H, I, S; + + WidgetPaint.Color2HBS (baseColor, out H, out I, out S); + int NewIntensity = Math.Min (255, I + (int) ((255 - I) * 0.5f * percOfLightLight)); + + return WidgetPaint.HBS2Color (H, NewIntensity, S); + } + + public static Color LightLight (Color baseColor) + { + return Light(baseColor, 1.0f); + } + + public static Color Dark (Color baseColor) + { + return Dark(baseColor, 0.5f); + } + + public static Color Dark (Color baseColor, float percOfDarkDark) + { + if (baseColor.ToArgb () == ThemeEngine.Current.ColorControl.ToArgb ()) { + + int r_sub, g_sub, b_sub; + Color color; + + if (percOfDarkDark <= 0f) + return ThemeEngine.Current.ColorControlDark; + + if (percOfDarkDark == 1.0f) + return ThemeEngine.Current.ColorControlDarkDark; + + r_sub = ThemeEngine.Current.ColorControlDarkDark.R - ThemeEngine.Current.ColorControlDark.R; + g_sub = ThemeEngine.Current.ColorControlDarkDark.G - ThemeEngine.Current.ColorControlDark.G; + b_sub = ThemeEngine.Current.ColorControlDarkDark.B - ThemeEngine.Current.ColorControlDark.B; + + color = Color.FromArgb (ThemeEngine.Current.ColorControlDark.A, + (int) (ThemeEngine.Current.ColorControlDark.R + (r_sub * percOfDarkDark)), + (int) (ThemeEngine.Current.ColorControlDark.G + (g_sub * percOfDarkDark)), + (int) (ThemeEngine.Current.ColorControlDark.B + (b_sub * percOfDarkDark))); + return color; + } + + int H, I, S; + + WidgetPaint.Color2HBS(baseColor, out H, out I, out S); + int PreIntensity = Math.Max (0, I - (int) (I * 0.333f)); + int NewIntensity = Math.Max (0, PreIntensity - (int) (PreIntensity * percOfDarkDark)); + return WidgetPaint.HBS2Color(H, NewIntensity, S); + } + + public static Color DarkDark (Color baseColor) + { + return Dark(baseColor, 1.0f); + } + + public static void DrawBorder (Graphics graphics, Rectangle bounds, Color color, ButtonBorderStyle style) + { + int line_width_top_left = 1; + int line_width_bottom_right = 1; + + if (style == ButtonBorderStyle.Inset) + line_width_top_left = 2; + if (style == ButtonBorderStyle.Outset) { + line_width_bottom_right = 2; + line_width_top_left = 2; + } + + DrawBorder(graphics, bounds, color, line_width_top_left, style, color, line_width_top_left, style, color, line_width_bottom_right, style, color, line_width_bottom_right, style); + } + + internal static void DrawBorder (Graphics graphics, RectangleF bounds, Color color, ButtonBorderStyle style) + { + int line_width_top_left = 1; + int line_width_bottom_right = 1; + + if (style == ButtonBorderStyle.Inset) + line_width_top_left = 2; + if (style == ButtonBorderStyle.Outset) { + line_width_bottom_right = 2; + line_width_top_left = 2; + } + + ThemeEngine.Current.CPDrawBorder (graphics, bounds, color, line_width_top_left, style, color, line_width_top_left, style, color, line_width_bottom_right, style, color, line_width_bottom_right, style); + } + + public static void DrawBorder( Graphics graphics, Rectangle bounds, Color leftColor, int leftWidth, + ButtonBorderStyle leftStyle, Color topColor, int topWidth, ButtonBorderStyle topStyle, + Color rightColor, int rightWidth, ButtonBorderStyle rightStyle, Color bottomColor, int bottomWidth, + ButtonBorderStyle bottomStyle) { + + ThemeEngine.Current.CPDrawBorder (graphics, bounds, leftColor, leftWidth, + leftStyle, topColor, topWidth, topStyle, rightColor, rightWidth, rightStyle, + bottomColor, bottomWidth, bottomStyle); + } + + + public static void DrawBorder3D(Graphics graphics, Rectangle rectangle) { + DrawBorder3D(graphics, rectangle, Border3DStyle.Etched, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom); + } + + public static void DrawBorder3D(Graphics graphics, Rectangle rectangle, Border3DStyle style) { + DrawBorder3D(graphics, rectangle, style, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom); + } + + public static void DrawBorder3D(Graphics graphics, int x, int y, int width, int height) { + DrawBorder3D(graphics, new Rectangle(x, y, width, height), Border3DStyle.Etched, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom); + } + + public static void DrawBorder3D(Graphics graphics, int x, int y, int width, int height, Border3DStyle style) { + DrawBorder3D(graphics, new Rectangle(x, y, width, height), style, Border3DSide.Left | Border3DSide.Right | Border3DSide.Top | Border3DSide.Bottom); + } + + public static void DrawBorder3D( Graphics graphics, int x, int y, int width, int height, Border3DStyle style,Border3DSide sides) { + DrawBorder3D( graphics, new Rectangle(x, y, width, height), style, sides); + } + + public static void DrawBorder3D( Graphics graphics, Rectangle rectangle, Border3DStyle style, Border3DSide sides) { + + ThemeEngine.Current.CPDrawBorder3D (graphics, rectangle, style, sides); + } + + public static void DrawButton( Graphics graphics, int x, int y, int width, int height, ButtonState state) { + DrawButton(graphics, new Rectangle(x, y, width, height), state); + } + + public static void DrawButton( Graphics graphics, Rectangle rectangle, ButtonState state) { + + ThemeEngine.Current.CPDrawButton (graphics, rectangle, state); + } + + + public static void DrawCaptionButton(Graphics graphics, int x, int y, int width, int height, CaptionButton button, ButtonState state) { + DrawCaptionButton(graphics, new Rectangle(x, y, width, height), button, state); + } + + public static void DrawCaptionButton(Graphics graphics, Rectangle rectangle, CaptionButton button, ButtonState state) { + + ThemeEngine.Current.CPDrawCaptionButton (graphics, rectangle, button, state); + } + + public static void DrawCheckBox(Graphics graphics, int x, int y, int width, int height, ButtonState state) { + DrawCheckBox(graphics, new Rectangle(x, y, width, height), state); + } + + public static void DrawCheckBox(Graphics graphics, Rectangle rectangle, ButtonState state) { + + ThemeEngine.Current.CPDrawCheckBox (graphics, rectangle, state); + } + + public static void DrawComboButton(Graphics graphics, Rectangle rectangle, ButtonState state) { + + ThemeEngine.Current.CPDrawComboButton (graphics, rectangle, state); + } + + public static void DrawComboButton(Graphics graphics, int x, int y, int width, int height, ButtonState state) { + DrawComboButton(graphics, new Rectangle(x, y, width, height), state); + } + + public static void DrawContainerGrabHandle(Graphics graphics, Rectangle bounds) { + + ThemeEngine.Current.CPDrawContainerGrabHandle (graphics, bounds); + } + + public static void DrawFocusRectangle( Graphics graphics, Rectangle rectangle) { + DrawFocusRectangle(graphics, rectangle, SystemColors.Control, SystemColors.ControlText); + } + + public static void DrawFocusRectangle( Graphics graphics, Rectangle rectangle, Color foreColor, Color backColor) { + + ThemeEngine.Current.CPDrawFocusRectangle (graphics, rectangle, foreColor, backColor); + } + + public static void DrawGrabHandle(Graphics graphics, Rectangle rectangle, bool primary, bool enabled) { + + ThemeEngine.Current.CPDrawGrabHandle (graphics, rectangle, primary, enabled); + } + + public static void DrawGrid(Graphics graphics, Rectangle area, Size pixelsBetweenDots, Color backColor) { + + ThemeEngine.Current.CPDrawGrid (graphics, area, pixelsBetweenDots, backColor); + } + + public static void DrawImageDisabled(Graphics graphics, Image image, int x, int y, Color background) { + + ThemeEngine.Current.CPDrawImageDisabled (graphics, image, x, y, background); + } + + public static void DrawLockedFrame(Graphics graphics, Rectangle rectangle, bool primary) { + + ThemeEngine.Current.CPDrawLockedFrame (graphics, rectangle, primary); + } + + public static void DrawMenuGlyph(Graphics graphics, Rectangle rectangle, MenuGlyph glyph) { + + ThemeEngine.Current.CPDrawMenuGlyph (graphics, rectangle, glyph, ThemeEngine.Current.ColorMenuText, Color.Empty); + } + + public static void DrawMenuGlyph (Graphics graphics, Rectangle rectangle, MenuGlyph glyph, Color foreColor, Color backColor) + { + ThemeEngine.Current.CPDrawMenuGlyph (graphics, rectangle, glyph, foreColor, backColor); + } + + public static void DrawMenuGlyph(Graphics graphics, int x, int y, int width, int height, MenuGlyph glyph) { + DrawMenuGlyph(graphics, new Rectangle(x, y, width, height), glyph); + } + + public static void DrawMenuGlyph (Graphics graphics, int x, int y, int width, int height, MenuGlyph glyph, Color foreColor, Color backColor) + { + DrawMenuGlyph (graphics, new Rectangle (x, y, width, height), glyph, foreColor, backColor); + } + + public static void DrawMixedCheckBox(Graphics graphics, Rectangle rectangle, ButtonState state) { + ThemeEngine.Current.CPDrawMixedCheckBox (graphics, rectangle, state); + } + + public static void DrawMixedCheckBox(Graphics graphics, int x, int y, int width, int height, ButtonState state) { + DrawMixedCheckBox(graphics, new Rectangle(x, y, width, height), state); + } + + + public static void DrawRadioButton(Graphics graphics, int x, int y, int width, int height, ButtonState state) { + DrawRadioButton(graphics, new Rectangle(x, y, width, height), state); + } + + public static void DrawRadioButton(Graphics graphics, Rectangle rectangle, ButtonState state) { + + ThemeEngine.Current.CPDrawRadioButton (graphics, rectangle, state); + } + + public static void DrawReversibleFrame(Rectangle rectangle, Color backColor, FrameStyle style) { + XplatUI.DrawReversibleFrame (rectangle, backColor, style); + } + + public static void DrawReversibleLine(Point start, Point end, Color backColor) { + XplatUI.DrawReversibleLine (start, end, backColor); + } + + public static void FillReversibleRectangle(Rectangle rectangle, Color backColor) { + XplatUI.FillReversibleRectangle (rectangle, backColor); + } + + public static void DrawScrollButton (Graphics graphics, int x, int y, int width, int height, ScrollButton button, ButtonState state) { + ThemeEngine.Current.CPDrawScrollButton (graphics, new Rectangle(x, y, width, height), button, state); + } + + public static void DrawScrollButton (Graphics graphics, Rectangle rectangle, ScrollButton button, ButtonState state) { + ThemeEngine.Current.CPDrawScrollButton (graphics, rectangle, button, state); + } + + [MonoTODO ("Stub, does nothing")] + private static bool DSFNotImpl = false; + public static void DrawSelectionFrame(Graphics graphics, bool active, Rectangle outsideRect, Rectangle insideRect, Color backColor) { + if (!DSFNotImpl) { + DSFNotImpl = true; + Console.WriteLine("NOT IMPLEMENTED: DrawSelectionFrame(Graphics graphics, bool active, Rectangle outsideRect, Rectangle insideRect, Color backColor)"); + } + //throw new NotImplementedException(); + } + + public static void DrawSizeGrip (Graphics graphics, Color backColor, Rectangle bounds) + { + ThemeEngine.Current.CPDrawSizeGrip (graphics, backColor, bounds); + } + + public static void DrawSizeGrip(Graphics graphics, Color backColor, int x, int y, int width, int height) { + DrawSizeGrip(graphics, backColor, new Rectangle(x, y, width, height)); + } + + public static void DrawStringDisabled(Graphics graphics, string s, Font font, Color color, RectangleF layoutRectangle, StringFormat format) { + + ThemeEngine.Current.CPDrawStringDisabled (graphics, s, font, color, layoutRectangle, format); + } + + public static void DrawStringDisabled (IDeviceContext dc, string s, Font font, Color color, Rectangle layoutRectangle, TextFormatFlags format) + { + ThemeEngine.Current.CPDrawStringDisabled (dc, s, font, color, layoutRectangle, format); + } + + public static void DrawVisualStyleBorder (Graphics graphics, Rectangle bounds) + { + ThemeEngine.Current.CPDrawVisualStyleBorder (graphics, bounds); + } + #endregion // Public Static Methods + } +} diff --git a/source/ShiftUI/Internal/CurrencyManager.cs b/source/ShiftUI/Internal/CurrencyManager.cs new file mode 100644 index 0000000..9f68fd4 --- /dev/null +++ b/source/ShiftUI/Internal/CurrencyManager.cs @@ -0,0 +1,453 @@ +// 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. +// +// Authors: +// Jackson Harper ([email protected]) +// Ivan N. Zlatev ([email protected]) +// + +using System; +using System.Data; +using System.Reflection; +using System.Collections; +using System.ComponentModel; + +namespace ShiftUI { + public class CurrencyManager : BindingManagerBase { + + protected int listposition; + protected Type finalType; + + private IList list; + private bool binding_suspended; + + private object data_source; + + bool editing; + + internal CurrencyManager () + { + } + + internal CurrencyManager (object data_source) + { + SetDataSource (data_source); + } + + public IList List { + get { return list; } + } + + public override object Current { + get { + if (listposition == -1 || listposition >= list.Count) { + // Console.WriteLine ("throwing exception from here"); + // Console.WriteLine (Environment.StackTrace); + throw new IndexOutOfRangeException ("list position"); + } + return list [listposition]; + } + } + + public override int Count { + get { return list.Count; } + } + + public override int Position { + get { + return listposition; + } + set { + if (value < 0) + value = 0; + if (value >= list.Count) + value = list.Count - 1; + if (listposition == value) + return; + + if (listposition != -1) + EndCurrentEdit (); + + listposition = value; + OnCurrentChanged (EventArgs.Empty); + OnPositionChanged (EventArgs.Empty); + } + } + + internal void SetDataSource (object data_source) + { + if (this.data_source is IBindingList) + ((IBindingList)this.data_source).ListChanged -= new ListChangedEventHandler (ListChangedHandler); + + if (data_source is IListSource) + data_source = ((IListSource)data_source).GetList(); + + this.data_source = data_source; + if (data_source != null) + this.finalType = data_source.GetType(); + + listposition = -1; + if (this.data_source is IBindingList) + ((IBindingList)this.data_source).ListChanged += new ListChangedEventHandler (ListChangedHandler); + + list = (IList)data_source; + + // XXX this is wrong. MS invokes OnItemChanged directly, which seems to call PushData. + ListChangedHandler (null, new ListChangedEventArgs (ListChangedType.Reset, -1)); + } + + public override PropertyDescriptorCollection GetItemProperties () + { + return ListBindingHelper.GetListItemProperties (list); + } + + public override void RemoveAt (int index) + { + list.RemoveAt (index); + } + + public override void SuspendBinding () + { + binding_suspended = true; + } + + public override void ResumeBinding () + { + binding_suspended = false; + } + + internal override bool IsSuspended { + get { + // Always return true if we don't have items + if (Count == 0) + return true; + + return binding_suspended; + } + } + + internal bool AllowNew { + get { + if (list is IBindingList) + return ((IBindingList)list).AllowNew; + + if (list.IsReadOnly) + return false; + + return false; + } + } + + internal bool AllowRemove { + get { + if (list.IsReadOnly) + return false; + + if (list is IBindingList) + return ((IBindingList)list).AllowRemove; + + return false; + } + } + + internal bool AllowEdit { + get { + if (list is IBindingList) + return ((IBindingList)list).AllowEdit; + + return false; + } + } + + public override void AddNew () + { + IBindingList ibl = list as IBindingList; + + if (ibl == null) + throw new NotSupportedException (); + + ibl.AddNew (); + + bool validate = (Position != (list.Count - 1)); + ChangeRecordState (list.Count - 1, validate, validate, true, true); + } + + + void BeginEdit () + { + IEditableObject editable = Current as IEditableObject; + + if (editable != null) { + try { + editable.BeginEdit (); + editing = true; + } + catch { + /* swallow exceptions in IEditableObject.BeginEdit () */ + } + } + } + + public override void CancelCurrentEdit () + { + if (listposition == -1) + return; + + IEditableObject editable = Current as IEditableObject; + + if (editable != null) { + editing = false; + editable.CancelEdit (); + OnItemChanged (new ItemChangedEventArgs (Position)); + } + if (list is ICancelAddNew) + ((ICancelAddNew)list).CancelNew (listposition); + } + + public override void EndCurrentEdit () + { + if (listposition == -1) + return; + + IEditableObject editable = Current as IEditableObject; + + if (editable != null) { + editing = false; + editable.EndEdit (); + } + + if (list is ICancelAddNew) + ((ICancelAddNew)list).EndNew (listposition); + } + + public void Refresh () + { + ListChangedHandler (null, new ListChangedEventArgs (ListChangedType.Reset, -1)); + } + + protected void CheckEmpty () + { + if (list == null || list.Count < 1) + throw new Exception ("List is empty."); + + } + + protected internal override void OnCurrentChanged (EventArgs e) + { + if (onCurrentChangedHandler != null) { + onCurrentChangedHandler (this, e); + } + + // don't call OnCurrentItemChanged here, as it can be overridden + if (onCurrentItemChangedHandler != null) { + onCurrentItemChangedHandler (this, e); + } + + } + + protected override void OnCurrentItemChanged (EventArgs e) + { + if (onCurrentItemChangedHandler != null) { + onCurrentItemChangedHandler (this, e); + } + } + + protected virtual void OnItemChanged (ItemChangedEventArgs e) + { + if (ItemChanged != null) + ItemChanged (this, e); + + transfering_data = true; + PushData (); + transfering_data = false; + } + + void OnListChanged (ListChangedEventArgs args) + { + if (ListChanged != null) + ListChanged (this, args); + } + + protected virtual void OnPositionChanged (EventArgs e) + { + if (onPositionChangedHandler != null) + onPositionChangedHandler (this, e); + } + + protected internal override string GetListName (ArrayList listAccessors) + { + if (list is ITypedList) { + PropertyDescriptor [] pds = null; + if (listAccessors != null) { + pds = new PropertyDescriptor [listAccessors.Count]; + listAccessors.CopyTo (pds, 0); + } + return ((ITypedList) list).GetListName (pds); + } + else if (finalType != null) { + return finalType.Name; + } + return String.Empty; + } + + protected override void UpdateIsBinding () + { + UpdateItem (); + + foreach (Binding binding in Bindings) + binding.UpdateIsBinding (); + + ChangeRecordState (listposition, false, false, true, false); + + OnItemChanged (new ItemChangedEventArgs (-1)); + } + + private void ChangeRecordState (int newPosition, + bool validating, + bool endCurrentEdit, + bool firePositionChanged, + bool pullData) + { + if (endCurrentEdit) + EndCurrentEdit (); + + int old_index = listposition; + + listposition = newPosition; + + if (listposition >= list.Count) + listposition = list.Count - 1; + + if (old_index != -1 && listposition != -1) + OnCurrentChanged (EventArgs.Empty); + + if (firePositionChanged) + OnPositionChanged (EventArgs.Empty); + } + + private void UpdateItem () + { + // Probably should be validating or something here + if (!transfering_data && listposition == -1 && list.Count > 0) { + listposition = 0; + BeginEdit (); + } + } + + internal object this [int index] { + get { return list [index]; } + } + + private PropertyDescriptorCollection GetBrowsableProperties (Type t) + { + Attribute [] att = new System.Attribute [1]; + att [0] = new BrowsableAttribute (true); + return TypeDescriptor.GetProperties (t, att); + } + + protected void OnMetaDataChanged (EventArgs e) + { + if (MetaDataChanged != null) + MetaDataChanged (this, e); + } + + private void ListChangedHandler (object sender, ListChangedEventArgs e) + { + switch (e.ListChangedType) { + case ListChangedType.PropertyDescriptorAdded: + case ListChangedType.PropertyDescriptorDeleted: + case ListChangedType.PropertyDescriptorChanged: + OnMetaDataChanged (EventArgs.Empty); + OnListChanged (e); + break; + case ListChangedType.ItemDeleted: + if (list.Count == 0) { + /* the last row was deleted */ + listposition = -1; + UpdateIsBinding (); + + OnPositionChanged (EventArgs.Empty); + OnCurrentChanged (EventArgs.Empty); + } + else if (e.NewIndex <= listposition) { + /* the deleted row was either the current one, or one earlier in the list. + Update the index and emit PositionChanged, CurrentChanged, and ItemChanged. */ + // FIXME: this looks wrong, shouldn't it be (listposition - 1) instead of e.NewIndex ? + ChangeRecordState (e.NewIndex, + false, false, e.NewIndex != listposition, false); + } + else { + /* the deleted row was after the current one, so we don't + need to update bound Widgets for Position/Current changed */ + } + + OnItemChanged (new ItemChangedEventArgs (-1)); + OnListChanged (e); + break; + case ListChangedType.ItemAdded: + if (list.Count == 1) { + /* it's the first one we've added */ + ChangeRecordState (e.NewIndex, + false, false, true, false); + + OnItemChanged (new ItemChangedEventArgs (-1)); + OnListChanged (e); + } + else { + if (e.NewIndex <= listposition) { + ChangeRecordState (listposition + 1, + false, false, false, false); + OnItemChanged (new ItemChangedEventArgs (-1)); + OnListChanged (e); + OnPositionChanged (EventArgs.Empty); + } + else { + OnItemChanged (new ItemChangedEventArgs (-1)); + OnListChanged (e); + } + } + + break; + case ListChangedType.ItemChanged: + if (editing) { + if (e.NewIndex == listposition) + OnCurrentItemChanged (EventArgs.Empty); + OnItemChanged (new ItemChangedEventArgs (e.NewIndex)); + } + OnListChanged (e); + break; + case ListChangedType.Reset: + PushData(); + UpdateIsBinding(); + OnListChanged (e); + break; + default: + OnListChanged (e); + break; + } + } + + public event ListChangedEventHandler ListChanged; + public event ItemChangedEventHandler ItemChanged; + public event EventHandler MetaDataChanged; + } +} + diff --git a/source/ShiftUI/Internal/Cursor.cs b/source/ShiftUI/Internal/Cursor.cs new file mode 100644 index 0000000..1b3e0f6 --- /dev/null +++ b/source/ShiftUI/Internal/Cursor.cs @@ -0,0 +1,245 @@ +// 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) 2008 Novell, Inc. +// +// Authors: +// Geoff Norton ([email protected]) +// +// + + +using System; +using System.Drawing; +using ShiftUI; +using System.Runtime.InteropServices; + +namespace ShiftUI.CarbonInternal { + internal class Cursor { + internal static CarbonCursor defcur = new CarbonCursor (StdCursor.Default); + + internal static Bitmap DefineStdCursorBitmap (StdCursor id) { + // FIXME + return new Bitmap (16, 16); + } + internal static IntPtr DefineCursor (Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot) { + CarbonCursor cc = new CarbonCursor (bitmap, mask, cursor_pixel, mask_pixel, xHotSpot, yHotSpot); + + return (IntPtr) GCHandle.Alloc (cc); + } + internal static IntPtr DefineStdCursor (StdCursor id) { + CarbonCursor cc = new CarbonCursor (id); + + return (IntPtr) GCHandle.Alloc (cc); + } + internal static void SetCursor (IntPtr cursor) { + if (cursor == IntPtr.Zero) { + defcur.SetCursor (); + return; + } + + CarbonCursor cc = (CarbonCursor) ((GCHandle) cursor).Target; + + cc.SetCursor (); + } + } + + internal struct CarbonCursor { + private Bitmap bmp; + private Bitmap mask; + private Color cursor_color; + private Color mask_color; + private int hot_x; + private int hot_y; + private StdCursor id; + private bool standard; + + public CarbonCursor (Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot) { + this.id = StdCursor.Default; + this.bmp = bitmap; + this.mask = mask; + this.cursor_color = cursor_pixel; + this.mask_color = mask_pixel; + this.hot_x = xHotSpot; + this.hot_y = yHotSpot; + standard = true; + } + + public CarbonCursor (StdCursor id) { + this.id = id; + this.bmp = null; + this.mask = null; + this.cursor_color = Color.Black; + this.mask_color = Color.Black; + this.hot_x = 0; + this.hot_y = 0; + standard = true; + } + + public StdCursor StdCursor { + get { + return id; + } + } + + public Bitmap Bitmap { + get { + return bmp; + } + } + + public Bitmap Mask { + get { + return mask; + } + } + + public Color CursorColor { + get { + return cursor_color; + } + } + + public Color MaskColor { + get { + return mask_color; + } + } + + public int HotSpotX { + get { + return hot_x; + } + } + + public int HotSpotY { + get { + return hot_y; + } + } + + public void SetCursor () { + if (standard) + SetStandardCursor (); + else + SetCustomCursor (); + } + + public void SetCustomCursor () { + throw new NotImplementedException ("We dont support custom cursors yet"); + } + + public void SetStandardCursor () { + switch (id) { + case StdCursor.AppStarting: + SetThemeCursor (ThemeCursor.kThemeSpinningCursor); + break; + case StdCursor.Arrow: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.Cross: + SetThemeCursor (ThemeCursor.kThemeCrossCursor); + break; + case StdCursor.Default: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.Hand: + SetThemeCursor (ThemeCursor.kThemeOpenHandCursor); + break; + case StdCursor.Help: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.HSplit: + SetThemeCursor (ThemeCursor.kThemeResizeLeftRightCursor); + break; + case StdCursor.IBeam: + SetThemeCursor (ThemeCursor.kThemeIBeamCursor); + break; + case StdCursor.No: + SetThemeCursor (ThemeCursor.kThemeNotAllowedCursor); + break; + case StdCursor.NoMove2D: + SetThemeCursor (ThemeCursor.kThemeNotAllowedCursor); + break; + case StdCursor.NoMoveHoriz: + SetThemeCursor (ThemeCursor.kThemeNotAllowedCursor); + break; + case StdCursor.NoMoveVert: + SetThemeCursor (ThemeCursor.kThemeNotAllowedCursor); + break; + case StdCursor.PanEast: + SetThemeCursor (ThemeCursor.kThemeResizeRightCursor); + break; + case StdCursor.PanNE: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.PanNorth: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.PanNW: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.PanSE: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.PanSouth: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.PanSW: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.PanWest: + SetThemeCursor (ThemeCursor.kThemeResizeLeftCursor); + break; + case StdCursor.SizeAll: + SetThemeCursor (ThemeCursor.kThemeResizeLeftRightCursor); + break; + case StdCursor.SizeNESW: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.SizeNS: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.SizeNWSE: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.SizeWE: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.UpArrow: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.VSplit: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + case StdCursor.WaitCursor: + SetThemeCursor (ThemeCursor.kThemeSpinningCursor); + break; + default: + SetThemeCursor (ThemeCursor.kThemeArrowCursor); + break; + } + return; + } + + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int SetThemeCursor (ThemeCursor cursor); + + } +} diff --git a/source/ShiftUI/Internal/CursorConverter.cs b/source/ShiftUI/Internal/CursorConverter.cs new file mode 100644 index 0000000..d84b3d2 --- /dev/null +++ b/source/ShiftUI/Internal/CursorConverter.cs @@ -0,0 +1,126 @@ +// 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. +// +// Authors: +// Jackson Harper ([email protected]) + + +using System; +using System.IO; +using System.Drawing; +using System.Drawing.Imaging; +using System.Collections; +using System.ComponentModel; +using System.ComponentModel.Design.Serialization; +using System.Globalization; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Runtime.Serialization; + +namespace ShiftUI +{ + public class CursorConverter : TypeConverter + { + public CursorConverter () + { + } + + public override bool CanConvertFrom (ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof (byte [])) + return true; + return base.CanConvertFrom (context, sourceType); + } + + public override bool CanConvertTo (ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof (byte []) || destinationType == typeof (InstanceDescriptor)) + return true; + return base.CanConvertTo (context, destinationType); + } + + public override object ConvertFrom (ITypeDescriptorContext context, + CultureInfo culture, object value) + { + byte [] val = value as byte []; + if (val == null) + return base.ConvertFrom (context, culture, value); + + using (MemoryStream s = new MemoryStream (val)) { + return new Cursor (s); + } + } + + public override object ConvertTo (ITypeDescriptorContext context, CultureInfo culture, + object value, Type destinationType) + { + if (destinationType == null) + throw new ArgumentNullException ("destinationType"); + + if (value == null && destinationType == typeof (string)) + return "(none)"; + + if ( !(value is Cursor)) + throw new ArgumentException("object must be of class Cursor", "value"); + + if (destinationType == typeof (byte [])) { + Cursor c; + SerializationInfo si; + + if (value == null) { + return new byte [0]; + } + + c = (Cursor)value; + + si = new SerializationInfo(typeof(Cursor), new FormatterConverter()); + ((ISerializable)c).GetObjectData(si, new StreamingContext(StreamingContextStates.Remoting)); + + return (byte[])si.GetValue("CursorData", typeof(byte[])); + } else if (destinationType == typeof (InstanceDescriptor)) { + PropertyInfo[] properties = typeof (Cursors).GetProperties (); + foreach (PropertyInfo propInfo in properties) { + if (propInfo.GetValue (null, null) == value) { + return new InstanceDescriptor (propInfo, null); + } + } + } + return base.ConvertTo (context, culture, value, destinationType); + } + + public override StandardValuesCollection GetStandardValues (ITypeDescriptorContext context) + { + PropertyInfo[] props = typeof (Cursors).GetProperties(); + + ArrayList vals = new ArrayList (); + + for (int i = 0; i < props.Length; i++) { + vals.Add (props [i].GetValue (null, null)); + } + return new StandardValuesCollection (vals); + } + + public override bool GetStandardValuesSupported (ITypeDescriptorContext context) + { + return true; + } + } +} diff --git a/source/ShiftUI/Internal/Cursors.cs b/source/ShiftUI/Internal/Cursors.cs new file mode 100644 index 0000000..2d43345 --- /dev/null +++ b/source/ShiftUI/Internal/Cursors.cs @@ -0,0 +1,365 @@ +// 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 ShiftUI; + +namespace ShiftUI { + public sealed class Cursors { + #region Local Variables + internal static Cursor app_starting; + internal static Cursor arrow; + internal static Cursor cross; + internal static Cursor def; + internal static Cursor hand; + internal static Cursor help; + internal static Cursor hsplit; + internal static Cursor ibeam; + internal static Cursor no; + internal static Cursor no_move_2d; + internal static Cursor no_move_horiz; + internal static Cursor no_move_vert; + internal static Cursor pan_east; + internal static Cursor pan_ne; + internal static Cursor pan_north; + internal static Cursor pan_nw; + internal static Cursor pan_se; + internal static Cursor pan_south; + internal static Cursor pan_sw; + internal static Cursor pan_west; + internal static Cursor size_all; + internal static Cursor size_nesw; + internal static Cursor size_ns; + internal static Cursor size_nwse; + internal static Cursor size_we; + internal static Cursor up_arrow; + internal static Cursor vsplit; + internal static Cursor wait_cursor; + #endregion // Local Variables + + #region Constructors + private Cursors() { + } + #endregion // Constructors + + #region Public Static Properties + public static Cursor AppStarting { + get { + if (app_starting == null) { + app_starting = new Cursor(StdCursor.AppStarting); + app_starting.name = "AppStarting"; + } + return app_starting; + } + } + + public static Cursor Arrow { + get { + if (arrow == null) { + arrow = new Cursor(StdCursor.Arrow); + arrow.name = "Arrow"; + } + return arrow; + } + } + + public static Cursor Cross { + get { + if (cross == null) { + cross = new Cursor(StdCursor.Cross); + cross.name = "Cross"; + } + return cross; + } + } + + public static Cursor Default { + get { + if (def == null) { + def = new Cursor(StdCursor.Default); + def.name = "Default"; + } + return def; + } + } + + public static Cursor Hand { + get { + if (hand == null) { + hand = new Cursor(StdCursor.Hand); + hand.name = "Hand"; + } + return hand; + } + } + + public static Cursor Help { + get { + if (help == null) { + help = new Cursor(StdCursor.Help); + help.name = "Help"; + } + return help; + } + } + + public static Cursor HSplit { + get { + if (hsplit == null) { + hsplit = new Cursor(global::ShiftUI.Properties.Resources.SplitterWE); + hsplit.name = "HSplit"; + } + return hsplit; + } + } + + public static Cursor IBeam { + get { + if (ibeam == null) { + ibeam = new Cursor(StdCursor.IBeam); + ibeam.name = "IBeam"; + } + return ibeam; + } + } + + public static Cursor No { + get { + if (no == null) { + no = new Cursor(StdCursor.No); + no.name = "No"; + } + return no; + } + } + + public static Cursor NoMove2D { + get { + if (no_move_2d == null) { + no_move_2d = new Cursor(StdCursor.NoMove2D); + no_move_2d.name = "NoMove2D"; + } + return no_move_2d; + } + } + + public static Cursor NoMoveHoriz { + get { + if (no_move_horiz == null) { + no_move_horiz = new Cursor(StdCursor.NoMoveHoriz); + no_move_horiz.name = "NoMoveHoriz"; + } + return no_move_horiz; + } + } + + public static Cursor NoMoveVert { + get { + if (no_move_vert == null) { + no_move_vert = new Cursor(StdCursor.NoMoveVert); + no_move_vert.name = "NoMoveVert"; + } + return no_move_vert; + } + } + + public static Cursor PanEast { + get { + if (pan_east == null) { + pan_east = new Cursor(StdCursor.PanEast); + pan_east.name = "PanEast"; + } + return pan_east; + } + } + + + + + public static Cursor PanNE { + get { + if (pan_ne == null) { + pan_ne = new Cursor(StdCursor.PanNE); + pan_ne.name = "PanNE"; + } + return pan_ne; + } + } + + + public static Cursor PanNorth { + get { + if (pan_north == null) { + pan_north = new Cursor(StdCursor.PanNorth); + pan_north.name = "PanNorth"; + } + return pan_north; + } + } + + public static Cursor PanNW { + get { + if (pan_nw == null) { + pan_nw = new Cursor(StdCursor.PanNW); + pan_nw.name = "PanNW"; + } + return pan_nw; + } + } + + public static Cursor PanSE { + get { + if (pan_se == null) { + pan_se = new Cursor(StdCursor.PanSE); + pan_se.name = "PanSE"; + } + return pan_se; + } + } + + public static Cursor PanSouth { + get { + if (pan_south == null) { + pan_south = new Cursor(StdCursor.PanSouth); + pan_south.name = "PanSouth"; + } + return pan_south; + } + } + + public static Cursor PanSW { + get { + if (pan_sw == null) { + pan_sw = new Cursor(StdCursor.PanSW); + pan_sw.name = "PanSW"; + } + return pan_sw; + } + } + + public static Cursor PanWest { + get { + if (pan_west == null) { + pan_west = new Cursor(StdCursor.PanWest); + pan_west.name = "PanWest"; + } + return pan_west; + } + } + + public static Cursor SizeAll { + get { + if (size_all == null) { + size_all = new Cursor(StdCursor.SizeAll); + size_all.name = "SizeAll"; + } + return size_all; + } + } + + public static Cursor SizeNESW { + get { + if (size_nesw == null) { + if (XplatUI.RunningOnUnix) { + size_nesw = new Cursor(Properties.Resources.NESW); + size_nesw.name = "SizeNESW"; + } else { + size_nesw = new Cursor(StdCursor.SizeNESW); + size_nesw.name = "SizeNESW"; + } + } + return size_nesw; + } + } + + public static Cursor SizeNS { + get { + if (size_ns == null) { + size_ns = new Cursor(StdCursor.SizeNS); + size_ns.name = "SizeNS"; + } + return size_ns; + } + } + + public static Cursor SizeNWSE { + get { + if (size_nwse == null) { + if (XplatUI.RunningOnUnix) { + size_nwse = new Cursor(Properties.Resources.NWSE); + size_nwse.name = "SizeNWSE"; + } else { + size_nwse = new Cursor(StdCursor.SizeNWSE); + size_nwse.name = "SizeNWSE"; + } + } + return size_nwse; + } + } + + public static Cursor SizeWE { + get { + if (size_we == null) { + size_we = new Cursor(StdCursor.SizeWE); + size_we.name = "SizeWE"; + } + return size_we; + } + } + + public static Cursor UpArrow { + get { + if (up_arrow == null) { + up_arrow = new Cursor(StdCursor.UpArrow); + up_arrow.name = "UpArrow"; + } + return up_arrow; + } + } + + public static Cursor VSplit { + get { + if (vsplit == null) { + vsplit = new Cursor(Properties.Resources.SplitterWE); + vsplit.name = "VSplit"; + } + return vsplit; + } + } + + public static Cursor WaitCursor { + get { + if (wait_cursor == null) { + wait_cursor = new Cursor(StdCursor.WaitCursor); + wait_cursor.name = "WaitCursor"; + } + return wait_cursor; + } + } + #endregion // Public Static Properties + } +} 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 + } +} diff --git a/source/ShiftUI/Internal/Day.cs b/source/ShiftUI/Internal/Day.cs new file mode 100644 index 0000000..0c797a7 --- /dev/null +++ b/source/ShiftUI/Internal/Day.cs @@ -0,0 +1,39 @@ +// +// 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) 2004 Novell, Inc. +// +// Authors: +// John BouAntoun [email protected] +// + +namespace ShiftUI { + // used mainly by monthcalendar + public enum Day { + Monday, + Tuesday, + Wednesday, + Thursday, + Friday, + Saturday, + Sunday, + Default + } +} diff --git a/source/ShiftUI/Internal/DebugHelper.cs b/source/ShiftUI/Internal/DebugHelper.cs new file mode 100644 index 0000000..3c76307 --- /dev/null +++ b/source/ShiftUI/Internal/DebugHelper.cs @@ -0,0 +1,257 @@ +// 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) 2008 Novell, Inc. +// +// Authors: +// Andreia Gaita ([email protected]) +// + +//#define DEBUG +//#define TRACE + +using System; +using System.Collections.Generic; +using System.Reflection; +using System.Text; +using System.IO; +using System.Diagnostics; + +namespace ShiftUI +{ + internal class DebugHelper + { + static DebugHelper () { + Debug.AutoFlush = true; + } + + struct Data { + public MethodBase method; + public object[] args; + public Data (MethodBase m, object[] a) { + this.method = m; + this.args = a; + } + } + + static Stack<Data> methods = new Stack<Data>(); + + [Conditional("DEBUG")] + internal static void DumpCallers () { + StackTrace trace = new StackTrace(true); + int count = trace.FrameCount; + Debug.Indent (); + for (int i = 1; i < count; i++) { + StackFrame parentFrame = trace.GetFrame(i); + MethodBase parentMethod = parentFrame.GetMethod(); + string file = parentFrame.GetFileName(); + if (file != null && file.Length > 1) + file = file.Substring (file.LastIndexOf (Path.DirectorySeparatorChar) + 1); + Debug.WriteLine(parentMethod.DeclaringType.Name + "." + parentMethod.Name + + " at " + file + ":" + parentFrame.GetFileLineNumber() + ); + } + + Debug.Unindent (); + } + + [Conditional("DEBUG")] + internal static void DumpCallers (int count) { + StackTrace trace = new StackTrace(true); + int c = (count > trace.FrameCount ? trace.FrameCount : count); + Debug.Indent (); + for (int i = 1; i < c; i++) { + StackFrame parentFrame = trace.GetFrame(i); + MethodBase parentMethod = parentFrame.GetMethod(); + string file = parentFrame.GetFileName(); + if (file != null && file.Length > 1) + file = file.Substring (file.LastIndexOf (Path.DirectorySeparatorChar) + 1); + Debug.WriteLine(parentMethod.DeclaringType.Name + "." + parentMethod.Name + + " at " + file + ":" + parentFrame.GetFileLineNumber() + ); + } + + Debug.Unindent (); + } + + [Conditional("DEBUG")] + internal static void Enter () + { + StackTrace trace = new StackTrace(); + methods.Push (new Data (trace.GetFrame(1).GetMethod(), null)); + Print (); + Debug.Indent (); + } + + [Conditional("DEBUG")] + internal static void Enter (object[] args) + { + StackTrace trace = new StackTrace(); + methods.Push (new Data (trace.GetFrame(1).GetMethod(), args)); + Print (); + Debug.Indent (); + } + + [Conditional("DEBUG")] + internal static void Leave () + { + if (methods.Count > 0) { + methods.Pop (); + Debug.Unindent (); + } + } + + [Conditional("DEBUG")] + internal static void Print () + { + if (methods.Count == 0) + return; + + Data data = methods.Peek (); + Debug.WriteLine (data.method.DeclaringType.Name + "." + data.method.Name); + } + + [Conditional("DEBUG")] + internal static void Print (int index) + { + if (methods.Count == 0 || methods.Count <= index || index < 0) + return; + + Stack<Data> temp = new Stack<Data>(index-1); + + for (int i = 0; i < index; i++) + temp.Push (methods.Pop ()); + + Data data = methods.Peek (); + for (int i = 0; i < temp.Count; i++) + methods.Push (temp.Pop()); + temp = null; + + Debug.WriteLine (data.method.DeclaringType.Name + "." + data.method.Name); + } + + [Conditional("DEBUG")] + internal static void Print (string methodName, string parameterName) + { + if (methods.Count == 0) + return; + + Stack<Data> temp = new Stack<Data>(); + + Data data = methods.Peek (); + bool foundit = false; + for (int i = 0; i < methods.Count; i++) + { + data = methods.Peek (); + if (data.method.Name.Equals (methodName)) { + foundit = true; + break; + } + temp.Push (methods.Pop ()); + } + + for (int i = 0; i < temp.Count; i++) + methods.Push (temp.Pop()); + temp = null; + + if (!foundit) + return; + + Debug.WriteLine (data.method.DeclaringType.Name + "." + data.method.Name); + ParameterInfo[] pi = data.method.GetParameters (); + + for (int i = 0; i < pi.Length; i++) { + if (pi[i].Name == parameterName) { + Debug.Indent (); + Debug.Write (parameterName + "="); + if (pi[i].ParameterType == typeof(IntPtr)) + Debug.WriteLine (String.Format ("0x{0:x}", ((IntPtr)data.args[i]).ToInt32())); + else + Debug.WriteLine (data.args[i]); + Debug.Unindent (); + } + } + } + + [Conditional("DEBUG")] + internal static void Print (string parameterName) + { + if (methods.Count == 0) + return; + Data data = methods.Peek (); + + ParameterInfo[] pi = data.method.GetParameters (); + + for (int i = 0; i < pi.Length; i++) { + if (pi[i].Name == parameterName) { + Debug.Indent (); + Debug.Write (parameterName + "="); + if (pi[i].ParameterType == typeof(IntPtr)) + Debug.WriteLine (String.Format ("0x{0:x}", data.args[i])); + else + Debug.WriteLine (data.args[i]); + Debug.Unindent (); + } + } + } + + [Conditional("DEBUG")] + internal static void WriteLine (object arg) + { + Debug.WriteLine (arg); + } + + [Conditional("DEBUG")] + internal static void WriteLine (string format, params object[] arg) + { + Debug.WriteLine (String.Format (format, arg)); + } + + [Conditional("DEBUG")] + internal static void WriteLine (string message) + { + Debug.WriteLine (message); + } + + [Conditional("DEBUG")] + internal static void Indent () + { + Debug.Indent (); + } + + [Conditional("DEBUG")] + internal static void Unindent () + { + Debug.Unindent (); + } + + [Conditional("TRACE")] + internal static void TraceWriteLine (string format, params object[] arg) + { + Debug.WriteLine (String.Format (format, arg)); + } + + [Conditional("TRACE")] + internal static void TraceWriteLine (string message) + { + Debug.WriteLine (message); + } + + } +} diff --git a/source/ShiftUI/Internal/DefaultLayout.cs b/source/ShiftUI/Internal/DefaultLayout.cs new file mode 100644 index 0000000..4fbf647 --- /dev/null +++ b/source/ShiftUI/Internal/DefaultLayout.cs @@ -0,0 +1,290 @@ +// +// DefaultLayout.cs +// +// 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) 2006 Jonathan Pobst +// +// Authors: +// Jonathan Pobst ([email protected]) +// Stefan Noack ([email protected]) +// + +using System; +using System.Drawing; + +namespace ShiftUI.Layout +{ + class DefaultLayout : LayoutEngine + { + void LayoutDockedChildren (Widget parent, Widget[] Widgets) + { + Rectangle space = parent.DisplayRectangle; + MdiClient mdi = null; + + // Deal with docking; go through in reverse, MS docs say that lowest Z-order is closest to edge + for (int i = Widgets.Length - 1; i >= 0; i--) { + Widget child = Widgets[i]; + Size child_size = child.Size; + + if (child.AutoSize) + child_size = GetPreferredWidgetSize (child); + + if (!child.VisibleInternal + || child.WidgetLayoutType == Widget.LayoutType.Anchor) + continue; + + // MdiClient never fills the whole area like other Widgets, have to do it later + if (child is MdiClient) { + mdi = (MdiClient)child; + continue; + } + + switch (child.Dock) { + case DockStyle.None: + // Do nothing + break; + + case DockStyle.Left: + child.SetBoundsInternal (space.Left, space.Y, child_size.Width, space.Height, BoundsSpecified.None); + space.X += child.Width; + space.Width -= child.Width; + break; + + case DockStyle.Top: + child.SetBoundsInternal (space.Left, space.Y, space.Width, child_size.Height, BoundsSpecified.None); + space.Y += child.Height; + space.Height -= child.Height; + break; + + case DockStyle.Right: + child.SetBoundsInternal (space.Right - child_size.Width, space.Y, child_size.Width, space.Height, BoundsSpecified.None); + space.Width -= child.Width; + break; + + case DockStyle.Bottom: + child.SetBoundsInternal (space.Left, space.Bottom - child_size.Height, space.Width, child_size.Height, BoundsSpecified.None); + space.Height -= child.Height; + break; + + case DockStyle.Fill: + child.SetBoundsInternal (space.Left, space.Top, space.Width, space.Height, BoundsSpecified.None); + break; + } + } + + // MdiClient gets whatever space is left + if (mdi != null) + mdi.SetBoundsInternal (space.Left, space.Top, space.Width, space.Height, BoundsSpecified.None); + } + + void LayoutAnchoredChildren (Widget parent, Widget[] Widgets) + { + Rectangle space = parent.ClientRectangle; + + for (int i = 0; i < Widgets.Length; i++) { + int left; + int top; + int width; + int height; + + Widget child = Widgets[i]; + + if (!child.VisibleInternal + || child.WidgetLayoutType == Widget.LayoutType.Dock) + continue; + + AnchorStyles anchor = child.Anchor; + + left = child.Left; + top = child.Top; + + width = child.Width; + height = child.Height; + + if ((anchor & AnchorStyles.Right) != 0) { + if ((anchor & AnchorStyles.Left) != 0) + width = space.Width - child.dist_right - left; + else + left = space.Width - child.dist_right - width; + } + else if ((anchor & AnchorStyles.Left) == 0) { + // left+=diff_width/2 will introduce rounding errors (diff_width removed from svn after r51780) + // This calculates from scratch every time: + left = left + (space.Width - (left + width + child.dist_right)) / 2; + child.dist_right = space.Width - (left + width); + } + + if ((anchor & AnchorStyles.Bottom) != 0) { + if ((anchor & AnchorStyles.Top) != 0) + height = space.Height - child.dist_bottom - top; + else + top = space.Height - child.dist_bottom - height; + } + else if ((anchor & AnchorStyles.Top) == 0) { + // top += diff_height/2 will introduce rounding errors (diff_height removed from after r51780) + // This calculates from scratch every time: + top = top + (space.Height - (top + height + child.dist_bottom)) / 2; + child.dist_bottom = space.Height - (top + height); + } + + // Sanity + if (width < 0) + width = 0; + + if (height < 0) + height = 0; + + child.SetBoundsInternal (left, top, width, height, BoundsSpecified.None); + } + } + + void LayoutAutoSizedChildren (Widget parent, Widget[] Widgets) + { + for (int i = 0; i < Widgets.Length; i++) { + int left; + int top; + + Widget child = Widgets[i]; + if (!child.VisibleInternal + || child.WidgetLayoutType == Widget.LayoutType.Dock + || !child.AutoSize) + continue; + + AnchorStyles anchor = child.Anchor; + left = child.Left; + top = child.Top; + + Size preferredsize = GetPreferredWidgetSize (child); + + if (((anchor & AnchorStyles.Left) != 0) || ((anchor & AnchorStyles.Right) == 0)) + child.dist_right += child.Width - preferredsize.Width; + if (((anchor & AnchorStyles.Top) != 0) || ((anchor & AnchorStyles.Bottom) == 0)) + child.dist_bottom += child.Height - preferredsize.Height; + + child.SetBoundsInternal (left, top, preferredsize.Width, preferredsize.Height, BoundsSpecified.None); + } + } + + void LayoutAutoSizeContainer (Widget container) + { + int left; + int top; + int width; + int height; + + if (!container.VisibleInternal || container.WidgetLayoutType == Widget.LayoutType.Dock || !container.AutoSize) + return; + + left = container.Left; + top = container.Top; + + Size preferredsize = container.PreferredSize; + + if (container.GetAutoSizeMode () == AutoSizeMode.GrowAndShrink) { + width = preferredsize.Width; + height = preferredsize.Height; + } else { + width = container.ExplicitBounds.Width; + height = container.ExplicitBounds.Height; + if (preferredsize.Width > width) + width = preferredsize.Width; + if (preferredsize.Height > height) + height = preferredsize.Height; + } + + // Sanity + if (width < container.MinimumSize.Width) + width = container.MinimumSize.Width; + + if (height < container.MinimumSize.Height) + height = container.MinimumSize.Height; + + if (container.MaximumSize.Width != 0 && width > container.MaximumSize.Width) + width = container.MaximumSize.Width; + + if (container.MaximumSize.Height != 0 && height > container.MaximumSize.Height) + height = container.MaximumSize.Height; + + container.SetBoundsInternal (left, top, width, height, BoundsSpecified.None); + } + + public override bool Layout (object container, LayoutEventArgs args) + { + Widget parent = container as Widget; + + Widget[] Widgets = parent.Widgets.GetAllWidgets (); + + LayoutDockedChildren (parent, Widgets); + LayoutAnchoredChildren (parent, Widgets); + LayoutAutoSizedChildren (parent, Widgets); + if (parent is Form) LayoutAutoSizeContainer (parent); + + return false; + } + + private Size GetPreferredWidgetSize (Widget child) + { + int width; + int height; + Size preferredsize = child.PreferredSize; + + if (child.GetAutoSizeMode () == AutoSizeMode.GrowAndShrink || (child.Dock != DockStyle.None && !(child is Button) && !(child is FlowLayoutPanel))) { + width = preferredsize.Width; + height = preferredsize.Height; + } else { + width = child.ExplicitBounds.Width; + height = child.ExplicitBounds.Height; + if (preferredsize.Width > width) + width = preferredsize.Width; + if (preferredsize.Height > height) + height = preferredsize.Height; + } + if (child.AutoSize && child is FlowLayoutPanel && child.Dock != DockStyle.None) { + switch (child.Dock) { + case DockStyle.Left: + case DockStyle.Right: + if (preferredsize.Width < child.ExplicitBounds.Width && preferredsize.Height < child.Parent.PaddingClientRectangle.Height) + width = preferredsize.Width; + break; + case DockStyle.Top: + case DockStyle.Bottom: + if (preferredsize.Height < child.ExplicitBounds.Height && preferredsize.Width < child.Parent.PaddingClientRectangle.Width) + height = preferredsize.Height; + break; + } + } + // Sanity + if (width < child.MinimumSize.Width) + width = child.MinimumSize.Width; + + if (height < child.MinimumSize.Height) + height = child.MinimumSize.Height; + + if (child.MaximumSize.Width != 0 && width > child.MaximumSize.Width) + width = child.MaximumSize.Width; + + if (child.MaximumSize.Height != 0 && height > child.MaximumSize.Height) + height = child.MaximumSize.Height; + + return new Size (width, height); + } + } +} diff --git a/source/ShiftUI/Internal/Dnd.cs b/source/ShiftUI/Internal/Dnd.cs new file mode 100644 index 0000000..b08b528 --- /dev/null +++ b/source/ShiftUI/Internal/Dnd.cs @@ -0,0 +1,371 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton ([email protected]) +// +// + + +using System; +using System.IO; +using System.Text; +using System.Drawing; +using System.Threading; +using System.Collections; +using ShiftUI; +using System.Runtime.Serialization; +using System.Runtime.InteropServices; +using System.Runtime.Serialization.Formatters.Binary; + +namespace ShiftUI.CarbonInternal { + internal delegate void DragTrackingDelegate (short message, IntPtr window, IntPtr data, IntPtr dragref); + + internal class Dnd { + internal const uint kEventParamDragRef = 1685217639; + internal const uint typeDragRef = 1685217639; + + internal const uint typeMono = 1836019311; + internal const uint typeMonoSerializedObject = 1836279154; + + private static DragDropEffects effects = DragDropEffects.None; + private static DragTrackingDelegate DragTrackingHandler = new DragTrackingDelegate (TrackingCallback); + + static Dnd () { + try { + InstallTrackingHandler (DragTrackingHandler, IntPtr.Zero, IntPtr.Zero); + } catch (EntryPointNotFoundException) { + // it is deprecated in 10.6 and does not exist anymore. + } + } + + internal Dnd () { + } + + internal static void TrackingCallback (short message, IntPtr window, IntPtr data, IntPtr dragref) { + XplatUICarbon.GetInstance ().FlushQueue (); + } + + internal static DragDropEffects DragActionsToEffects (UInt32 actions) { + DragDropEffects effects = DragDropEffects.None; + if ((actions & 1) != 0) + effects |= DragDropEffects.Copy; + if ((actions & (1 << 4)) != 0) + effects |= DragDropEffects.Move; + if ((actions & 0xFFFFFFFF) != 0) + effects |= DragDropEffects.All; + + return effects; + } + + internal static DataObject DragToDataObject (IntPtr dragref) { + UInt32 items = 0; + ArrayList flavorlist = new ArrayList (); + + CountDragItems (dragref, ref items); + + for (uint item_counter = 1; item_counter <= items; item_counter++) { + IntPtr itemref = IntPtr.Zero; + UInt32 flavors = 0; + + GetDragItemReferenceNumber (dragref, item_counter, ref itemref); + CountDragItemFlavors (dragref, itemref, ref flavors); + for (uint flavor_counter = 1; flavor_counter <= flavors; flavor_counter++) { + FlavorHandler flavor = new FlavorHandler (dragref, itemref, flavor_counter); + if (flavor.Supported) + flavorlist.Add (flavor); + } + } + + if (flavorlist.Count > 0) { + return ((FlavorHandler) flavorlist [0]).Convert (flavorlist); + } + + return new DataObject (); + } + + internal static bool HandleEvent (IntPtr callref, IntPtr eventref, IntPtr handle, uint kind, ref MSG msg) { + Widget Widget; + DataObject data; + DragEventArgs drag_event; + DragDropEffects allowed; + QDPoint point = new QDPoint (); + UInt32 actions = 0; + IntPtr dragref = IntPtr.Zero; + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd == null || hwnd.Handle != handle) + return false; + + GetEventParameter (eventref, kEventParamDragRef, typeDragRef, IntPtr.Zero, (uint) Marshal.SizeOf (typeof (IntPtr)), IntPtr.Zero, ref dragref); + XplatUICarbon.GetGlobalMouse (ref point); + GetDragAllowableActions (dragref, ref actions); + Widget = Widget.FromHandle (hwnd.Handle); + allowed = DragActionsToEffects (actions); + data = DragToDataObject (dragref); + drag_event = new DragEventArgs (data, 0, point.x, point.y, allowed, DragDropEffects.None); + + switch (kind) { + case WidgetHandler.kEventWidgetDragEnter: { + bool accept = Widget.AllowDrop; + SetEventParameter (eventref, WidgetHandler.kEventParamWidgetLikesDrag, WidgetHandler.typeBoolean, (uint)Marshal.SizeOf (typeof (bool)), ref accept); + + Widget.DndEnter (drag_event); + effects = drag_event.Effect; + return false; + } + case WidgetHandler.kEventWidgetDragWithin: + Widget.DndOver (drag_event); + effects = drag_event.Effect; + break; + case WidgetHandler.kEventWidgetDragLeave: + Widget.DndLeave (drag_event); + break; + case WidgetHandler.kEventWidgetDragReceive: + Widget.DndDrop (drag_event); + break; + } + return true; + } + + public void SetAllowDrop (Hwnd hwnd, bool allow) { + if (hwnd.allow_drop == allow) + return; + + hwnd.allow_drop = allow; + SetWidgetDragTrackingEnabled (hwnd.whole_window, true); + SetWidgetDragTrackingEnabled (hwnd.client_window, true); + } + + public void SendDrop (IntPtr handle, IntPtr from, IntPtr time) { + } + + public DragDropEffects StartDrag (IntPtr handle, object data, DragDropEffects allowed_effects) { + IntPtr dragref = IntPtr.Zero; + EventRecord eventrecord = new EventRecord (); + + effects = DragDropEffects.None; + + NewDrag (ref dragref); + XplatUICarbon.GetGlobalMouse (ref eventrecord.mouse); + StoreObjectInDrag (handle, dragref, data); + + TrackDrag (dragref, ref eventrecord, IntPtr.Zero); + + DisposeDrag (dragref); + + return effects; + } + + public void StoreObjectInDrag (IntPtr handle, IntPtr dragref, object data) { + IntPtr type = IntPtr.Zero; + IntPtr dataptr = IntPtr.Zero; + Int32 size = 0; + + if (data is string) { + // implement me + throw new NotSupportedException ("Implement me."); + } else if (data is ISerializable) { + MemoryStream stream = new MemoryStream (); + BinaryFormatter bf = new BinaryFormatter (); + + bf.Serialize (stream, data); + + dataptr = Marshal.AllocHGlobal ((int) stream.Length); + stream.Seek (0, 0); + + for (int i = 0; i < stream.Length; i++) { + Marshal.WriteByte (dataptr, i, (byte) stream.ReadByte ()); + } + + type = (IntPtr) typeMonoSerializedObject; + size = (int) stream.Length; + } else { + dataptr = (IntPtr) GCHandle.Alloc (data); + + type = (IntPtr) typeMono; + size = Marshal.SizeOf (typeof (IntPtr)); + } + + AddDragItemFlavor (dragref, handle, type, ref dataptr, size, 1 << 0); + } + + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int InstallTrackingHandler (DragTrackingDelegate callback, IntPtr window, IntPtr data); + + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int GetEventParameter (IntPtr eventref, uint name, uint type, IntPtr outtype, uint size, IntPtr outsize, ref IntPtr data); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int SetEventParameter (IntPtr eventref, uint name, uint type, uint size, ref bool data); + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int SetWidgetDragTrackingEnabled (IntPtr view, bool enabled); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int AddDragItemFlavor (IntPtr dragref, IntPtr itemref, IntPtr flavortype, ref IntPtr data, Int32 size, UInt32 flags); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int CountDragItems (IntPtr dragref, ref UInt32 count); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int CountDragItemFlavors (IntPtr dragref, IntPtr itemref, ref UInt32 count); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int GetDragItemReferenceNumber (IntPtr dragref, UInt32 index, ref IntPtr itemref); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int NewDrag (ref IntPtr dragref); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int TrackDrag (IntPtr dragref, ref EventRecord eventrecord, IntPtr region); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int DisposeDrag (IntPtr dragref); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int GetDragAllowableActions (IntPtr dragref, ref UInt32 actions); + } + + internal struct EventRecord { + internal UInt16 what; + internal UInt32 message; + internal UInt32 when; + internal QDPoint mouse; + internal UInt16 modifiers; + } + + internal class FlavorHandler { + internal IntPtr flavorref; + internal IntPtr dragref; + internal IntPtr itemref; + internal Int32 size; + internal UInt32 flags; + internal byte [] data; + internal string fourcc; + + internal FlavorHandler (IntPtr dragref, IntPtr itemref, uint counter) { + GetFlavorType (dragref, itemref, counter, ref flavorref); + GetFlavorFlags (dragref, itemref, flavorref, ref flags); + byte [] fourcc_b = BitConverter.GetBytes ((Int32)flavorref); + this.fourcc = String.Format ("{0}{1}{2}{3}", (char)fourcc_b [3], (char)fourcc_b [2], (char)fourcc_b [1], (char)fourcc_b [0]); + this.dragref = dragref; + this.itemref = itemref; + + this.GetData (); + } + + internal void GetData () { + GetFlavorDataSize (dragref, itemref, flavorref, ref size); + data = new byte [size]; + GetFlavorData (dragref, itemref, flavorref, data, ref size, 0); + } + + internal string DataString { + get { return Encoding.Default.GetString (this.data); } + } + + internal byte[] DataArray { + get { return this.data; } + } + + internal IntPtr DataPtr { + get { return (IntPtr) BitConverter.ToInt32 (this.data, 0); } + } + + internal bool Supported { + get { + switch (fourcc) { + case "furl": + return true; + case "mono": + return true; + case "mser": + return true; + } + return false; + } + } + + internal DataObject Convert (ArrayList flavorlist) { + switch (fourcc) { + case "furl": + return ConvertToFileDrop (flavorlist); + case "mono": + return ConvertToObject (flavorlist); + case "mser": + return DeserializeObject (flavorlist); + } + + return new DataObject (); + } + + internal DataObject DeserializeObject (ArrayList flavorlist) { + DataObject data = new DataObject (); + MemoryStream stream = new MemoryStream (this.DataArray); + BinaryFormatter bf = new BinaryFormatter (); + + if (stream.Length == 0) + return data; + + stream.Seek (0, 0); + data.SetData (bf.Deserialize (stream)); + + return data; + } + + internal DataObject ConvertToObject (ArrayList flavorlist) { + DataObject data = new DataObject (); + + foreach (FlavorHandler flavor in flavorlist) { + GCHandle handle = (GCHandle) flavor.DataPtr; + + data.SetData (handle.Target); + } + + return data; + } + + internal DataObject ConvertToFileDrop (ArrayList flavorlist) { + DataObject data = new DataObject (); + ArrayList uri_list = new ArrayList (); + + foreach (FlavorHandler flavor in flavorlist) { + try { + uri_list.Add (new Uri (flavor.DataString).LocalPath); + } catch { } + } + + string [] l = (string []) uri_list.ToArray (typeof (string)); + if (l.Length < 1) + return data; + data.SetData (DataFormats.FileDrop, l); + data.SetData ("FileName", l [0]); + data.SetData ("FileNameW", l [0]); + + return data; + } + + public override string ToString () { + return fourcc; + } + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int GetFlavorDataSize (IntPtr dragref, IntPtr itemref, IntPtr flavorref, ref Int32 size); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int GetFlavorData (IntPtr dragref, IntPtr itemref, IntPtr flavorref, [In, Out] byte[] data, ref Int32 size, UInt32 offset); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int GetFlavorFlags (IntPtr dragref, IntPtr itemref, IntPtr flavorref, ref UInt32 flags); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int GetFlavorType (IntPtr dragref, IntPtr itemref, UInt32 index, ref IntPtr flavor); + } +} diff --git a/source/ShiftUI/Internal/DockingAttribute.cs b/source/ShiftUI/Internal/DockingAttribute.cs new file mode 100644 index 0000000..3aba6bf --- /dev/null +++ b/source/ShiftUI/Internal/DockingAttribute.cs @@ -0,0 +1,74 @@ +// +// DockingAttribute.cs +// +// 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) 2006 Daniel Nauck +// +// Author: +// Daniel Nauck (dna(at)mono-project(dot)de) + + +using System; +using ShiftUI; + +namespace ShiftUI +{ + [AttributeUsageAttribute(AttributeTargets.Class)] + public sealed class DockingAttribute : Attribute + { + private DockingBehavior dockingBehavior; + + public DockingAttribute() + { + dockingBehavior = DockingBehavior.Never; + } + + public DockingAttribute(DockingBehavior dockingBehavior) + { + this.dockingBehavior = dockingBehavior; + } + + public static readonly DockingAttribute Default = new DockingAttribute(); + + public DockingBehavior DockingBehavior + { + get { return dockingBehavior; } + } + + public override bool Equals(object obj) + { + if (obj is DockingAttribute) + return (dockingBehavior == ((DockingAttribute)obj).DockingBehavior); + else + return false; + } + + public override int GetHashCode() + { + return dockingBehavior.GetHashCode(); + } + + public override bool IsDefaultAttribute() + { + return Default.Equals(this); + } + } +} diff --git a/source/ShiftUI/Internal/DockingBehavior.cs b/source/ShiftUI/Internal/DockingBehavior.cs new file mode 100644 index 0000000..b5dcdc0 --- /dev/null +++ b/source/ShiftUI/Internal/DockingBehavior.cs @@ -0,0 +1,38 @@ +// +// DockingBehavior.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + + +namespace ShiftUI +{ + public enum DockingBehavior + { + Never = 0, + Ask = 1, + AutoDock = 2 + } +} diff --git a/source/ShiftUI/Internal/DrawToolTipEventArgs.cs b/source/ShiftUI/Internal/DrawToolTipEventArgs.cs new file mode 100644 index 0000000..8d66f5f --- /dev/null +++ b/source/ShiftUI/Internal/DrawToolTipEventArgs.cs @@ -0,0 +1,113 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Rolf Bjarne Kvinge <[email protected]> +// +// +// COMPLETE + + +using System.Drawing; +using System; + +namespace ShiftUI +{ + public class DrawToolTipEventArgs : EventArgs + { + private Widget associated_control; + private IWin32Window associated_window; + private Color back_color; + private Font font; + private Rectangle bounds; + private Color fore_color; + private Graphics graphics; + private string tooltip_text; + + public DrawToolTipEventArgs (Graphics graphics, IWin32Window associatedWindow, Widget associatedControl, Rectangle bounds, string toolTipText, Color backColor, Color foreColor, Font font) + { + this.graphics = graphics; + this.associated_window = associatedWindow; + this.associated_control = associatedControl; + this.bounds = bounds; + this.tooltip_text = toolTipText; + this.back_color = backColor; + this.fore_color = foreColor; + this.font = font; + } + + public void DrawBackground () + { + graphics.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (back_color), bounds); + } + + public void DrawBorder () + { + WidgetPaint.DrawBorder (graphics, bounds, SystemColors.WindowFrame, ButtonBorderStyle.Solid); + } + + public void DrawText () + { + DrawText (TextFormatFlags.HidePrefix | TextFormatFlags.SingleLine | TextFormatFlags.VerticalCenter | TextFormatFlags.HorizontalCenter); + } + + public void DrawText (TextFormatFlags flags) + { + TextRenderer.DrawTextInternal (graphics, tooltip_text, font, bounds, fore_color, flags, false); + } + + public Widget AssociatedWidget { + get { + return associated_control; + } + } + + public IWin32Window AssociatedWindow { + get { + return associated_window; + } + } + + public Rectangle Bounds { + get { + return bounds; + } + } + + public Font Font { + get { + return font; + } + } + + public Graphics Graphics { + get { + return graphics; + } + } + + public string ToolTipText { + get { + return tooltip_text; + } + } + } +}
\ No newline at end of file diff --git a/source/ShiftUI/Internal/DrawToolTipEventHandler.cs b/source/ShiftUI/Internal/DrawToolTipEventHandler.cs new file mode 100644 index 0000000..e647ae8 --- /dev/null +++ b/source/ShiftUI/Internal/DrawToolTipEventHandler.cs @@ -0,0 +1,31 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Rolf Bjarne Kvinge <[email protected]> +// +// +// COMPLETE + +namespace ShiftUI +{ + public delegate void DrawToolTipEventHandler (object sender, DrawToolTipEventArgs e); +} diff --git a/source/ShiftUI/Internal/Enums.cs b/source/ShiftUI/Internal/Enums.cs new file mode 100644 index 0000000..50d705e --- /dev/null +++ b/source/ShiftUI/Internal/Enums.cs @@ -0,0 +1,108 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton <[email protected]> +// + +using System; + +namespace ShiftUI.CarbonInternal { + internal enum WindowClass : uint { + kAlertWindowClass = 1, + kMovableAlertWindowClass = 2, + kModalWindowClass = 3, + kMovableModalWindowClass = 4, + kFloatingWindowClass = 5, + kDocumentWindowClass = 6, + kUtilityWindowClass = 8, + kHelpWindowClass = 10, + kSheetWindowClass = 11, + kToolbarWindowClass = 12, + kPlainWindowClass = 13, + kOverlayWindowClass = 14, + kSheetAlertWindowClass = 15, + kAltPlainWindowClass = 16, + kDrawerWindowClass = 20, + kAllWindowClasses = 0xFFFFFFFF + } + + internal enum WindowAttributes : uint { + kWindowNoAttributes = 0, + kWindowCloseBoxAttribute = (1u << 0), + kWindowHorizontalZoomAttribute = (1u << 1), + kWindowVerticalZoomAttribute = (1u << 2), + kWindowFullZoomAttribute = (kWindowVerticalZoomAttribute | kWindowHorizontalZoomAttribute), + kWindowCollapseBoxAttribute = (1u << 3), + kWindowResizableAttribute = (1u << 4), + kWindowSideTitlebarAttribute = (1u << 5), + kWindowToolbarButtonAttribute = (1u << 6), + kWindowMetalAttribute = (1u << 8), + kWindowNoUpdatesAttribute = (1u << 16), + kWindowNoActivatesAttribute = (1u << 17), + kWindowOpaqueForEventsAttribute = (1u << 18), + kWindowCompositingAttribute = (1u << 19), + kWindowNoShadowAttribute = (1u << 21), + kWindowHideOnSuspendAttribute = (1u << 24), + kWindowStandardHandlerAttribute = (1u << 25), + kWindowHideOnFullScreenAttribute = (1u << 26), + kWindowInWindowMenuAttribute = (1u << 27), + kWindowLiveResizeAttribute = (1u << 28), + kWindowIgnoreClicksAttribute = (1u << 29), + kWindowNoConstrainAttribute = (1u << 31), + kWindowStandardDocumentAttributes = (kWindowCloseBoxAttribute | kWindowFullZoomAttribute | kWindowCollapseBoxAttribute | kWindowResizableAttribute), + kWindowStandardFloatingAttributes = (kWindowCloseBoxAttribute | kWindowCollapseBoxAttribute) + } + + internal enum ThemeCursor : uint { + kThemeArrowCursor = 0, + kThemeCopyArrowCursor = 1, + kThemeAliasArrowCursor = 2, + kThemeContextualMenuArrowCursor = 3, + kThemeIBeamCursor = 4, + kThemeCrossCursor = 5, + kThemePlusCursor = 6, + kThemeWatchCursor = 7, + kThemeClosedHandCursor = 8, + kThemeOpenHandCursor = 9, + kThemePointingHandCursor = 10, + kThemeCountingUpHandCursor = 11, + kThemeCountingDownHandCursor = 12, + kThemeCountingUpAndDownHandCursor = 13, + kThemeSpinningCursor = 14, + kThemeResizeLeftCursor = 15, + kThemeResizeRightCursor = 16, + kThemeResizeLeftRightCursor = 17, + kThemeNotAllowedCursor = 18 + } + + internal enum MouseTrackingResult : ushort { + kMouseTrackingMouseDown = 1, + kMouseTrackingMouseUp = 2, + kMouseTrackingMouseExited = 3, + kMouseTrackingMouseEntered = 4, + kMouseTrackingMouseDragged = 5, + kMouseTrackingKeyModifiersChanged = 6, + kMouseTrackingUserCancelled = 7, + kMouseTrackingTimedOut = 8, + kMouseTrackingMouseMoved = 9 + } +} diff --git a/source/ShiftUI/Internal/EventHandler.cs b/source/ShiftUI/Internal/EventHandler.cs new file mode 100644 index 0000000..673e3d0 --- /dev/null +++ b/source/ShiftUI/Internal/EventHandler.cs @@ -0,0 +1,184 @@ +// 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 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton <[email protected]> +// +// + +using System; +using System.Runtime.InteropServices; + +namespace ShiftUI.CarbonInternal { + internal delegate int EventDelegate (IntPtr callref, IntPtr eventref, IntPtr user_data); + + internal class EventHandler { + internal static EventDelegate EventHandlerDelegate = new EventDelegate (EventCallback); + internal static XplatUICarbon Driver; + + internal const int EVENT_NOT_HANDLED = 0; + internal const int EVENT_HANDLED = -9874; + + internal const uint kEventClassMouse = 1836021107; + internal const uint kEventClassKeyboard = 1801812322; + internal const uint kEventClassTextInput = 1952807028; + internal const uint kEventClassApplication = 1634758764; + internal const uint kEventClassAppleEvent = 1701867619; + internal const uint kEventClassMenu = 1835363957; + internal const uint kEventClassWindow = 2003398244; + internal const uint kEventClassWidget = 1668183148; + internal const uint kEventClassCommand = 1668113523; + internal const uint kEventClassTablet = 1952607348; + internal const uint kEventClassVolume = 1987013664; + internal const uint kEventClassAppearance = 1634758765; + internal const uint kEventClassService = 1936028278; + internal const uint kEventClassToolbar = 1952604530; + internal const uint kEventClassToolbarItem = 1952606580; + internal const uint kEventClassAccessibility = 1633903461; + internal const uint kEventClassHIObject = 1751740258; + + internal static EventTypeSpec [] HIObjectEvents = new EventTypeSpec [] { + new EventTypeSpec (kEventClassHIObject, HIObjectHandler.kEventHIObjectConstruct), + new EventTypeSpec (kEventClassHIObject, HIObjectHandler.kEventHIObjectInitialize), + new EventTypeSpec (kEventClassHIObject, HIObjectHandler.kEventHIObjectDestruct) + }; + internal static EventTypeSpec [] WidgetEvents = new EventTypeSpec [] { + new EventTypeSpec (kEventClassWidget, WidgetHandler.kEventWidgetBoundsChanged), + new EventTypeSpec (kEventClassWidget, WidgetHandler.kEventWidgetDraw), + new EventTypeSpec (kEventClassWidget, WidgetHandler.kEventWidgetDragEnter), + new EventTypeSpec (kEventClassWidget, WidgetHandler.kEventWidgetDragWithin), + new EventTypeSpec (kEventClassWidget, WidgetHandler.kEventWidgetDragLeave), + new EventTypeSpec (kEventClassWidget, WidgetHandler.kEventWidgetDragReceive), + new EventTypeSpec (kEventClassWidget, WidgetHandler.kEventWidgetGetFocusPart), + new EventTypeSpec (kEventClassWidget, WidgetHandler.kEventWidgetInitialize), + new EventTypeSpec (kEventClassWidget, WidgetHandler.kEventWidgetVisibilityChanged) + }; + + internal static EventTypeSpec [] ApplicationEvents = new EventTypeSpec[] { + new EventTypeSpec (kEventClassApplication, ApplicationHandler.kEventAppActivated), + new EventTypeSpec (kEventClassApplication, ApplicationHandler.kEventAppDeactivated) + }; + + private static EventTypeSpec [] WindowEvents = new EventTypeSpec[] { + new EventTypeSpec (kEventClassMouse, MouseHandler.kEventMouseMoved), + new EventTypeSpec (kEventClassMouse, MouseHandler.kEventMouseDragged), + new EventTypeSpec (kEventClassMouse, MouseHandler.kEventMouseDown), + new EventTypeSpec (kEventClassMouse, MouseHandler.kEventMouseUp), + new EventTypeSpec (kEventClassMouse, MouseHandler.kEventMouseWheelMoved), + new EventTypeSpec (kEventClassMouse, MouseHandler.kEventMouseScroll), + + new EventTypeSpec (kEventClassWindow, WindowHandler.kEventWindowDeactivated), + new EventTypeSpec (kEventClassWindow, WindowHandler.kEventWindowActivated), + new EventTypeSpec (kEventClassWindow, WindowHandler.kEventWindowDeactivated), + new EventTypeSpec (kEventClassWindow, WindowHandler.kEventWindowCollapsed), + new EventTypeSpec (kEventClassWindow, WindowHandler.kEventWindowCollapsing), + new EventTypeSpec (kEventClassWindow, WindowHandler.kEventWindowExpanded), + new EventTypeSpec (kEventClassWindow, WindowHandler.kEventWindowExpanding), + new EventTypeSpec (kEventClassWindow, WindowHandler.kEventWindowBoundsChanged), + new EventTypeSpec (kEventClassWindow, WindowHandler.kEventWindowResizeStarted), + new EventTypeSpec (kEventClassWindow, WindowHandler.kEventWindowResizeCompleted), + new EventTypeSpec (kEventClassWindow, WindowHandler.kEventWindowClose), + new EventTypeSpec (kEventClassWindow, WindowHandler.kEventWindowShown), + + new EventTypeSpec (kEventClassKeyboard, KeyboardHandler.kEventRawKeyModifiersChanged), + new EventTypeSpec (kEventClassKeyboard, KeyboardHandler.kEventRawKeyDown), + new EventTypeSpec (kEventClassKeyboard, KeyboardHandler.kEventRawKeyRepeat), + new EventTypeSpec (kEventClassKeyboard, KeyboardHandler.kEventRawKeyUp), + new EventTypeSpec (kEventClassTextInput, KeyboardHandler.kEventTextInputUnicodeForKeyEvent) + }; + + internal static int EventCallback (IntPtr callref, IntPtr eventref, IntPtr handle) { + uint klass = GetEventClass (eventref); + uint kind = GetEventKind (eventref); + MSG msg = new MSG (); + IEventHandler handler = null; + + switch (klass) { + case kEventClassHIObject: { + handler = (IEventHandler) Driver.HIObjectHandler; + break; + } + case kEventClassKeyboard: + case kEventClassTextInput: + handler = (IEventHandler) Driver.KeyboardHandler; + break; + case kEventClassWindow: + handler = (IEventHandler) Driver.WindowHandler; + break; + case kEventClassMouse: + handler = (IEventHandler) Driver.MouseHandler; + break; + case kEventClassWidget: + handler = (IEventHandler) Driver.WidgetHandler; + break; + case kEventClassApplication: + handler = (IEventHandler) Driver.ApplicationHandler; + break; + default: + return EVENT_NOT_HANDLED; + } + + if (handler.ProcessEvent (callref, eventref, handle, kind, ref msg)) { + Driver.EnqueueMessage (msg); + return EVENT_HANDLED; + } + + return EVENT_NOT_HANDLED; + } + + internal static bool TranslateMessage (ref MSG msg) { + bool result = false; + + if (!result) + result = Driver.KeyboardHandler.TranslateMessage (ref msg); + if (!result) + result = Driver.MouseHandler.TranslateMessage (ref msg); + + return result; + } + + internal static void InstallApplicationHandler () { + InstallEventHandler (GetApplicationEventTarget (), EventHandlerDelegate, (uint)ApplicationEvents.Length, ApplicationEvents, IntPtr.Zero, IntPtr.Zero); + } + + internal static void InstallWidgetHandler (IntPtr Widget) { + InstallEventHandler (GetWidgetEventTarget (Widget), EventHandlerDelegate, (uint)WidgetEvents.Length, WidgetEvents, Widget, IntPtr.Zero); + } + + internal static void InstallWindowHandler (IntPtr window) { + InstallEventHandler (GetWindowEventTarget (window), EventHandlerDelegate, (uint)WindowEvents.Length, WindowEvents, window, IntPtr.Zero); + } + + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern IntPtr GetApplicationEventTarget (); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal static extern IntPtr GetWidgetEventTarget (IntPtr Widget); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal static extern IntPtr GetWindowEventTarget (IntPtr window); + + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal static extern uint GetEventClass (IntPtr eventref); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern uint GetEventKind (IntPtr eventref); + + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int InstallEventHandler (IntPtr window, EventDelegate event_handler, uint count, EventTypeSpec [] types, IntPtr user_data, IntPtr handlerref); + } +} diff --git a/source/ShiftUI/Internal/EventHandlerBase.cs b/source/ShiftUI/Internal/EventHandlerBase.cs new file mode 100644 index 0000000..39bada4 --- /dev/null +++ b/source/ShiftUI/Internal/EventHandlerBase.cs @@ -0,0 +1,40 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton <[email protected]> +// +// + +using System; + +namespace ShiftUI.CarbonInternal { + internal abstract class EventHandlerBase { + internal XplatUICarbon Driver; + + public EventHandlerBase () { + } + + public EventHandlerBase (XplatUICarbon driver) { + Driver = driver; + } + } +} diff --git a/source/ShiftUI/Internal/FixedSizeTextBox.cs b/source/ShiftUI/Internal/FixedSizeTextBox.cs new file mode 100644 index 0000000..33b5dff --- /dev/null +++ b/source/ShiftUI/Internal/FixedSizeTextBox.cs @@ -0,0 +1,47 @@ +// 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) 2006 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) +// +// + +// This is an internal class that allows us to use a textbox as a child control +// for things such as UpDown Widgets, and the ComboBox that will not have their +// size altered by scaling + +namespace ShiftUI { + + internal class FixedSizeTextBox : TextBox { + + public FixedSizeTextBox () + { + SetStyle (Widgetstyles.FixedWidth, true); + SetStyle (Widgetstyles.FixedHeight, true); + } + + public FixedSizeTextBox (bool fixed_horz, bool fixed_vert) { + SetStyle (Widgetstyles.FixedWidth, fixed_horz); + SetStyle (Widgetstyles.FixedHeight, fixed_vert); + } + } +} + diff --git a/source/ShiftUI/Internal/FlowLayout.cs b/source/ShiftUI/Internal/FlowLayout.cs new file mode 100644 index 0000000..5eb55a5 --- /dev/null +++ b/source/ShiftUI/Internal/FlowLayout.cs @@ -0,0 +1,589 @@ +// +// FlowLayout.cs +// +// 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) 2006 Jonathan Pobst +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +using System; +using System.Collections.Generic; +using System.Drawing; + +namespace ShiftUI.Layout +{ + class FlowLayout : LayoutEngine + { + private static FlowLayoutSettings default_settings = new FlowLayoutSettings (); + + public FlowLayout () + { + } + + public override void InitLayout (object child, BoundsSpecified specified) + { + base.InitLayout (child, specified); + } + + public override bool Layout (object container, LayoutEventArgs args) + { + if (container is ToolStripPanel) + return false; + + if (container is ToolStrip) + return LayoutToolStrip ((ToolStrip)container); + + Widget parent = container as Widget; + + FlowLayoutSettings settings; + if (parent is FlowLayoutPanel) + settings = (parent as FlowLayoutPanel).LayoutSettings; + else + settings = default_settings; + + // Nothing to layout, exit method + if (parent.Widgets.Count == 0) return false; + + // Use DisplayRectangle so that parent.Padding is honored. + Rectangle parentDisplayRectangle = parent.DisplayRectangle; + Point currentLocation; + + // Set our starting point based on flow direction + switch (settings.FlowDirection) { + case FlowDirection.BottomUp: + currentLocation = new Point (parentDisplayRectangle.Left, parentDisplayRectangle.Bottom); + break; + case FlowDirection.LeftToRight: + case FlowDirection.TopDown: + default: + currentLocation = parentDisplayRectangle.Location; + break; + case FlowDirection.RightToLeft: + currentLocation = new Point (parentDisplayRectangle.Right, parentDisplayRectangle.Top); + break; + } + + bool forceFlowBreak = false; + + List<Widget> rowWidgets = new List<Widget> (); + + foreach (Widget c in parent.Widgets) { + // Only apply layout to visible Widgets. + if (!c.Visible) { continue; } + + // Resize any AutoSize Widgets to their preferred size + if (c.AutoSize == true) { + Size new_size = c.GetPreferredSize (c.Size); + c.SetBoundsInternal (c.Left, c.Top, new_size.Width, new_size.Height, BoundsSpecified.None); + } + + switch (settings.FlowDirection) { + case FlowDirection.BottomUp: + // Decide if it's time to start a new column + // - Our settings must be WrapContents, and we ran out of room or the previous Widget's FlowBreak == true + if (settings.WrapContents) + if ((currentLocation.Y) < (c.Height + c.Margin.Top + c.Margin.Bottom) || forceFlowBreak) { + + currentLocation.X = FinishColumn (rowWidgets); + currentLocation.Y = parentDisplayRectangle.Bottom; + + forceFlowBreak = false; + rowWidgets.Clear (); + } + + // Offset the right margin and set the Widget to our point + currentLocation.Offset (0, c.Margin.Bottom * -1); + c.SetBoundsInternal (currentLocation.X + c.Margin.Left, currentLocation.Y - c.Height, c.Width, c.Height, BoundsSpecified.None); + + // Update our location pointer + currentLocation.Y -= (c.Height + c.Margin.Top); + break; + case FlowDirection.LeftToRight: + default: + // Decide if it's time to start a new row + // - Our settings must be WrapContents, and we ran out of room or the previous Widget's FlowBreak == true + if (settings.WrapContents && !(parent is ToolStripPanel)) + if ((parentDisplayRectangle.Width + parentDisplayRectangle.Left - currentLocation.X) < (c.Width + c.Margin.Left + c.Margin.Right) || forceFlowBreak) { + + currentLocation.Y = FinishRow (rowWidgets); + currentLocation.X = parentDisplayRectangle.Left; + + forceFlowBreak = false; + rowWidgets.Clear (); + } + + // Offset the left margin and set the Widget to our point + currentLocation.Offset (c.Margin.Left, 0); + c.SetBoundsInternal (currentLocation.X, currentLocation.Y + c.Margin.Top, c.Width, c.Height, BoundsSpecified.None); + + // Update our location pointer + currentLocation.X += c.Width + c.Margin.Right; + break; + case FlowDirection.RightToLeft: + // Decide if it's time to start a new row + // - Our settings must be WrapContents, and we ran out of room or the previous Widget's FlowBreak == true + if (settings.WrapContents) + if ((currentLocation.X) < (c.Width + c.Margin.Left + c.Margin.Right) || forceFlowBreak) { + + currentLocation.Y = FinishRow (rowWidgets); + currentLocation.X = parentDisplayRectangle.Right; + + forceFlowBreak = false; + rowWidgets.Clear (); + } + + // Offset the right margin and set the Widget to our point + currentLocation.Offset (c.Margin.Right * -1, 0); + c.SetBoundsInternal (currentLocation.X - c.Width, currentLocation.Y + c.Margin.Top, c.Width, c.Height, BoundsSpecified.None); + + // Update our location pointer + currentLocation.X -= (c.Width + c.Margin.Left); + break; + case FlowDirection.TopDown: + // Decide if it's time to start a new column + // - Our settings must be WrapContents, and we ran out of room or the previous Widget's FlowBreak == true + if (settings.WrapContents) + if ((parentDisplayRectangle.Height + parentDisplayRectangle.Top - currentLocation.Y) < (c.Height + c.Margin.Top + c.Margin.Bottom) || forceFlowBreak) { + + currentLocation.X = FinishColumn (rowWidgets); + currentLocation.Y = parentDisplayRectangle.Top; + + forceFlowBreak = false; + rowWidgets.Clear (); + } + + // Offset the top margin and set the Widget to our point + currentLocation.Offset (0, c.Margin.Top); + c.SetBoundsInternal (currentLocation.X + c.Margin.Left, currentLocation.Y, c.Width, c.Height, BoundsSpecified.None); + + // Update our location pointer + currentLocation.Y += c.Height + c.Margin.Bottom; + break; + } + // Add it to our list of things to adjust the second dimension of + rowWidgets.Add (c); + + // If user set a flowbreak on this Widget, it will be the last one in this row/column + if (settings.GetFlowBreak (c)) + forceFlowBreak = true; + } + + // Set the Widget heights/widths for the last row/column + if (settings.FlowDirection == FlowDirection.LeftToRight || settings.FlowDirection == FlowDirection.RightToLeft) + FinishRow (rowWidgets); + else + FinishColumn (rowWidgets); + + return false; + } + + // Calculate the heights of the Widgets, returns the y coordinate of the greatest height it uses + private int FinishRow (List<Widget> row) + { + // Nothing to do + if (row.Count == 0) return 0; + + int rowTop = int.MaxValue; + int rowBottom = 0; + bool allDockFill = true; + bool noAuto = true; + + // Special semantics if all Widgets are Dock.Fill/Anchor:Top,Bottom or AutoSize = true + foreach (Widget c in row) { + if (c.Dock != DockStyle.Fill && !((c.Anchor & AnchorStyles.Top) == AnchorStyles.Top && (c.Anchor & AnchorStyles.Bottom) == AnchorStyles.Bottom)) + allDockFill = false; + if (c.AutoSize == true) + noAuto = false; + } + + // Find the tallest Widget with a concrete height + foreach (Widget c in row) { + if (c.Bottom + c.Margin.Bottom > rowBottom && (c.Dock != DockStyle.Fill) && ((c.Anchor & AnchorStyles.Top) != AnchorStyles.Top || (c.Anchor & AnchorStyles.Bottom) != AnchorStyles.Bottom || c.AutoSize == true)) + rowBottom = c.Bottom + c.Margin.Bottom; + if (c.Top - c.Margin.Top < rowTop) + rowTop = c.Top - c.Margin.Top; + } + + // Find the tallest Widget that is AutoSize = true + if (rowBottom == 0) + foreach (Widget c in row) + if (c.Bottom + c.Margin.Bottom > rowBottom && (c.Dock != DockStyle.Fill && c.AutoSize == true)) + rowBottom = c.Bottom + c.Margin.Bottom; + + // Find the tallest Widget that is Dock = Fill + if (rowBottom == 0) + foreach (Widget c in row) + if (c.Bottom + c.Margin.Bottom > rowBottom && (c.Dock == DockStyle.Fill)) + rowBottom = c.Bottom + c.Margin.Bottom; + + // Set the new heights for each Widget + foreach (Widget c in row) + if (allDockFill && noAuto) + c.SetBoundsInternal (c.Left, c.Top, c.Width, 0, BoundsSpecified.None); + else if (c.Dock == DockStyle.Fill || ((c.Anchor & AnchorStyles.Top) == AnchorStyles.Top) && ((c.Anchor & AnchorStyles.Bottom) == AnchorStyles.Bottom)) + c.SetBoundsInternal (c.Left, c.Top, c.Width, rowBottom - c.Top - c.Margin.Bottom, BoundsSpecified.None); + else if (c.Dock == DockStyle.Bottom || ((c.Anchor & AnchorStyles.Bottom) == AnchorStyles.Bottom)) + c.SetBoundsInternal (c.Left, rowBottom - c.Margin.Bottom - c.Height, c.Width, c.Height, BoundsSpecified.None); + else if (c.Dock == DockStyle.Top || ((c.Anchor & AnchorStyles.Top) == AnchorStyles.Top)) + continue; + else + c.SetBoundsInternal (c.Left, ((rowBottom - rowTop) / 2) - (c.Height / 2) + (int)Math.Floor (((c.Margin.Top - c.Margin.Bottom) / 2.0)) + rowTop, c.Width, c.Height, BoundsSpecified.None); + + // Return bottom y of this row used + if (rowBottom == 0) + return rowTop; + + return rowBottom; + } + + // Calculate the widths of the Widgets, returns the x coordinate of the greatest width it uses + private int FinishColumn (List<Widget> col) + { + // Nothing to do + if (col.Count == 0) return 0; + + int rowLeft = int.MaxValue; + int rowRight = 0; + bool allDockFill = true; + bool noAuto = true; + + // Special semantics if all Widgets are Dock.Fill/Anchor:Left,Right or AutoSize = true + foreach (Widget c in col) { + if (c.Dock != DockStyle.Fill && !((c.Anchor & AnchorStyles.Left) == AnchorStyles.Left && (c.Anchor & AnchorStyles.Right) == AnchorStyles.Right)) + allDockFill = false; + if (c.AutoSize == true) + noAuto = false; + } + + // Find the widest Widget with a concrete width + foreach (Widget c in col) { + if (c.Right + c.Margin.Right > rowRight && (c.Dock != DockStyle.Fill) && ((c.Anchor & AnchorStyles.Left) != AnchorStyles.Left || (c.Anchor & AnchorStyles.Right) != AnchorStyles.Right || c.AutoSize == true)) + rowRight = c.Right + c.Margin.Right; + if (c.Left - c.Margin.Left < rowLeft) + rowLeft = c.Left - c.Margin.Left; + } + + // Find the widest Widget that is AutoSize = true + if (rowRight == 0) + foreach (Widget c in col) + if (c.Right + c.Margin.Right > rowRight && (c.Dock != DockStyle.Fill && c.AutoSize == true)) + rowRight = c.Right + c.Margin.Right; + + // Find the widest Widget that is Dock = Fill + if (rowRight == 0) + foreach (Widget c in col) + if (c.Right + c.Margin.Right > rowRight && (c.Dock == DockStyle.Fill)) + rowRight = c.Right + c.Margin.Right; + + // Set the new widths for each Widget + foreach (Widget c in col) + if (allDockFill && noAuto) + c.SetBoundsInternal (c.Left, c.Top, 0, c.Height, BoundsSpecified.None); + else if (c.Dock == DockStyle.Fill || ((c.Anchor & AnchorStyles.Left) == AnchorStyles.Left) && ((c.Anchor & AnchorStyles.Right) == AnchorStyles.Right)) + c.SetBoundsInternal (c.Left, c.Top, rowRight - c.Left - c.Margin.Right, c.Height, BoundsSpecified.None); + else if (c.Dock == DockStyle.Right || ((c.Anchor & AnchorStyles.Right) == AnchorStyles.Right)) + c.SetBoundsInternal (rowRight - c.Margin.Right - c.Width, c.Top, c.Width, c.Height, BoundsSpecified.None); + else if (c.Dock == DockStyle.Left || ((c.Anchor & AnchorStyles.Left) == AnchorStyles.Left)) + continue; + else + c.SetBoundsInternal (((rowRight - rowLeft) / 2) - (c.Width / 2) + (int)Math.Floor (((c.Margin.Left - c.Margin.Right) / 2.0)) + rowLeft, c.Top, c.Width, c.Height, BoundsSpecified.None); + + // Return rightmost x of this row used + if (rowRight == 0) + return rowLeft; + + return rowRight; + } + + #region Layout for ToolStrip + // ToolStrips use the same FlowLayout, but is made up of ToolStripItems which + // are Components instead of Widgets, so we have to duplicate this login for + // ToolStripItems. + private bool LayoutToolStrip (ToolStrip parent) + { + FlowLayoutSettings settings; + settings = (FlowLayoutSettings)parent.LayoutSettings; + + // Nothing to layout, exit method + if (parent.Items.Count == 0) return false; + + foreach (ToolStripItem tsi in parent.Items) + tsi.SetPlacement (ToolStripItemPlacement.Main); + + // Use DisplayRectangle so that parent.Padding is honored. + Rectangle parentDisplayRectangle = parent.DisplayRectangle; + Point currentLocation; + + // Set our starting point based on flow direction + switch (settings.FlowDirection) { + case FlowDirection.BottomUp: + currentLocation = new Point (parentDisplayRectangle.Left, parentDisplayRectangle.Bottom); + break; + case FlowDirection.LeftToRight: + case FlowDirection.TopDown: + default: + currentLocation = parentDisplayRectangle.Location; + break; + case FlowDirection.RightToLeft: + currentLocation = new Point (parentDisplayRectangle.Right, parentDisplayRectangle.Top); + break; + } + + bool forceFlowBreak = false; + + List<ToolStripItem> rowWidgets = new List<ToolStripItem> (); + + foreach (ToolStripItem c in parent.Items) { + // Only apply layout to visible Widgets. + if (!c.Available) { continue; } + + // Resize any AutoSize Widgets to their preferred size + if (c.AutoSize == true) + c.SetBounds (new Rectangle (c.Location, c.GetPreferredSize (c.Size))); + + switch (settings.FlowDirection) { + case FlowDirection.BottomUp: + // Decide if it's time to start a new column + // - Our settings must be WrapContents, and we ran out of room or the previous Widget's FlowBreak == true + if (settings.WrapContents) + if ((currentLocation.Y) < (c.Height + c.Margin.Top + c.Margin.Bottom) || forceFlowBreak) { + + currentLocation.X = FinishColumn (rowWidgets); + currentLocation.Y = parentDisplayRectangle.Bottom; + + forceFlowBreak = false; + rowWidgets.Clear (); + } + + // Offset the right margin and set the Widget to our point + currentLocation.Offset (0, c.Margin.Bottom * -1); + c.Location = new Point (currentLocation.X + c.Margin.Left, currentLocation.Y - c.Height); + + // Update our location pointer + currentLocation.Y -= (c.Height + c.Margin.Top); + break; + case FlowDirection.LeftToRight: + default: + // Decide if it's time to start a new row + // - Our settings must be WrapContents, and we ran out of room or the previous Widget's FlowBreak == true + if (settings.WrapContents) + if ((parentDisplayRectangle.Width - currentLocation.X) < (c.Width + c.Margin.Left + c.Margin.Right) || forceFlowBreak) { + + currentLocation.Y = FinishRow (rowWidgets); + currentLocation.X = parentDisplayRectangle.Left; + + forceFlowBreak = false; + rowWidgets.Clear (); + } + + // Offset the left margin and set the Widget to our point + currentLocation.Offset (c.Margin.Left, 0); + c.Location = new Point (currentLocation.X, currentLocation.Y + c.Margin.Top); + + // Update our location pointer + currentLocation.X += c.Width + c.Margin.Right; + break; + case FlowDirection.RightToLeft: + // Decide if it's time to start a new row + // - Our settings must be WrapContents, and we ran out of room or the previous Widget's FlowBreak == true + if (settings.WrapContents) + if ((currentLocation.X) < (c.Width + c.Margin.Left + c.Margin.Right) || forceFlowBreak) { + + currentLocation.Y = FinishRow (rowWidgets); + currentLocation.X = parentDisplayRectangle.Right; + + forceFlowBreak = false; + rowWidgets.Clear (); + } + + // Offset the right margin and set the Widget to our point + currentLocation.Offset (c.Margin.Right * -1, 0); + c.Location = new Point (currentLocation.X - c.Width, currentLocation.Y + c.Margin.Top); + + // Update our location pointer + currentLocation.X -= (c.Width + c.Margin.Left); + break; + case FlowDirection.TopDown: + // Decide if it's time to start a new column + // - Our settings must be WrapContents, and we ran out of room or the previous Widget's FlowBreak == true + if (settings.WrapContents) + if ((parentDisplayRectangle.Height - currentLocation.Y) < (c.Height + c.Margin.Top + c.Margin.Bottom) || forceFlowBreak) { + + currentLocation.X = FinishColumn (rowWidgets); + currentLocation.Y = parentDisplayRectangle.Top; + + forceFlowBreak = false; + rowWidgets.Clear (); + } + + // Offset the top margin and set the Widget to our point + currentLocation.Offset (0, c.Margin.Top); + c.Location = new Point (currentLocation.X + c.Margin.Left, currentLocation.Y); + + // Update our location pointer + currentLocation.Y += c.Height + c.Margin.Bottom; + break; + } + // Add it to our list of things to adjust the second dimension of + rowWidgets.Add (c); + + // If user set a flowbreak on this Widget, it will be the last one in this row/column + if (settings.GetFlowBreak (c)) + forceFlowBreak = true; + } + + int final_height = 0; + + // Set the Widget heights/widths for the last row/column + if (settings.FlowDirection == FlowDirection.LeftToRight || settings.FlowDirection == FlowDirection.RightToLeft) + final_height = FinishRow (rowWidgets); + else + FinishColumn (rowWidgets); + + if (final_height > 0) + parent.SetBoundsInternal (parent.Left, parent.Top, parent.Width, final_height + parent.Padding.Bottom, BoundsSpecified.None); + + return false; + + } + + // Calculate the heights of the Widgets, returns the y coordinate of the greatest height it uses + private int FinishRow (List<ToolStripItem> row) + { + // Nothing to do + if (row.Count == 0) return 0; + + int rowTop = int.MaxValue; + int rowBottom = 0; + bool allDockFill = true; + bool noAuto = true; + + // Special semantics if all Widgets are Dock.Fill/Anchor:Top,Bottom or AutoSize = true + foreach (ToolStripItem c in row) { + if (c.Dock != DockStyle.Fill && !((c.Anchor & AnchorStyles.Top) == AnchorStyles.Top && (c.Anchor & AnchorStyles.Bottom) == AnchorStyles.Bottom)) + allDockFill = false; + if (c.AutoSize == true) + noAuto = false; + } + + // Find the tallest Widget with a concrete height + foreach (ToolStripItem c in row) { + if (c.Bottom + c.Margin.Bottom > rowBottom && (c.Dock != DockStyle.Fill) && ((c.Anchor & AnchorStyles.Top) != AnchorStyles.Top || (c.Anchor & AnchorStyles.Bottom) != AnchorStyles.Bottom || c.AutoSize == true)) + rowBottom = c.Bottom + c.Margin.Bottom; + if (c.Top - c.Margin.Top < rowTop) + rowTop = c.Top - c.Margin.Top; + } + + // Find the tallest Widget that is AutoSize = true + if (rowBottom == 0) + foreach (ToolStripItem c in row) + if (c.Bottom + c.Margin.Bottom > rowBottom && (c.Dock != DockStyle.Fill && c.AutoSize == true)) + rowBottom = c.Bottom + c.Margin.Bottom; + + // Find the tallest Widget that is Dock = Fill + if (rowBottom == 0) + foreach (ToolStripItem c in row) + if (c.Bottom + c.Margin.Bottom > rowBottom && (c.Dock == DockStyle.Fill)) + rowBottom = c.Bottom + c.Margin.Bottom; + + // Set the new heights for each Widget + foreach (ToolStripItem c in row) + if (allDockFill && noAuto) + c.Height = 0; + else if (c.Dock == DockStyle.Fill || ((c.Anchor & AnchorStyles.Top) == AnchorStyles.Top) && ((c.Anchor & AnchorStyles.Bottom) == AnchorStyles.Bottom)) + c.Height = rowBottom - c.Top - c.Margin.Bottom; + else if (c.Dock == DockStyle.Bottom || ((c.Anchor & AnchorStyles.Bottom) == AnchorStyles.Bottom)) + c.Top = rowBottom - c.Margin.Bottom - c.Height; + else if (c.Dock == DockStyle.Top || ((c.Anchor & AnchorStyles.Top) == AnchorStyles.Top)) + continue; + else + c.Top = ((rowBottom - rowTop) / 2) - (c.Height / 2) + (int)Math.Floor (((c.Margin.Top - c.Margin.Bottom) / 2.0)) + rowTop; + + // Return bottom y of this row used + if (rowBottom == 0) + return rowTop; + + return rowBottom; + } + + // Calculate the widths of the Widgets, returns the x coordinate of the greatest width it uses + private int FinishColumn (List<ToolStripItem> col) + { + // Nothing to do + if (col.Count == 0) return 0; + + int rowLeft = int.MaxValue; + int rowRight = 0; + bool allDockFill = true; + bool noAuto = true; + + // Special semantics if all Widgets are Dock.Fill/Anchor:Left,Right or AutoSize = true + foreach (ToolStripItem c in col) { + if (c.Dock != DockStyle.Fill && !((c.Anchor & AnchorStyles.Left) == AnchorStyles.Left && (c.Anchor & AnchorStyles.Right) == AnchorStyles.Right)) + allDockFill = false; + if (c.AutoSize == true) + noAuto = false; + } + + // Find the widest Widget with a concrete width + foreach (ToolStripItem c in col) { + if (c.Right + c.Margin.Right > rowRight && (c.Dock != DockStyle.Fill) && ((c.Anchor & AnchorStyles.Left) != AnchorStyles.Left || (c.Anchor & AnchorStyles.Right) != AnchorStyles.Right || c.AutoSize == true)) + rowRight = c.Right + c.Margin.Right; + if (c.Left - c.Margin.Left < rowLeft) + rowLeft = c.Left - c.Margin.Left; + } + + // Find the widest Widget that is AutoSize = true + if (rowRight == 0) + foreach (ToolStripItem c in col) + if (c.Right + c.Margin.Right > rowRight && (c.Dock != DockStyle.Fill && c.AutoSize == true)) + rowRight = c.Right + c.Margin.Right; + + // Find the widest Widget that is Dock = Fill + if (rowRight == 0) + foreach (ToolStripItem c in col) + if (c.Right + c.Margin.Right > rowRight && (c.Dock == DockStyle.Fill)) + rowRight = c.Right + c.Margin.Right; + + // Set the new widths for each Widget + foreach (ToolStripItem c in col) + if (allDockFill && noAuto) + c.Width = 0; + else if (c.Dock == DockStyle.Fill || ((c.Anchor & AnchorStyles.Left) == AnchorStyles.Left) && ((c.Anchor & AnchorStyles.Right) == AnchorStyles.Right)) + c.Width = rowRight - c.Left - c.Margin.Right; + else if (c.Dock == DockStyle.Right || ((c.Anchor & AnchorStyles.Right) == AnchorStyles.Right)) + c.Left = rowRight - c.Margin.Right - c.Width; + else if (c.Dock == DockStyle.Left || ((c.Anchor & AnchorStyles.Left) == AnchorStyles.Left)) + continue; + else + c.Left = ((rowRight - rowLeft) / 2) - (c.Width / 2) + (int)Math.Floor (((c.Margin.Left - c.Margin.Right) / 2.0)) + rowLeft; + + // Return rightmost x of this row used + if (rowRight == 0) + return rowLeft; + + return rowRight; + } + #endregion + } +} diff --git a/source/ShiftUI/Internal/FlowLayoutSettings.cs b/source/ShiftUI/Internal/FlowLayoutSettings.cs new file mode 100644 index 0000000..3480165 --- /dev/null +++ b/source/ShiftUI/Internal/FlowLayoutSettings.cs @@ -0,0 +1,111 @@ +// +// FlowLayoutSettings.cs +// +// 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) 2006 Jonathan Pobst +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +using ShiftUI.Layout; +using System.ComponentModel; +using System.Collections.Generic; +using System; + +namespace ShiftUI +{ + [DefaultProperty ("FlowDirection")] + public class FlowLayoutSettings : LayoutSettings + { + private FlowDirection flow_direction; + private bool wrap_contents; + private LayoutEngine layout_engine; + private Dictionary<object, bool> flow_breaks; + private Widget owner; + + internal FlowLayoutSettings () : this (null) + { + } + + internal FlowLayoutSettings (Widget owner) + { + flow_breaks = new Dictionary<object, bool> (); + wrap_contents = true; + flow_direction = FlowDirection.LeftToRight; + this.owner = owner; + } + + #region Public Properties + [DefaultValue (FlowDirection.LeftToRight)] + public FlowDirection FlowDirection { + get { return this.flow_direction; } + set { + if (this.flow_direction != value) { + this.flow_direction = value; + if (owner != null) + owner.PerformLayout (owner, "FlowDirection"); + } + } + } + + public override LayoutEngine LayoutEngine { + get { + if (this.layout_engine == null) + this.layout_engine = new FlowLayout (); + + return this.layout_engine; + } + } + + [DefaultValue (true)] + public bool WrapContents { + get { return this.wrap_contents; } + set { + if (this.wrap_contents != value) { + this.wrap_contents = value; + if (owner != null) + owner.PerformLayout (owner, "WrapContents"); + } + } + } + #endregion + + #region Public Methods + public bool GetFlowBreak (Object child) + { + bool retval; + + if (flow_breaks.TryGetValue (child, out retval)) + return retval; + + return false; + } + + public void SetFlowBreak (Object child, bool value) + { + flow_breaks[child] = value; + if (owner != null) + owner.PerformLayout ((Widget)child, "FlowBreak"); + } + #endregion + } +} diff --git a/source/ShiftUI/Internal/GetChildAtPointSkip.cs b/source/ShiftUI/Internal/GetChildAtPointSkip.cs new file mode 100644 index 0000000..963406c --- /dev/null +++ b/source/ShiftUI/Internal/GetChildAtPointSkip.cs @@ -0,0 +1,41 @@ +// +// GetChildAtPointSkip.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// +using System; + + +namespace ShiftUI +{ + [Flags] + public enum GetChildAtPointSkip + { + None = 0, + Invisible = 1, + Disabled = 2, + Transparent = 4 + } +}
\ No newline at end of file diff --git a/source/ShiftUI/Internal/GridItem.cs b/source/ShiftUI/Internal/GridItem.cs new file mode 100644 index 0000000..3efac21 --- /dev/null +++ b/source/ShiftUI/Internal/GridItem.cs @@ -0,0 +1,114 @@ +// 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) 2004-2005 Novell, Inc. +// +// Authors: +// Jonathan Chambers ([email protected]) +// + +// NOT COMPLETE + +using System; +using System.Drawing; +using System.ComponentModel; + +namespace ShiftUI +{ + public abstract class GridItem + { + #region Fields + private bool expanded; + private object tag; + #endregion Fields + + #region Constructors + protected GridItem() + { + expanded = false; + } + #endregion // Constructors + + #region Public Instance Properties + public virtual bool Expandable + { + get { + return GridItems.Count > 1; + } + } + + public virtual bool Expanded + { + get { + return expanded; + } + + set { + expanded = value; + } + } + + public abstract GridItemCollection GridItems + { + get; + } + + public abstract GridItemType GridItemType + { + get; + } + + public abstract string Label + { + get; + } + + + public abstract GridItem Parent + { + get; + } + + + public abstract PropertyDescriptor PropertyDescriptor + { + get; + } + + [Localizable (false)] + [Bindable (true)] + [DefaultValue (null)] + [TypeConverter (typeof (StringConverter))] + public Object Tag { + get { return this.tag; } + set { this.tag = value; } + } + + public abstract object Value + { + get; + set; + } + #endregion + + #region Public Instance Methods + public abstract bool Select (); + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/GridItemType.cs b/source/ShiftUI/Internal/GridItemType.cs new file mode 100644 index 0000000..821626a --- /dev/null +++ b/source/ShiftUI/Internal/GridItemType.cs @@ -0,0 +1,38 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jonathan Chambers ([email protected]) +// + +// COMPLETE + +namespace ShiftUI +{ + public enum GridItemType + { + Property = 0, + Category = 1, + ArrayValue = 2, + Root = 3 + } +} + diff --git a/source/ShiftUI/Internal/GroupBoxRenderer.cs b/source/ShiftUI/Internal/GroupBoxRenderer.cs new file mode 100644 index 0000000..c0c9699 --- /dev/null +++ b/source/ShiftUI/Internal/GroupBoxRenderer.cs @@ -0,0 +1,157 @@ +// +// GroupBoxRenderer.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +using System.Drawing; +using ShiftUI.VisualStyles; +using System; + +namespace ShiftUI +{ + public sealed class GroupBoxRenderer + { + private static bool always_use_visual_styles = false; + + #region Private Constructor + private GroupBoxRenderer () { } + #endregion + + #region Public Static Methods + public static void DrawGroupBox (Graphics g, Rectangle bounds, GroupBoxState state) + { + DrawGroupBox (g, bounds, String.Empty, null, Color.Empty, TextFormatFlags.Default, state); + } + + public static void DrawGroupBox (Graphics g, Rectangle bounds, string groupBoxText, Font font, GroupBoxState state) + { + DrawGroupBox (g, bounds, groupBoxText, font, Color.Empty, TextFormatFlags.Default, state); + } + + public static void DrawGroupBox (Graphics g, Rectangle bounds, string groupBoxText, Font font, Color textColor, GroupBoxState state) + { + DrawGroupBox (g, bounds, groupBoxText, font, textColor, TextFormatFlags.Default, state); + } + + public static void DrawGroupBox (Graphics g, Rectangle bounds, string groupBoxText, Font font, TextFormatFlags flags, GroupBoxState state) + { + DrawGroupBox (g, bounds, groupBoxText, font, Color.Empty, flags, state); + } + + public static void DrawGroupBox (Graphics g, Rectangle bounds, string groupBoxText, Font font, Color textColor, TextFormatFlags flags, GroupBoxState state) + { + Size font_size = TextRenderer.MeasureText (groupBoxText, font); + + if (Application.RenderWithVisualStyles || always_use_visual_styles == true) { + VisualStyleRenderer vsr; + Rectangle new_bounds; + + switch (state) { + case GroupBoxState.Normal: + default: + vsr = new VisualStyleRenderer (VisualStyleElement.Button.GroupBox.Normal); + new_bounds = new Rectangle (bounds.Left, bounds.Top + (int)(font_size.Height / 2) - 1, bounds.Width, bounds.Height - (int)(font_size.Height / 2) + 1); + break; + case GroupBoxState.Disabled: + vsr = new VisualStyleRenderer (VisualStyleElement.Button.GroupBox.Disabled); + new_bounds = new Rectangle (bounds.Left, bounds.Top + (int)(font_size.Height / 2) - 2, bounds.Width, bounds.Height - (int)(font_size.Height / 2) + 2); + break; + } + + if (groupBoxText == String.Empty) + vsr.DrawBackground (g, bounds); + else + vsr.DrawBackgroundExcludingArea (g, new_bounds, new Rectangle (bounds.Left + 9, bounds.Top, font_size.Width - 3, font_size.Height)); + + if (textColor == Color.Empty) + textColor = vsr.GetColor (ColorProperty.TextColor); + + if (groupBoxText != String.Empty) + TextRenderer.DrawText (g, groupBoxText, font, new Point (bounds.Left + 8, bounds.Top), textColor, flags); + } + else { + // MS has a pretty big bug when rendering the non-visual styles group box. Instead of using the height + // part of the bounds as height, they use it as the bottom, so the boxes are drawn in completely different + // places. Rather than emulate this bug, we do it correctly. After googling for a while, I don't think + // anyone has ever actually used this class for anything, so it should be fine. :) + Rectangle new_bounds = new Rectangle (bounds.Left, bounds.Top + (int)(font_size.Height / 2), bounds.Width, bounds.Height - (int)(font_size.Height / 2)); + + // Don't paint over the background where we are going to put the text + Region old_clip = g.Clip; + g.SetClip (new Rectangle (bounds.Left + 9, bounds.Top, font_size.Width - 3, font_size.Height), System.Drawing.Drawing2D.CombineMode.Exclude); + + WidgetPaint.DrawBorder3D (g, new_bounds, Border3DStyle.Etched); + + g.Clip = old_clip; + + if (groupBoxText != String.Empty) { + if (textColor == Color.Empty) + textColor = state == GroupBoxState.Normal ? SystemColors.ControlText : + SystemColors.GrayText; + TextRenderer.DrawText (g, groupBoxText, font, new Point (bounds.Left + 8, bounds.Top), textColor, flags); + } + } + } + + public static bool IsBackgroundPartiallyTransparent (GroupBoxState state) + { + if (!VisualStyleRenderer.IsSupported) + return false; + + VisualStyleRenderer vsr; + + switch (state) { + case GroupBoxState.Normal: + default: + vsr = new VisualStyleRenderer (VisualStyleElement.Button.GroupBox.Normal); + break; + case GroupBoxState.Disabled: + vsr = new VisualStyleRenderer (VisualStyleElement.Button.GroupBox.Disabled); + break; + } + + return vsr.IsBackgroundPartiallyTransparent (); + } + + public static void DrawParentBackground (Graphics g, Rectangle bounds, Widget childControl) + { + if (!VisualStyleRenderer.IsSupported) + return; + + VisualStyleRenderer vsr = new VisualStyleRenderer (VisualStyleElement.Button.GroupBox.Normal); + + vsr.DrawParentBackground (g, bounds, childControl); + } + #endregion + + #region Public Static Properties + public static bool RenderMatchingApplicationState { + get { return !always_use_visual_styles; } + set { always_use_visual_styles = !value; } + } + #endregion + } +} diff --git a/source/ShiftUI/Internal/HIObjectHandler.cs b/source/ShiftUI/Internal/HIObjectHandler.cs new file mode 100644 index 0000000..ca7adc0 --- /dev/null +++ b/source/ShiftUI/Internal/HIObjectHandler.cs @@ -0,0 +1,57 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton <[email protected]> +// +// + +using System; +using System.Runtime.InteropServices; + +namespace ShiftUI.CarbonInternal { + internal class HIObjectHandler : EventHandlerBase, IEventHandler { + internal const uint kEventHIObjectConstruct = 1; + internal const uint kEventHIObjectInitialize = 2; + internal const uint kEventHIObjectDestruct = 3; + + internal HIObjectHandler (XplatUICarbon driver) : base (driver) {} + + public bool ProcessEvent (IntPtr callref, IntPtr eventref, IntPtr handle, uint kind, ref MSG msg) { + switch (kind) { + case kEventHIObjectConstruct: + IntPtr v = IntPtr.Zero; + GetEventParameter (eventref, (uint)1751740265, (uint)1751740258, IntPtr.Zero, 4, IntPtr.Zero, ref v); + return false; + case kEventHIObjectInitialize: + CallNextEventHandler (callref, eventref); + return false; + case kEventHIObjectDestruct: + return false; + } + return false; + } + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int CallNextEventHandler (IntPtr callref, IntPtr eventref); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int GetEventParameter (IntPtr eventref, uint name, uint type, IntPtr outtype, uint size, IntPtr outsize, ref IntPtr data); + } +} diff --git a/source/ShiftUI/Internal/HScrollProperties.cs b/source/ShiftUI/Internal/HScrollProperties.cs new file mode 100644 index 0000000..4eed2da --- /dev/null +++ b/source/ShiftUI/Internal/HScrollProperties.cs @@ -0,0 +1,33 @@ +// 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. +// +// Authors: +// Olivier Dufour [email protected] +// + +namespace ShiftUI +{ + public class HScrollProperties : ScrollProperties + { + public HScrollProperties (ScrollableWidget container) : base (container) + { + scroll_bar = container.hscrollbar; + } + } +} diff --git a/source/ShiftUI/Internal/Hwnd.cs b/source/ShiftUI/Internal/Hwnd.cs new file mode 100644 index 0000000..fcdc17d --- /dev/null +++ b/source/ShiftUI/Internal/Hwnd.cs @@ -0,0 +1,910 @@ +// 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-2006 Novell, Inc. (http://www.novell.com) +// +// Authors: +// Peter Bartok ([email protected]) +// +// + +// NOT COMPLETE + +using System; +using System.Collections; +using System.Drawing; +using System.Runtime.InteropServices; + +// NOTE: Possible optimization: +// Several properties calculate dimensions on the fly; instead; they can +// be stored in a field and only be recalculated when a style is changed (DefaultClientRect, for example) + +namespace ShiftUI { + internal class Hwnd : IDisposable { + #region Local Variables + private static Hashtable windows = new Hashtable(100, 0.5f); + //private const int menu_height = 14; // FIXME - Read this value from somewhere + + private IntPtr handle; + internal IntPtr client_window; + internal IntPtr whole_window; + internal IntPtr cursor; + internal Menu menu; + internal TitleStyle title_style; + internal FormBorderStyle border_style; + internal bool border_static; + internal int x; + internal int y; + internal int width; + internal int height; + internal bool allow_drop; + internal Hwnd parent; + internal bool visible; + internal bool mapped; + internal uint opacity; + internal bool enabled; + internal bool zero_sized; + internal ArrayList invalid_list; + internal Rectangle nc_invalid; + internal bool expose_pending; + internal bool nc_expose_pending; + internal bool configure_pending; + internal bool resizing_or_moving; // Used by the X11 backend to track form resize/move + internal bool reparented; + internal Stack drawing_stack; + internal object user_data; + internal Rectangle client_rectangle; + internal ArrayList marshal_free_list; + internal int caption_height; + internal int tool_caption_height; + internal bool whacky_wm; + internal bool fixed_size; + internal bool zombie; /* X11 only flag. true if the X windows have been destroyed but we haven't been Disposed */ + internal bool topmost; /* X11 only. */ + internal Region user_clip; + internal XEventQueue queue; + internal WindowExStyles initial_ex_style; + internal WindowStyles initial_style; + internal FormWindowState cached_window_state = (FormWindowState)(-1); /* X11 only field */ + internal Point previous_child_startup_location = new Point (int.MinValue, int.MinValue); + static internal Point previous_main_startup_location = new Point (int.MinValue, int.MinValue); + internal ArrayList children; + + [ThreadStatic] + private static Bitmap bmp; + [ThreadStatic] + private static Graphics bmp_g; + #endregion // Local Variables + + // locks for some operations (used in XplatUIX11.cs) + internal object configure_lock = new object (); + internal object expose_lock = new object (); + + #region Constructors and destructors + public Hwnd() { + x = 0; + y = 0; + width = 0; + height = 0; + visible = false; + menu = null; + border_style = FormBorderStyle.None; + client_window = IntPtr.Zero; + whole_window = IntPtr.Zero; + cursor = IntPtr.Zero; + handle = IntPtr.Zero; + parent = null; + invalid_list = new ArrayList(); + expose_pending = false; + nc_expose_pending = false; + enabled = true; + reparented = false; + client_rectangle = Rectangle.Empty; + marshal_free_list = new ArrayList(2); + opacity = 0xffffffff; + fixed_size = false; + drawing_stack = new Stack (); + children = new ArrayList (); + resizing_or_moving = false; + whacky_wm = false; + topmost = false; + } + + public void Dispose() { + expose_pending = false; + nc_expose_pending = false; + Parent = null; + lock (windows) { + windows.Remove(client_window); + windows.Remove(whole_window); + } + client_window = IntPtr.Zero; + whole_window = IntPtr.Zero; + zombie = false; + for (int i = 0; i < marshal_free_list.Count; i++) { + Marshal.FreeHGlobal((IntPtr)marshal_free_list[i]); + } + marshal_free_list.Clear(); + } + #endregion + + #region Static Methods + public static Hwnd ObjectFromWindow(IntPtr window) { + Hwnd rv; + lock (windows) { + rv = (Hwnd)windows[window]; + } + return rv; + } + + public static Hwnd ObjectFromHandle(IntPtr handle) { + //return (Hwnd)(((GCHandle)handle).Target); + Hwnd rv; + lock (windows) { + rv = (Hwnd)windows[handle]; + } + return rv; + } + + public static IntPtr HandleFromObject(Hwnd obj) { + return obj.handle; + } + + public static Hwnd GetObjectFromWindow(IntPtr window) { + Hwnd rv; + lock (windows) { + rv = (Hwnd)windows[window]; + } + return rv; + } + + public static IntPtr GetHandleFromWindow(IntPtr window) { + Hwnd hwnd; + + lock (windows) { + hwnd = (Hwnd)windows[window]; + } + if (hwnd != null) { + return hwnd.handle; + } else { + return IntPtr.Zero; + } + } + + public static Borders GetBorderWidth (CreateParams cp) + { + Borders border_size = new Borders (); + + Size windowborder = ThemeEngine.Current.BorderSize; /*new Size (1, 1);*/ // This is the only one that can be changed from the display properties in windows. + Size border = ThemeEngine.Current.BorderStaticSize; /*new Size (1, 1);*/ + Size clientedge = ThemeEngine.Current.Border3DSize; /*new Size (2, 2);*/ + Size thickframe = new Size (2 + windowborder.Width, 2 + windowborder.Height); + Size dialogframe = ThemeEngine.Current.BorderSizableSize; /* new Size (3, 3);*/ + + if (cp.IsSet (WindowStyles.WS_CAPTION)) { + border_size.Inflate (dialogframe); + } else if (cp.IsSet (WindowStyles.WS_BORDER)) { + if (cp.IsSet (WindowExStyles.WS_EX_DLGMODALFRAME)) { + if (cp.IsSet (WindowStyles.WS_THICKFRAME) && (cp.IsSet (WindowExStyles.WS_EX_STATICEDGE) || cp.IsSet (WindowExStyles.WS_EX_CLIENTEDGE))) { + border_size.Inflate (border); + } + } else { + border_size.Inflate (border); + } + } else if (cp.IsSet (WindowStyles.WS_DLGFRAME)) { + border_size.Inflate (dialogframe); + } + + if (cp.IsSet (WindowStyles.WS_THICKFRAME)) { + if (cp.IsSet (WindowStyles.WS_DLGFRAME)) { + border_size.Inflate (border); + } else { + border_size.Inflate (thickframe); + } + } + + bool only_small_border; + Size small_border = Size.Empty; + + only_small_border = cp.IsSet (WindowStyles.WS_THICKFRAME) || cp.IsSet (WindowStyles.WS_DLGFRAME); + if (only_small_border && cp.IsSet (WindowStyles.WS_THICKFRAME) && !cp.IsSet (WindowStyles.WS_BORDER) && !cp.IsSet (WindowStyles.WS_DLGFRAME)) { + small_border = border; + } + + if (cp.IsSet (WindowExStyles.WS_EX_CLIENTEDGE | WindowExStyles.WS_EX_DLGMODALFRAME)) { + border_size.Inflate (clientedge + (only_small_border ? small_border : dialogframe)); + } else if (cp.IsSet (WindowExStyles.WS_EX_STATICEDGE | WindowExStyles.WS_EX_DLGMODALFRAME)) { + border_size.Inflate (only_small_border ? small_border : dialogframe); + } else if (cp.IsSet (WindowExStyles.WS_EX_STATICEDGE | WindowExStyles.WS_EX_CLIENTEDGE)) { + border_size.Inflate (border + (only_small_border ? Size.Empty : clientedge)); + } else { + if (cp.IsSet (WindowExStyles.WS_EX_CLIENTEDGE)) { + border_size.Inflate (clientedge); + } + if (cp.IsSet (WindowExStyles.WS_EX_DLGMODALFRAME) && !cp.IsSet (WindowStyles.WS_DLGFRAME)) { + border_size.Inflate (cp.IsSet (WindowStyles.WS_THICKFRAME) ? border : dialogframe); + } + if (cp.IsSet (WindowExStyles.WS_EX_STATICEDGE)) { + if (cp.IsSet (WindowStyles.WS_THICKFRAME) || cp.IsSet (WindowStyles.WS_DLGFRAME)) { + border_size.Inflate (new Size (-border.Width, -border.Height)); + } else { + border_size.Inflate (border); + } + } + } + + return border_size; + } + + public static Rectangle GetWindowRectangle (CreateParams cp, Menu menu) + { + return GetWindowRectangle (cp, menu, Rectangle.Empty); + } + + public static Rectangle GetWindowRectangle (CreateParams cp, Menu menu, Rectangle client_rect) + { + Rectangle rect; + Borders borders; + + borders = GetBorders (cp, menu); + + rect = new Rectangle (Point.Empty, client_rect.Size); + rect.Y -= borders.top; + rect.Height += borders.top + borders.bottom; + rect.X -= borders.left; + rect.Width += borders.left + borders.right; + + #if debug + Console.WriteLine ("GetWindowRectangle ({0}, {1}, {2}): {3}", cp, menu != null, client_rect, rect); + #endif + return rect; + } + + public Rectangle GetClientRectangle (int width, int height) + { + CreateParams cp = new CreateParams (); + cp.WindowStyle = initial_style; + cp.WindowExStyle = initial_ex_style; + return GetClientRectangle (cp, menu, width, height); + } + + // This could be greatly optimized by caching the outputs and only updating when something is moved + // in the parent planar space. To do that we need to track z-order in the parent space as well + public ArrayList GetClippingRectangles () + { + ArrayList masks = new ArrayList (); + + if (x < 0) { + masks.Add (new Rectangle (0, 0, x*-1, Height)); + if (y < 0) { + masks.Add (new Rectangle (x*-1, 0, Width, y*-1)); + } + } else if (y < 0) { + masks.Add (new Rectangle (0, 0, Width, y*-1)); + } + + foreach (Hwnd child in children) { + if (child.visible) + masks.Add (new Rectangle (child.X, child.Y, child.Width, child.Height)); + } + + if (parent == null) { + return masks; + } + + ArrayList siblings = parent.children; + + foreach (Hwnd sibling in siblings) { + IntPtr sibling_handle = whole_window; + + if (sibling == this) + continue; + + // This entire method should be cached to find all higher views at the time of query + do { + sibling_handle = XplatUI.GetPreviousWindow (sibling_handle); + + if (sibling_handle == sibling.WholeWindow && sibling.visible) { + + Rectangle intersect = Rectangle.Intersect (new Rectangle (X, Y, Width, Height), new Rectangle (sibling.X, sibling.Y, sibling.Width, sibling.Height)); + + if (intersect == Rectangle.Empty) + continue; + + intersect.X -= X; + intersect.Y -= Y; + + masks.Add (intersect); + } + } while (sibling_handle != IntPtr.Zero); + } + + return masks; + } + + public static Borders GetBorders (CreateParams cp, Menu menu) + { + + Borders borders = new Borders (); + + if (menu != null) { + int menu_height = menu.Rect.Height; + if (menu_height == 0) + menu_height = ThemeEngine.Current.CalcMenuBarSize (GraphicsContext, menu, cp.Width); + borders.top += menu_height; + } + + if (cp.IsSet (WindowStyles.WS_CAPTION)) { + int caption_height; + if (cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) { + caption_height = ThemeEngine.Current.ToolWindowCaptionHeight; + } else { + caption_height = ThemeEngine.Current.CaptionHeight; + } + borders.top += caption_height; + } + + Borders border_width = GetBorderWidth (cp); + + borders.left += border_width.left; + borders.right += border_width.right; + borders.top += border_width.top; + borders.bottom += border_width.bottom; + + return borders; + } + + public static Rectangle GetClientRectangle(CreateParams cp, Menu menu, int width, int height) { + Rectangle rect; + Borders borders; + + borders = GetBorders (cp, menu); + + rect = new Rectangle(0, 0, width, height); + rect.Y += borders.top; + rect.Height -= borders.top + borders.bottom; + rect.X += borders.left; + rect.Width -= borders.left + borders.right; + + #if debug + Console.WriteLine ("GetClientRectangle ({0}, {1}, {2}, {3}): {4}", cp, menu != null, width, height, rect); + #endif + + return rect; + } + + public static Graphics GraphicsContext { + get { + if (bmp_g == null) { + bmp = new Bitmap (1, 1, System.Drawing.Imaging.PixelFormat.Format32bppArgb); + bmp_g = Graphics.FromImage (bmp); + } + + return bmp_g; + } + } + #endregion // Static Methods + + #region Instance Properties + public FormBorderStyle BorderStyle { + get { + return border_style; + } + + set { + border_style = value; + } + } + + public Rectangle ClientRect { + get { + if (client_rectangle == Rectangle.Empty) { + return DefaultClientRect; + } + return client_rectangle; + } + + set { + client_rectangle = value; + } + } + + public IntPtr Cursor { + get { + return cursor; + } + + set { + cursor = value; + } + } + + public IntPtr ClientWindow { + get { + return client_window; + } + + set { + client_window = value; + handle = value; + + zombie = false; + + if (client_window != IntPtr.Zero) { + lock (windows) { + if (windows[client_window] == null) { + windows[client_window] = this; + } + } + } + } + } + + public Region UserClip { + get { + return user_clip; + } + + set { + user_clip = value; + } + } + + public Rectangle DefaultClientRect { + get { + // We pass a Zero for the menu handle so the menu size is + // not computed this is done via an WM_NCCALC + CreateParams cp = new CreateParams (); + Rectangle rect; + + cp.WindowStyle = initial_style; + cp.WindowExStyle = initial_ex_style; + + rect = GetClientRectangle (cp, null, width, height); + + return rect; + } + } + + public bool ExposePending { + get { + return expose_pending; + } + } + + public IntPtr Handle { + get { + if (handle == IntPtr.Zero) { + throw new ArgumentNullException("Handle", "Handle is not yet assigned, need a ClientWindow"); + } + return handle; + } + } + + public int Height { + get { + return height; + } + + set { + height = value; + } + } + + public Menu Menu { + get { + return menu; + } + + set { + menu = value; + } + } + + public bool Reparented { + get { + return reparented; + } + + set { + reparented = value; + } + } + + public uint Opacity { + get { + return opacity; + } + + set { + opacity = value; + } + } + + public XEventQueue Queue { + get { + return queue; + } + + set { + queue = value; + } + } + + public bool Enabled { + get { + if (!enabled) { + return false; + } + + if (parent != null) { + return parent.Enabled; + } + + return true; + } + + set { + enabled = value; + } + } + + public IntPtr EnabledHwnd { + get { + if (Enabled || parent == null) { + return Handle; + } + + return parent.EnabledHwnd; + } + } + + public Point MenuOrigin { + get { + Form frm = Widget.FromHandle (handle) as Form; + if (frm != null && frm.window_manager != null) + return frm.window_manager.GetMenuOrigin (); + + Point pt; + Size border_3D_size = ThemeEngine.Current.Border3DSize; + + pt = new Point(0, 0); + + if (border_style == FormBorderStyle.Fixed3D) { + pt.X += border_3D_size.Width; + pt.Y += border_3D_size.Height; + } else if (border_style == FormBorderStyle.FixedSingle) { + pt.X += 1; + pt.Y += 1; + } + + if (this.title_style == TitleStyle.Normal) { + pt.Y += caption_height; + } else if (this.title_style == TitleStyle.Normal) { + pt.Y += tool_caption_height; + } + + return pt; + } + } + + public Rectangle Invalid { + get { + if (invalid_list.Count == 0) + return Rectangle.Empty; + + Rectangle result = (Rectangle)invalid_list[0]; + for (int i = 1; i < invalid_list.Count; i ++) { + result = Rectangle.Union (result, (Rectangle)invalid_list[i]); + } + return result; + } + } + + public Rectangle[] ClipRectangles { + get { + return (Rectangle[]) invalid_list.ToArray (typeof (Rectangle)); + } + } + + public Rectangle NCInvalid { + get { return nc_invalid; } + set { nc_invalid = value; } + + } + + public bool NCExposePending { + get { + return nc_expose_pending; + } + } + + public Hwnd Parent { + get { + return parent; + } + + set { + if (parent != null) + parent.children.Remove (this); + parent = value; + if (parent != null) + parent.children.Add (this); + } + } + + public bool Mapped { + get { + if (!mapped) { + return false; + } + + if (parent != null) { + return parent.Mapped; + } + + return true; + } + + set { + mapped = value; + } + } + + public int CaptionHeight { + get { return caption_height; } + set { caption_height = value; } + } + + public int ToolCaptionHeight { + get { return tool_caption_height; } + set { tool_caption_height = value; } + } + + public TitleStyle TitleStyle { + get { + return title_style; + } + + set { + title_style = value; + } + } + + public object UserData { + get { + return user_data; + } + + set { + user_data = value; + } + } + + public IntPtr WholeWindow { + get { + return whole_window; + } + + set { + whole_window = value; + + zombie = false; + + if (whole_window != IntPtr.Zero) { + lock (windows) { + if (windows[whole_window] == null) { + windows[whole_window] = this; + } + } + } + } + } + + public int Width { + get { + return width; + } + + set { + width = value; + } + } + + public bool Visible { + get { + return visible; + } + + set { + visible = value; + } + } + + public int X { + get { + return x; + } + + set { + x = value; + } + } + + public int Y { + get { + return y; + } + + set { + y = value; + } + } + + #endregion // Instance properties + + #region Methods + public void AddInvalidArea(int x, int y, int width, int height) { + AddInvalidArea(new Rectangle(x, y, width, height)); + } + + public void AddInvalidArea(Rectangle rect) { + ArrayList tmp = new ArrayList (); + foreach (Rectangle r in invalid_list) { + if (!rect.Contains (r)) { + tmp.Add (r); + } + } + tmp.Add (rect); + invalid_list = tmp; + } + + public void ClearInvalidArea() { + invalid_list.Clear(); + expose_pending = false; + } + + public void AddNcInvalidArea(int x, int y, int width, int height) { + if (nc_invalid == Rectangle.Empty) { + nc_invalid = new Rectangle (x, y, width, height); + return; + } + + int right, bottom; + right = Math.Max (nc_invalid.Right, x + width); + bottom = Math.Max (nc_invalid.Bottom, y + height); + nc_invalid.X = Math.Min (nc_invalid.X, x); + nc_invalid.Y = Math.Min (nc_invalid.Y, y); + + nc_invalid.Width = right - nc_invalid.X; + nc_invalid.Height = bottom - nc_invalid.Y; + } + + public void AddNcInvalidArea(Rectangle rect) { + if (nc_invalid == Rectangle.Empty) { + nc_invalid = rect; + return; + } + nc_invalid = Rectangle.Union (nc_invalid, rect); + } + + public void ClearNcInvalidArea() { + nc_invalid = Rectangle.Empty; + nc_expose_pending = false; + } + + public override string ToString() { + return String.Format("Hwnd, Mapped:{3} ClientWindow:0x{0:X}, WholeWindow:0x{1:X}, Zombie={4}, Parent:[{2:X}]", client_window.ToInt32(), whole_window.ToInt32(), parent != null ? parent.ToString() : "<null>", Mapped, zombie); + } + + public static Point GetNextStackedFormLocation (CreateParams cp, Hwnd parent_hwnd) + { + if (cp.control == null) + return Point.Empty; + + int X = cp.X; + int Y = cp.Y; + Point previous, next; + Rectangle within; + + if (parent_hwnd != null) { + Widget parent = cp.control.Parent; + previous = parent_hwnd.previous_child_startup_location; + if (parent_hwnd.client_rectangle == Rectangle.Empty && parent != null) { + within = parent.ClientRectangle; + } else { + within = parent_hwnd.client_rectangle; + } + } else { + previous = Hwnd.previous_main_startup_location; + within = ShiftUI.Screen.PrimaryScreen.WorkingArea; + } + + if (previous.X == int.MinValue || previous.Y == int.MinValue) { + next = Point.Empty; + } else { + next = new Point (previous.X + 22, previous.Y + 22); + } + + if (!within.Contains (next.X * 3, next.Y * 3)) { + next = Point.Empty; + } + + if (next == Point.Empty && cp.Parent == IntPtr.Zero) { + next = new Point (22, 22); + } + + if (parent_hwnd != null) { + parent_hwnd.previous_child_startup_location = next; + } else { + Hwnd.previous_main_startup_location = next; + } + + if (X == int.MinValue && Y == int.MinValue) { + X = next.X; + Y = next.Y; + } + + return new Point (X, Y); + } + + #endregion // Methods + + internal struct Borders + { + public int top; + public int bottom; + public int left; + public int right; + + public void Inflate (Size size) + { + left += size.Width; + right += size.Width; + top += size.Height; + bottom += size.Height; + } + + public override string ToString () + { + return string.Format("{{top={0}, bottom={1}, left={2}, right={3}}}", top, bottom, left, right); + } + + public static bool operator == (Borders a, Borders b) + { + return (a.left == b.left && a.right == b.right && a.top == b.top && a.bottom == b.bottom); + } + + public static bool operator != (Borders a, Borders b) + { + return !(a == b); + } + + public override bool Equals (object obj) + { + return base.Equals (obj); + } + + public override int GetHashCode () + { + return base.GetHashCode (); + } + } + } +} diff --git a/source/ShiftUI/Internal/IBindableComponent.cs b/source/ShiftUI/Internal/IBindableComponent.cs new file mode 100644 index 0000000..8c7edaa --- /dev/null +++ b/source/ShiftUI/Internal/IBindableComponent.cs @@ -0,0 +1,34 @@ +// 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) 2006 Novell, Inc. (http://www.novell.com) +// + + +using System; +using System.ComponentModel; + +namespace ShiftUI { + + public interface IBindableComponent : IComponent, IDisposable + { + BindingContext BindingContext { get; set; } + WidgetBindingsCollection DataBindings { get; } + } +} diff --git a/source/ShiftUI/Internal/IBounds.cs b/source/ShiftUI/Internal/IBounds.cs new file mode 100644 index 0000000..923a029 --- /dev/null +++ b/source/ShiftUI/Internal/IBounds.cs @@ -0,0 +1,40 @@ +// +// IBounds.cs +// +// 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) 2008 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; + +namespace ShiftUI +{ + interface IBounds + { + Rectangle Bounds { get; } + } +} diff --git a/source/ShiftUI/Internal/IButtonControl.cs b/source/ShiftUI/Internal/IButtonControl.cs new file mode 100644 index 0000000..33d9fc8 --- /dev/null +++ b/source/ShiftUI/Internal/IButtonControl.cs @@ -0,0 +1,40 @@ +// +// ShiftUI.IButtonWidget.cs +// +// 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. +// +// Authors: +// Jordi Mas i Hernandez, [email protected] +// +// + + +// COMPLETE + +namespace ShiftUI +{ + + public interface IButtonWidget + { + DialogResult DialogResult {get; set;} + void NotifyDefault (bool value); + void PerformClick (); + } +} diff --git a/source/ShiftUI/Internal/ICommandExecutor.cs b/source/ShiftUI/Internal/ICommandExecutor.cs new file mode 100644 index 0000000..dfe1573 --- /dev/null +++ b/source/ShiftUI/Internal/ICommandExecutor.cs @@ -0,0 +1,34 @@ +// 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 + +namespace ShiftUI { + public interface ICommandExecutor { + #region Public Instance Methods + void Execute(); + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/IComponentEditorPageSite.cs b/source/ShiftUI/Internal/IComponentEditorPageSite.cs new file mode 100644 index 0000000..fd9eaa9 --- /dev/null +++ b/source/ShiftUI/Internal/IComponentEditorPageSite.cs @@ -0,0 +1,34 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok ([email protected]); +// + +// COMPLETE + +namespace ShiftUI { + + public interface IComponentEditorPageSite { + Widget GetWidget(); + void SetDirty(); + } +} diff --git a/source/ShiftUI/Internal/IContainerControl.cs b/source/ShiftUI/Internal/IContainerControl.cs new file mode 100644 index 0000000..da5cc19 --- /dev/null +++ b/source/ShiftUI/Internal/IContainerControl.cs @@ -0,0 +1,39 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// + + +// COMPLETE + +namespace ShiftUI { + public interface IContainerWidget { + #region Public Instance Properties + Widget ActiveWidget {get; set;} + #endregion // Public Instance Properties + + #region Public Instance Methods + bool ActivateWidget(Widget active); + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/ICurrencyManagerProvider.cs b/source/ShiftUI/Internal/ICurrencyManagerProvider.cs new file mode 100644 index 0000000..a3993cc --- /dev/null +++ b/source/ShiftUI/Internal/ICurrencyManagerProvider.cs @@ -0,0 +1,32 @@ +// 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) 2006 Novell, Inc. (http://www.novell.com) +// + + +namespace ShiftUI { + + public interface ICurrencyManagerProvider { + CurrencyManager CurrencyManager { get; } + + CurrencyManager GetRelatedCurrencyManager (string dataMember); + } + +} diff --git a/source/ShiftUI/Internal/IDataGridColumnStyleEditingNotificationService.cs b/source/ShiftUI/Internal/IDataGridColumnStyleEditingNotificationService.cs new file mode 100644 index 0000000..f55a6c6 --- /dev/null +++ b/source/ShiftUI/Internal/IDataGridColumnStyleEditingNotificationService.cs @@ -0,0 +1,35 @@ +// 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 + +namespace ShiftUI { + public interface IDataGridColumnStyleEditingNotificationService { + #region Public Instance Methods + void ColumnStartedEditing(Widget editingWidget); + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/IDataGridEditingService.cs b/source/ShiftUI/Internal/IDataGridEditingService.cs new file mode 100644 index 0000000..41f9c9a --- /dev/null +++ b/source/ShiftUI/Internal/IDataGridEditingService.cs @@ -0,0 +1,36 @@ +// 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 + +namespace ShiftUI { + public interface IDataGridEditingService { + #region Public Instance Methods + bool BeginEdit(DataGridColumnStyle gridColumn, int rowNumber); + bool EndEdit(DataGridColumnStyle gridColumn, int rowNumber, bool shouldAbort); + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/IDataGridViewEditingCell.cs b/source/ShiftUI/Internal/IDataGridViewEditingCell.cs new file mode 100644 index 0000000..30fc6e4 --- /dev/null +++ b/source/ShiftUI/Internal/IDataGridViewEditingCell.cs @@ -0,0 +1,41 @@ +// 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) +// +// Author: +// Pedro MartÃnez Juliá <[email protected]> +// + + +namespace ShiftUI { + + public interface IDataGridViewEditingCell { + + object EditingCellFormattedValue { get; set; } + + bool EditingCellValueChanged { get; set; } + + object GetEditingCellFormattedValue (DataGridViewDataErrorContexts context); + + void PrepareEditingCellForEdit (bool selectAll); + + } + +} diff --git a/source/ShiftUI/Internal/IDataGridViewEditingControl.cs b/source/ShiftUI/Internal/IDataGridViewEditingControl.cs new file mode 100644 index 0000000..8b102d0 --- /dev/null +++ b/source/ShiftUI/Internal/IDataGridViewEditingControl.cs @@ -0,0 +1,53 @@ +// 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) +// +// Author: +// Pedro MartÃnez Juliá <[email protected]> +// + + +namespace ShiftUI { + + public interface IDataGridViewEditingWidget { + + DataGridView EditingWidgetDataGridView {get; set;} + + object EditingWidgetFormattedValue {get; set;} + + int EditingWidgetRowIndex {get; set;} + + bool EditingWidgetValueChanged {get; set;} + + Cursor EditingPanelCursor {get;} + + bool RepositionEditingWidgetOnValueChange {get;} + + void ApplyCellStyleToEditingWidget (DataGridViewCellStyle dataGridViewCellStyle); + + bool EditingWidgetWantsInputKey (Keys keyData, bool dataGridViewWantsInputKey); + + object GetEditingWidgetFormattedValue (DataGridViewDataErrorContexts context); + + void PrepareEditingWidgetForEdit (bool selectAll); + + } + +} diff --git a/source/ShiftUI/Internal/IDataObject.cs b/source/ShiftUI/Internal/IDataObject.cs new file mode 100644 index 0000000..7ce0d80 --- /dev/null +++ b/source/ShiftUI/Internal/IDataObject.cs @@ -0,0 +1,54 @@ +// 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) 2004-2005 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// +// + + +// COMPLETE + +using System.Runtime.InteropServices; +using System; + +namespace ShiftUI { + [ComVisible(true)] + public interface IDataObject { + #region Public Instance Methods + object GetData(string format); + object GetData(string format, bool autoConvert); + object GetData(Type format); + + bool GetDataPresent(string format); + bool GetDataPresent(string format, bool autoConvert); + bool GetDataPresent(Type format); + + string[] GetFormats(); + string[] GetFormats(bool autoConvert); + + void SetData(object data); + void SetData(string format, bool autoConvert, object data); + void SetData(string format, object data); + void SetData(Type format, object data); + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/IDropTarget.cs b/source/ShiftUI/Internal/IDropTarget.cs new file mode 100644 index 0000000..2589634 --- /dev/null +++ b/source/ShiftUI/Internal/IDropTarget.cs @@ -0,0 +1,36 @@ +// 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) 2006 Novell, Inc. +// + +using System; +using System.Drawing; +using System.ComponentModel; + +namespace ShiftUI { + + public interface IDropTarget { + void OnDragDrop (DragEventArgs e); + void OnDragEnter (DragEventArgs e); + void OnDragLeave (EventArgs e); + void OnDragOver (DragEventArgs e); + } + +} diff --git a/source/ShiftUI/Internal/IEventHandler.cs b/source/ShiftUI/Internal/IEventHandler.cs new file mode 100644 index 0000000..e46175e --- /dev/null +++ b/source/ShiftUI/Internal/IEventHandler.cs @@ -0,0 +1,33 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton <[email protected]> +// +// + +using System; + +namespace ShiftUI.CarbonInternal { + internal interface IEventHandler { + bool ProcessEvent (IntPtr callref, IntPtr eventref, IntPtr handle, uint kind, ref MSG msg); + } +} diff --git a/source/ShiftUI/Internal/IFeatureSupport.cs b/source/ShiftUI/Internal/IFeatureSupport.cs new file mode 100644 index 0000000..748b510 --- /dev/null +++ b/source/ShiftUI/Internal/IFeatureSupport.cs @@ -0,0 +1,38 @@ +// 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; + +namespace ShiftUI { + public interface IFeatureSupport { + #region Public Instance Methods + Version GetVersionPresent(object feature); + bool IsPresent(object feature); + bool IsPresent(object feature, Version minimumVersion); + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/IFileReaderService.cs b/source/ShiftUI/Internal/IFileReaderService.cs new file mode 100644 index 0000000..abee90e --- /dev/null +++ b/source/ShiftUI/Internal/IFileReaderService.cs @@ -0,0 +1,37 @@ +// 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.IO; + +namespace ShiftUI { + public interface IFileReaderService { + #region Public Instance Methods + Stream OpenFileFromSource(string relativePath); + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/IKeyFilter.cs b/source/ShiftUI/Internal/IKeyFilter.cs new file mode 100644 index 0000000..ecc2396 --- /dev/null +++ b/source/ShiftUI/Internal/IKeyFilter.cs @@ -0,0 +1,32 @@ +// 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) 2008 Novell, Inc. +// +// Authors: +// Mike Gorse [email protected] +// +// + + +namespace ShiftUI { + internal interface IKeyFilter { + bool PreFilterKey(KeyFilterData data); + } +} diff --git a/source/ShiftUI/Internal/IMessageFilter.cs b/source/ShiftUI/Internal/IMessageFilter.cs new file mode 100644 index 0000000..d55394f --- /dev/null +++ b/source/ShiftUI/Internal/IMessageFilter.cs @@ -0,0 +1,34 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// +// + + +// COMPLETE + +namespace ShiftUI { + public interface IMessageFilter { + bool PreFilterMessage(ref Message m); + } +} diff --git a/source/ShiftUI/Internal/IToolStripData.cs b/source/ShiftUI/Internal/IToolStripData.cs new file mode 100644 index 0000000..c01afd3 --- /dev/null +++ b/source/ShiftUI/Internal/IToolStripData.cs @@ -0,0 +1,41 @@ +// +// IToolStripData.cs +// +// 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) 2008 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; + +namespace ShiftUI +{ + interface IToolStripData + { + bool IsCurrentlyDragging { get; } + bool Stretch { get; set; } + } +} diff --git a/source/ShiftUI/Internal/IWin32Window.cs b/source/ShiftUI/Internal/IWin32Window.cs new file mode 100644 index 0000000..73bfc31 --- /dev/null +++ b/source/ShiftUI/Internal/IWin32Window.cs @@ -0,0 +1,44 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// +// + + +// COMPLETE + +using System.Runtime.InteropServices; +using System; + +namespace ShiftUI { + [ComVisible(true)] + [Guid("458AB8A2-A1EA-4d7b-8EBE-DEE5D3D9442C")] + [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWin32Window { + #region Public Instance Properties + IntPtr Handle { + get; + } + #endregion // Public Instance Properties + } +} diff --git a/source/ShiftUI/Internal/IWindowTarget.cs b/source/ShiftUI/Internal/IWindowTarget.cs new file mode 100644 index 0000000..0157773 --- /dev/null +++ b/source/ShiftUI/Internal/IWindowTarget.cs @@ -0,0 +1,34 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// +using System; + +namespace ShiftUI { + public interface IWindowTarget { + #region Public Instance Methods + void OnHandleChange(IntPtr newHandle); + void OnMessage(ref Message m); + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/ImageIndexConverter.cs b/source/ShiftUI/Internal/ImageIndexConverter.cs new file mode 100644 index 0000000..b2783e9 --- /dev/null +++ b/source/ShiftUI/Internal/ImageIndexConverter.cs @@ -0,0 +1,102 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Ravindra [email protected] +// + + +// COMPLETE + +using System; +using System.Drawing; +using System.ComponentModel; +using System.Collections; +using System.Diagnostics; +using System.Globalization; +using System.Runtime.InteropServices; + +namespace ShiftUI +{ + public class ImageIndexConverter : Int32Converter + { + #region Constructors + + public ImageIndexConverter () { } + + #endregion Constructors + + #region Protected Properties + + protected virtual bool IncludeNoneAsStandardValue { + get { return true; } + } + + #endregion Protected Properties + + #region Public Methods + + public override object ConvertFrom (ITypeDescriptorContext context, CultureInfo culture, object value) + { + string indexStr; + if (value != null && value is string) { + indexStr = (string) value; + if (indexStr == "(none)") + return -1; + else + return Int32.Parse (indexStr); + } + else + return base.ConvertFrom (context, culture, value); + } + + public override object ConvertTo (ITypeDescriptorContext context, CultureInfo culture, + object value, Type destinationType) + { + if (value != null && destinationType == typeof (string)) { + if (value is int && (int) value == -1) + return "(none)"; + else + return value.ToString (); + } + else + return base.ConvertTo (context, culture, value, destinationType); + } + + public override StandardValuesCollection GetStandardValues (ITypeDescriptorContext context) + { + int [] stdVal = new int [] {-1}; + return new TypeConverter.StandardValuesCollection (stdVal); + } + + public override bool GetStandardValuesExclusive (ITypeDescriptorContext context) + { + return false; + } + + public override bool GetStandardValuesSupported (ITypeDescriptorContext context) + { + return true; + } + + #endregion Public Methods + } +} diff --git a/source/ShiftUI/Internal/ImageKeyConverter.cs b/source/ShiftUI/Internal/ImageKeyConverter.cs new file mode 100644 index 0000000..e70b5e1 --- /dev/null +++ b/source/ShiftUI/Internal/ImageKeyConverter.cs @@ -0,0 +1,97 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Jonathan Pobst [email protected] +// + +using System.Drawing; +using System.ComponentModel; +using System.Collections; +using System.Diagnostics; +using System.Globalization; +using System.Runtime.InteropServices; +using System; + +namespace ShiftUI +{ + public class ImageKeyConverter : StringConverter + { + #region Constructors + public ImageKeyConverter () { } + #endregion Constructors + + #region Protected Properties + protected virtual bool IncludeNoneAsStandardValue { + get { return true; } + } + #endregion Protected Properties + + #region Public Methods + public override bool CanConvertFrom (ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof (string)) + return true; + + return false; + } + + public override object ConvertFrom (ITypeDescriptorContext context, CultureInfo culture, object value) + { + if (value != null && value is string) + return (string) value; + else + return base.ConvertFrom (context, culture, value); + } + + public override object ConvertTo (ITypeDescriptorContext context, CultureInfo culture, + object value, Type destinationType) + { + if (value == null) + return "(none)"; + else if (destinationType == typeof (string)) { + if (value is string && (string) value == string.Empty) + return "(none)"; + else + return value.ToString (); + } + else + return base.ConvertTo (context, culture, value, destinationType); + } + + public override StandardValuesCollection GetStandardValues (ITypeDescriptorContext context) + { + string[] stdVal = new string[] { string.Empty }; + return new TypeConverter.StandardValuesCollection (stdVal); + } + + public override bool GetStandardValuesExclusive (ITypeDescriptorContext context) + { + return true; + } + + public override bool GetStandardValuesSupported (ITypeDescriptorContext context) + { + return true; + } + #endregion Public Methods + } +} diff --git a/source/ShiftUI/Internal/ImageList.cs b/source/ShiftUI/Internal/ImageList.cs new file mode 100644 index 0000000..b983455 --- /dev/null +++ b/source/ShiftUI/Internal/ImageList.cs @@ -0,0 +1,1073 @@ +// +// ShiftUI.ImageList.cs +// +// Authors: +// Peter Bartok <[email protected]> +// Kornél Pál <http://www.kornelpal.hu/> +// +// Copyright (C) 2004-2005 Novell, Inc. +// Copyright (C) 2005 Kornél Pál +// + +// +// 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. +// + +// COMPLETE + +// +// Differences between MS.NET ImageList and this implementation: +// +// This is a fully managed image list implementation. +// +// Images are stored as Format32bppArgb internally but ColorDepth is applied +// to the colors of images. Images[index] returns a Format32bppArgb copy of +// the image so this difference is only internal. +// +// MS.NET has no alpha channel support (except for icons in 32-bit mode with +// comctl32.dll version 6.0) but this implementation has full alpha channel +// support in 32-bit mode. +// +// Handle should be an HIMAGELIST returned by ImageList_Create. This +// implementation uses (IntPtr)(-1) that is a non-zero but invalid handle. +// +// MS.NET destroys handles using the garbage collector this implementation +// does the same with Image objects stored in an ArrayList. +// +// MS.NET 1.x shares the same HIMAGELIST between ImageLists that were +// initialized from the same ImageListStreamer and doesn't update ImageSize +// and ColorDepth that are treated as bugs and MS.NET 2.0 behavior is +// implemented. +// +// MS.NET 2.0 does not clear keys when handle is destroyed that is treated as +// a bug. +// + +using System.Collections; +using System.Collections.Specialized; +using System.ComponentModel; +using System.ComponentModel.Design.Serialization; +using System.Drawing; +using System.Drawing.Design; +using System.Drawing.Imaging; +using System.Globalization; +using System.Runtime.InteropServices; +using System; + +namespace ShiftUI +{ + [DefaultProperty("Images")] + //[Designer("ShiftUI.Design.ImageListDesigner, " + Consts.AssemblySystem_Design)] + //[DesignerSerializer("ShiftUI.Design.ImageListCodeDomSerializer, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.Serialization.CodeDomSerializer, " + Consts.AssemblySystem_Design)] + [ToolboxItemFilter("ShiftUI")] + [TypeConverter(typeof(ImageListConverter))] + public sealed class ImageList : System.ComponentModel.Component + { + #region Private Fields + private const ColorDepth DefaultColorDepth = ColorDepth.Depth8Bit; + private static readonly Size DefaultImageSize = new Size(16, 16); + private static readonly Color DefaultTransparentColor = Color.Transparent; + private object tag; + private readonly ImageCollection images; + #endregion // Private Fields + + #region Sub-classes + //[Editor("ShiftUI.Design.ImageCollectionEditor, " + Consts.AssemblySystem_Design, typeof(UITypeEditor))] + public sealed class ImageCollection : IList, ICollection, IEnumerable + { + private const int AlphaMask = unchecked((int)0xFF000000); + + private static class IndexedColorDepths + { + internal static readonly ColorPalette Palette4Bit; + internal static readonly ColorPalette Palette8Bit; + private static readonly int[] squares; + + static IndexedColorDepths() + { + Bitmap bitmap; + int index; + + bitmap = new Bitmap(1, 1, PixelFormat.Format4bppIndexed); + Palette4Bit = bitmap.Palette; + bitmap.Dispose(); + + bitmap = new Bitmap(1, 1, PixelFormat.Format8bppIndexed); + Palette8Bit = bitmap.Palette; + bitmap.Dispose(); + + squares = new int[511]; + for (index = 0; index < 256; index++) + squares[255 + index] = squares[255 - index] = index * index; + } + + internal static int GetNearestColor(Color[] palette, int color) + { + int index; + int count; + int red; + int green; + int blue; + int nearestColor; + int minDistance; + int distance; + + count = palette.Length; + for (index = 0; index < count; index++) + if (palette[index].ToArgb() == color) + return color; + + red = unchecked((int)(unchecked((uint)color) >> 16) & 0xFF); + green = unchecked((int)(unchecked((uint)color) >> 8) & 0xFF); + blue = color & 0xFF; + nearestColor = AlphaMask; + minDistance = int.MaxValue; + + for (index = 0; index < count; index++) + if ((distance = squares[255 + palette[index].R - red] + squares[255 + palette[index].G - green] + squares[255 + palette[index].B - blue]) < minDistance) { + nearestColor = palette[index].ToArgb(); + minDistance = distance; + } + + return nearestColor; + } + } + + [Flags()] + private enum ItemFlags + { + None = 0, + UseTransparentColor = 1, + ImageStrip = 2 + } + + private sealed class ImageListItem + { + internal readonly object Image; + internal readonly ItemFlags Flags; + internal readonly Color TransparentColor; + internal readonly int ImageCount = 1; + + internal ImageListItem(Icon value) + { + if (value == null) + throw new ArgumentNullException("value"); + + // Icons are cloned. + this.Image = (Icon)value.Clone(); + } + + internal ImageListItem(Image value) + { + if (value == null) + throw new ArgumentNullException("value"); + + if (!(value is Bitmap)) + throw new ArgumentException("Image must be a Bitmap."); + + // Images are not cloned. + this.Image = value; + } + + internal ImageListItem(Image value, Color transparentColor) : this(value) + { + this.Flags = ItemFlags.UseTransparentColor; + this.TransparentColor = transparentColor; + } + + internal ImageListItem(Image value, int imageCount) : this(value) + { + this.Flags = ItemFlags.ImageStrip; + this.ImageCount = imageCount; + } + } + + #region ImageCollection Private Fields + private ColorDepth colorDepth = DefaultColorDepth; + private Size imageSize = DefaultImageSize; + private Color transparentColor = DefaultTransparentColor; + private ArrayList list = new ArrayList(); + private ArrayList keys = new ArrayList(); + private int count; + private bool handleCreated; + private int lastKeyIndex = -1; + private readonly ImageList owner; + #endregion // ImageCollection Private Fields + + #region ImageCollection Internal Constructors + // For use in ImageList + internal ImageCollection(ImageList owner) + { + this.owner = owner; + } + #endregion // ImageCollection Internal Constructor + + #region ImageCollection Internal Instance Properties + // For use in ImageList + internal ColorDepth ColorDepth { + get { + return this.colorDepth; + } + + set { + if (!Enum.IsDefined(typeof(ColorDepth), value)) + throw new InvalidEnumArgumentException("value", (int)value, typeof(ColorDepth)); + + if (this.colorDepth != value) { + this.colorDepth = value; + RecreateHandle(); + } + } + } + + // For use in ImageList + internal IntPtr Handle { + get { + CreateHandle(); + return (IntPtr)(-1); + } + } + + // For use in ImageList + internal bool HandleCreated { + get { + return this.handleCreated; + } + } + + // For use in ImageList + internal Size ImageSize { + get { + return this.imageSize; + } + + set { + if (value.Width < 1 || value.Width > 256 || value.Height < 1 || value.Height > 256) + throw new ArgumentException("ImageSize.Width and Height must be between 1 and 256", "value"); + + if (this.imageSize != value) { + this.imageSize = value; + RecreateHandle(); + } + } + } + + // For use in ImageList + internal ImageListStreamer ImageStream { + get { + return this.Empty ? null : new ImageListStreamer(this); + } + + set { + int index; + Image[] streamImages; + + if (value == null) { + if (this.handleCreated) + DestroyHandle(); + else + this.Clear(); + } + // Only deserialized ImageListStreamers are used. + else if ((streamImages = value.Images) != null) { + this.list = new ArrayList(streamImages.Length); + this.count = 0; + this.handleCreated = true; + this.keys = new ArrayList(streamImages.Length); + + for (index = 0; index < streamImages.Length; index++) { + list.Add((Image)streamImages[index].Clone()); + keys.Add(null); + } + + // Invalid ColorDepth values are ignored. + if (Enum.IsDefined(typeof(ColorDepth), value.ColorDepth)) + this.colorDepth = (ColorDepth)value.ColorDepth; + this.imageSize = value.ImageSize; + + // Event is raised even when handle was not created yet. + owner.OnRecreateHandle(); + } + } + } + + // For use in ImageList + internal Color TransparentColor { + get { + return this.transparentColor; + } + + set { + this.transparentColor = value; + } + } + #endregion // ImageCollection Internal Instance Properties + + #region ImageCollection Public Instance Properties + [Browsable(false)] + public int Count { + get { + return this.handleCreated ? list.Count : this.count; + } + } + + public bool Empty { + get { + return this.Count == 0; + } + } + + public bool IsReadOnly { + get { + return false; + } + } + + [Browsable(false)] + //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public Image this[int index] { + get { + return (Image)GetImage(index).Clone(); + } + + set { + Image image; + + if (index < 0 || index >= this.Count) + throw new ArgumentOutOfRangeException("index"); + + if (value == null) + throw new ArgumentNullException("value"); + + if (!(value is Bitmap)) + throw new ArgumentException("Image must be a Bitmap."); + + image = CreateImage(value, this.transparentColor); + CreateHandle(); + list[index] = image; + } + } + + public Image this[string key] { + get { + int index; + + return (index = IndexOfKey(key)) == -1 ? null : this[index]; + } + } + + public StringCollection Keys { + get { + int index; + string key; + StringCollection keyCollection; + + // Returns all keys even when there are more keys than + // images. Null keys are returned as empty strings. + + keyCollection = new StringCollection(); + for (index = 0; index < keys.Count; index++) + keyCollection.Add(((key = (string)keys[index]) == null || key.Length == 0) ? string.Empty : key); + + return keyCollection; + } + } + #endregion // ImageCollection Public Instance Properties + + #region ImageCollection Private Static Methods + private static bool CompareKeys(string key1, string key2) + { + // Keys are case-insensitive and keys with different length + // are not equal even when string.Compare treats them equal. + + if (key1 == null || key2 == null || key1.Length != key2.Length) + return false; + + return string.Compare(key1, key2, true, CultureInfo.InvariantCulture) == 0; + } + #endregion // ImageCollection Private Static Methods + + #region ImageCollection Private Instance Methods + private int AddItem(string key, ImageListItem item) + { + int itemIndex; + int index; + + if (this.handleCreated) + itemIndex = AddItemInternal(item); + else { + // Image strips are counted as a single item in the return + // value of Add and AddStrip until handle is created. + + itemIndex = list.Add(item); + this.count += item.ImageCount; + } + + if ((item.Flags & ItemFlags.ImageStrip) == 0) + keys.Add(key); + else + for (index = 0; index < item.ImageCount; index++) + keys.Add(null); + + return itemIndex; + } + + internal event EventHandler Changed; + + private int AddItemInternal(ImageListItem item) + { + if (Changed != null) + Changed (this, EventArgs.Empty); + + if (item.Image is Icon) { + int imageWidth; + int imageHeight; + Bitmap bitmap; + Graphics graphics; + + bitmap = new Bitmap(imageWidth = this.imageSize.Width, imageHeight = this.imageSize.Height, PixelFormat.Format32bppArgb); + graphics = Graphics.FromImage(bitmap); + graphics.DrawIcon((Icon)item.Image, new Rectangle(0, 0, imageWidth, imageHeight)); + graphics.Dispose(); + + ReduceColorDepth(bitmap); + return list.Add(bitmap); + } + else if ((item.Flags & ItemFlags.ImageStrip) == 0) + return list.Add(CreateImage((Image)item.Image, (item.Flags & ItemFlags.UseTransparentColor) == 0 ? this.transparentColor : item.TransparentColor)); + else { + int imageX; + int width; + int imageWidth; + int imageHeight; + int index; + Image image; + Bitmap bitmap; + Graphics graphics; + Rectangle imageRect; + ImageAttributes imageAttributes; + + // When ImageSize was changed after adding image strips + // Count will return invalid values based on old ImageSize + // but when creating handle either ArgumentException will + // be thrown or image strip will be added according to the + // new ImageSize. This can result in image count + // difference that can result in exceptions in methods + // that use Count before creating handle. In addition this + // can result in the loss of sync with keys. When doing + // the same after handle was created there are no problems + // as handle will be recreated after changing ImageSize + // that results in the loss of images added previously. + + if ((width = (image = (Image)item.Image).Width) == 0 || (width % (imageWidth = this.imageSize.Width)) != 0) + throw new ArgumentException("Width of image strip must be a positive multiple of ImageSize.Width.", "value"); + + if (image.Height != (imageHeight = this.imageSize.Height)) + throw new ArgumentException("Height of image strip must be equal to ImageSize.Height.", "value"); + + imageRect = new Rectangle(0, 0, imageWidth, imageHeight); + if (this.transparentColor.A == 0) + imageAttributes = null; + else { + imageAttributes = new ImageAttributes(); + imageAttributes.SetColorKey(this.transparentColor, this.transparentColor); + } + + index = list.Count; + for (imageX = 0; imageX < width; imageX += imageWidth) { + bitmap = new Bitmap(imageWidth, imageHeight, PixelFormat.Format32bppArgb); + graphics = Graphics.FromImage(bitmap); + graphics.DrawImage(image, imageRect, imageX, 0, imageWidth, imageHeight, GraphicsUnit.Pixel, imageAttributes); + graphics.Dispose(); + + ReduceColorDepth(bitmap); + list.Add(bitmap); + } + + if (imageAttributes != null) + imageAttributes.Dispose(); + + return index; + } + } + + private void CreateHandle() + { + int index; + ArrayList items; + + if (!this.handleCreated) { + items = this.list; + this.list = new ArrayList(this.count); + this.count = 0; + this.handleCreated = true; + + for (index = 0; index < items.Count; index++) + AddItemInternal((ImageListItem)items[index]); + } + } + + private Image CreateImage(Image value, Color transparentColor) + { + int imageWidth; + int imageHeight; + ImageAttributes imageAttributes; + + if (transparentColor.A == 0) + imageAttributes = null; + else { + imageAttributes = new ImageAttributes(); + imageAttributes.SetColorKey (transparentColor, transparentColor); + } + + var bitmap = new Bitmap (imageWidth = this.imageSize.Width, imageHeight = this.imageSize.Height, PixelFormat.Format32bppArgb); + using (var graphics = Graphics.FromImage (bitmap)) + graphics.DrawImage (value, new Rectangle(0, 0, imageWidth, imageHeight), 0, 0, value.Width, value.Height, GraphicsUnit.Pixel, imageAttributes); + + if (imageAttributes != null) + imageAttributes.Dispose (); + + ReduceColorDepth (bitmap); + return bitmap; + } + + private void RecreateHandle() + { + if (this.handleCreated) { + DestroyHandle(); + this.handleCreated = true; + owner.OnRecreateHandle(); + } + } + + private unsafe void ReduceColorDepth(Bitmap bitmap) + { + byte* pixelPtr; + byte* lineEndPtr; + byte* linePtr; + int line; + int pixel; + int height; + int widthBytes; + int stride; + BitmapData bitmapData; + Color[] palette; + + if (this.colorDepth < ColorDepth.Depth32Bit) { + bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb); + try { + linePtr = (byte*)bitmapData.Scan0; + height = bitmapData.Height; + widthBytes = bitmapData.Width << 2; + stride = bitmapData.Stride; + + if (this.colorDepth < ColorDepth.Depth16Bit) { + palette = (this.colorDepth < ColorDepth.Depth8Bit ? IndexedColorDepths.Palette4Bit : IndexedColorDepths.Palette8Bit).Entries; + + for (line = 0; line < height; line++) { + lineEndPtr = linePtr + widthBytes; + for (pixelPtr = linePtr; pixelPtr < lineEndPtr; pixelPtr += 4) + *(int*)pixelPtr = ((pixel = *(int*)pixelPtr) & AlphaMask) == 0 ? 0x00000000 : IndexedColorDepths.GetNearestColor(palette, pixel | AlphaMask); + linePtr += stride; + } + } + else if (this.colorDepth < ColorDepth.Depth24Bit) { + for (line = 0; line < height; line++) { + lineEndPtr = linePtr + widthBytes; + for (pixelPtr = linePtr; pixelPtr < lineEndPtr; pixelPtr += 4) + *(int*)pixelPtr = ((pixel = *(int*)pixelPtr) & AlphaMask) == 0 ? 0x00000000 : (pixel & 0x00F8F8F8) | AlphaMask; + linePtr += stride; + } + } + else { + for (line = 0; line < height; line++) { + lineEndPtr = linePtr + widthBytes; + for (pixelPtr = linePtr; pixelPtr < lineEndPtr; pixelPtr += 4) + *(int*)pixelPtr = ((pixel = *(int*)pixelPtr) & AlphaMask) == 0 ? 0x00000000 : pixel | AlphaMask; + linePtr += stride; + } + } + } + finally { + bitmap.UnlockBits(bitmapData); + } + } + } + #endregion // ImageCollection Private Instance Methods + + #region ImageCollection Internal Instance Methods + // For use in ImageList + internal void DestroyHandle() + { + if (this.handleCreated) { + this.list = new ArrayList(); + this.count = 0; + this.handleCreated = false; + keys = new ArrayList(); + } + } + + // For use in ImageList + internal Image GetImage(int index) + { + if (index < 0 || index >= this.Count) + throw new ArgumentOutOfRangeException("index"); + + CreateHandle(); + return (Image)list[index]; + } + + // For use in ImageListStreamer + internal Image[] ToArray() + { + Image[] images; + + // Handle is created even when the list is empty. + CreateHandle(); + images = new Image[list.Count]; + list.CopyTo(images); + return images; + } + #endregion // ImageCollection Internal Instance Methods + + #region ImageCollection Public Instance Methods + public void Add(Icon value) + { + Add(null, value); + } + + public void Add(Image value) + { + Add(null, value); + } + + public int Add(Image value, Color transparentColor) + { + return AddItem(null, new ImageListItem(value, transparentColor)); + } + + public void Add(string key, Icon icon) + { + // Argument has name icon but exceptions use name value. + AddItem(key, new ImageListItem(icon)); + } + + public void Add(string key, Image image) + { + // Argument has name image but exceptions use name value. + AddItem(key, new ImageListItem(image)); + } + + public void AddRange(Image[] images) + { + int index; + + if (images == null) + throw new ArgumentNullException("images"); + + for (index = 0; index < images.Length; index++) + Add(images[index]); + } + + public int AddStrip(Image value) + { + int width; + int imageWidth; + + if (value == null) + throw new ArgumentNullException("value"); + + if ((width = value.Width) == 0 || (width % (imageWidth = this.imageSize.Width)) != 0) + throw new ArgumentException("Width of image strip must be a positive multiple of ImageSize.Width.", "value"); + + if (value.Height != this.imageSize.Height) + throw new ArgumentException("Height of image strip must be equal to ImageSize.Height.", "value"); + + return AddItem(null, new ImageListItem(value, width / imageWidth)); + } + + public void Clear() + { + list.Clear(); + if (!this.handleCreated) + this.count = 0; + keys.Clear(); + } + + //[EditorBrowsable(EditorBrowsableState.Never)] + public bool Contains(Image image) + { + throw new NotSupportedException(); + } + + public bool ContainsKey(string key) + { + return IndexOfKey(key) != -1; + } + + public IEnumerator GetEnumerator() + { + Image[] images = new Image[this.Count]; + int index; + + if (images.Length != 0) { + // Handle is created only when there are images. + CreateHandle(); + + for (index = 0; index < images.Length; index++) + images[index] = (Image)((Image)list[index]).Clone(); + } + + return images.GetEnumerator(); + } + + //[EditorBrowsable(EditorBrowsableState.Never)] + public int IndexOf(Image image) + { + throw new NotSupportedException(); + } + + public int IndexOfKey(string key) + { + int index; + + if (key != null && key.Length != 0) { + // When last IndexOfKey was successful and the same key was + // assigned to an image with a lower index than the last + // result and the key of the last result equals to key + // argument the last result is returned. + + if (this.lastKeyIndex >= 0 && this.lastKeyIndex < this.Count && CompareKeys((string)keys[this.lastKeyIndex], key)) + return this.lastKeyIndex; + + // Duplicate keys are allowed and first match is returned. + for (index = 0; index < this.Count; index++) + if (CompareKeys((string)keys[index], key)) + return this.lastKeyIndex = index; + } + + return this.lastKeyIndex = -1; + } + + //[EditorBrowsable(EditorBrowsableState.Never)] + public void Remove(Image image) + { + throw new NotSupportedException(); + } + + public void RemoveAt(int index) + { + if (index < 0 || index >= this.Count) + throw new ArgumentOutOfRangeException("index"); + + CreateHandle(); + list.RemoveAt(index); + keys.RemoveAt(index); + if (Changed != null) + Changed (this, EventArgs.Empty); + } + + public void RemoveByKey(string key) + { + int index; + + if ((index = IndexOfKey(key)) != -1) + RemoveAt(index); + } + + public void SetKeyName(int index, string name) + { + // Only SetKeyName throws IndexOutOfRangeException. + if (index < 0 || index >= this.Count) + throw new IndexOutOfRangeException(); + + keys[index] = name; + } + #endregion // ImageCollection Public Instance Methods + + #region ImageCollection Interface Properties + object IList.this[int index] { + get { + return this[index]; + } + + set { + if (!(value is Image)) + throw new ArgumentException("value"); + + this[index] = (Image)value; + } + } + + bool IList.IsFixedSize { + get { + return false; + } + } + + bool ICollection.IsSynchronized { + get { + return false; + } + } + + object ICollection.SyncRoot { + get { + return this; + } + } + #endregion // ImageCollection Interface Properties + + #region ImageCollection Interface Methods + int IList.Add(object value) + { + int index; + + if (!(value is Image)) + throw new ArgumentException("value"); + + index = this.Count; + this.Add((Image)value); + return index; + } + + bool IList.Contains(object image) + { + return image is Image ? this.Contains ((Image) image) : false; + } + + int IList.IndexOf (object image) + { + return image is Image ? this.IndexOf ((Image) image) : -1; + } + + void IList.Insert(int index, object value) + { + throw new NotSupportedException(); + } + + void IList.Remove (object image) + { + if (image is Image) + this.Remove ((Image) image); + } + + void ICollection.CopyTo(Array dest, int index) + { + for (int imageIndex = 0; imageIndex < this.Count; imageIndex++) + dest.SetValue (this[imageIndex], index++); + } + #endregion // ImageCollection Interface Methods + } + #endregion // Sub-classes + + #region Public Constructors + public ImageList() + { + images = new ImageCollection(this); + } + + public ImageList(System.ComponentModel.IContainer container) : this() + { + container.Add(this); + } + #endregion // Public Constructors + + #region Private Instance Methods + private void OnRecreateHandle() + { + EventHandler eh = (EventHandler)(Events [RecreateHandleEvent]); + if (eh != null) + eh (this, EventArgs.Empty); + } + + // MS's TypeDescriptor stuff apparently uses + // non-public ShouldSerialize* methods, because it + // picks up this behavior even though the methods + // aren't public. we can't make them private, though, + // without adding compiler warnings. so, make then + // internal instead. + + internal bool ShouldSerializeTransparentColor () + { + return this.TransparentColor != Color.LightGray; + } + + internal bool ShouldSerializeColorDepth() + { + // ColorDepth is serialized in ImageStream when non-empty. + // It is serialized even if it has its default value when empty. + return images.Empty; + } + + internal bool ShouldSerializeImageSize() + { + // ImageSize is serialized in ImageStream when non-empty. + // It is serialized even if it has its default value when empty. + return images.Empty; + } + + internal void ResetColorDepth () + { + this.ColorDepth = DefaultColorDepth; + } + + internal void ResetImageSize () + { + this.ImageSize = DefaultImageSize; + } + + internal void ResetTransparentColor () + { + this.TransparentColor = Color.LightGray; + } + #endregion // Private Instance Methods + + #region Public Instance Properties + public ColorDepth ColorDepth { + get { + return images.ColorDepth; + } + + set { + images.ColorDepth = value; + } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Advanced)] + //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public IntPtr Handle { + get { + return images.Handle; + } + } + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Advanced)] + //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public bool HandleCreated { + get { + return images.HandleCreated; + } + } + + [DefaultValue(null)] + [MergableProperty(false)] + //[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public ImageCollection Images { + get { + return this.images; + } + } + + [Localizable(true)] + public Size ImageSize { + get { + return images.ImageSize; + } + + set { + images.ImageSize = value; + } + } + + [Browsable(false)] + [DefaultValue(null)] + //[EditorBrowsable(EditorBrowsableState.Advanced)] + public ImageListStreamer ImageStream { + get { + return images.ImageStream; + } + + set { + images.ImageStream = value; + } + } + + [Bindable(true)] + [DefaultValue(null)] + [Localizable(false)] + [TypeConverter(typeof(StringConverter))] + public object Tag { + get { + return this.tag; + } + + set { + this.tag = value; + } + } + + public Color TransparentColor { + get { + return images.TransparentColor; + } + + set { + images.TransparentColor = value; + } + } + #endregion // Public Instance Properties + + #region Public Instance Methods + public void Draw(Graphics g, Point pt, int index) + { + this.Draw(g, pt.X, pt.Y, index); + } + + public void Draw(Graphics g, int x, int y, int index) + { + g.DrawImage(images.GetImage(index), x, y); + } + + public void Draw(Graphics g, int x, int y, int width, int height, int index) + { + g.DrawImage(images.GetImage(index), x, y, width, height); + } + + public override string ToString() + { + return base.ToString() + " Images.Count: " + images.Count.ToString() + ", ImageSize: " + this.ImageSize.ToString(); + } + #endregion // Public Instance Methods + + #region Protected Instance Methods + protected override void Dispose(bool disposing) + { + if (disposing) + images.DestroyHandle(); + + base.Dispose(disposing); + } + #endregion // Protected Instance Methods + + #region Events + static object RecreateHandleEvent = new object (); + + [Browsable(false)] + //[EditorBrowsable(EditorBrowsableState.Advanced)] + public event EventHandler RecreateHandle { + add { Events.AddHandler (RecreateHandleEvent, value); } + remove { Events.RemoveHandler (RecreateHandleEvent, value); } + } + #endregion // Events + } +} diff --git a/source/ShiftUI/Internal/ImageListConverter.cs b/source/ShiftUI/Internal/ImageListConverter.cs new file mode 100644 index 0000000..8074d03 --- /dev/null +++ b/source/ShiftUI/Internal/ImageListConverter.cs @@ -0,0 +1,44 @@ +// 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. +// +// Authors: +// Matthias Felgner [email protected] +// + +// COMPLETE + +using System.ComponentModel; + + +namespace ShiftUI { + internal class ImageListConverter : ComponentConverter { + #region Constructors + public ImageListConverter() : base(typeof(ImageList)) { + } + #endregion Constructors + + #region Public Methods + public override bool GetPropertiesSupported(ITypeDescriptorContext context){ + return true; + } + #endregion Public Methods + } +} diff --git a/source/ShiftUI/Internal/ImageListStreamer.cs b/source/ShiftUI/Internal/ImageListStreamer.cs new file mode 100644 index 0000000..3186747 --- /dev/null +++ b/source/ShiftUI/Internal/ImageListStreamer.cs @@ -0,0 +1,338 @@ +// 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) 2002-2006 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) +// Gonzalo Paniagua Javier ([email protected]) +// +// Based on work done by: +// Dennis Hayes ([email protected]) +// Aleksey Ryabchuk ([email protected]) + +using System.IO; +using System.Drawing; +using System.Collections; +using System.Drawing.Imaging; +using System.Runtime.Serialization; +using System.Runtime.InteropServices; +using System; + + +namespace ShiftUI { + [Serializable] + public sealed class ImageListStreamer : ISerializable { + readonly ImageList.ImageCollection imageCollection; + Image [] images; + Size image_size; + Color back_color; + + internal ImageListStreamer (ImageList.ImageCollection imageCollection) + { + this.imageCollection = imageCollection; + } + + private ImageListStreamer (SerializationInfo info, StreamingContext context) + { + byte [] data = (byte []) info.GetValue ("Data", typeof (byte [])); + if (data == null || data.Length <= 4) { // 4 is the signature + return; + } + + // check the signature ( 'MSFt' ) + if (data [0] != 77 || data [1] != 83 || data [2] != 70 || data [3] != 116) { + return; + } + + MemoryStream decoded = GetDecodedStream (data, 4, data.Length - 4); + decoded.Position = 4; // jumps over 'magic' and 'version', which are 16-bits each + + BinaryReader reader = new BinaryReader (decoded); + ushort nimages = reader.ReadUInt16 (); + reader.ReadUInt16 (); // cMaxImage + ushort grow = reader.ReadUInt16 (); // cGrow + ushort cx = reader.ReadUInt16 (); + ushort cy = reader.ReadUInt16 (); + uint bkcolor = reader.ReadUInt32 (); + back_color = Color.FromArgb ((int) bkcolor); + reader.ReadUInt16 (); // flags + + short [] ovls = new short [4]; + for (int i = 0; i < 4; i++) { + ovls[i] = reader.ReadInt16 (); + } + + byte [] decoded_buffer = decoded.GetBuffer (); + int bmp_offset = 28; + // FileSize field from the bitmap file header + int filesize = decoded_buffer [bmp_offset + 2] + (decoded_buffer [bmp_offset + 3] << 8) + + (decoded_buffer [bmp_offset + 4] << 16) + (decoded_buffer [bmp_offset + 5] << 24); + // ImageSize field from the info header (can be 0) + int imagesize = decoded_buffer [bmp_offset + 34] + (decoded_buffer [bmp_offset + 35] << 8) + + (decoded_buffer [bmp_offset + 36] << 16) + (decoded_buffer [bmp_offset + 37] << 24); + + int bmp_length = imagesize + filesize; + MemoryStream bmpms = new MemoryStream (decoded_buffer, bmp_offset, bmp_length); + Bitmap bmp = null; + Bitmap mask = null; + bmp = new Bitmap (bmpms); + MemoryStream mask_stream = new MemoryStream (decoded_buffer, + bmp_offset + bmp_length, + (int) (decoded.Length - bmp_offset - bmp_length)); + + if (mask_stream.Length > 0) + mask = new Bitmap (mask_stream); + + if (bkcolor == 0xFFFFFFFF) + back_color = bmp.GetPixel (0, 0); + + if (mask != null) { + int width = bmp.Width; + int height = bmp.Height; + Bitmap newbmp = new Bitmap (bmp); + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + Color mcolor = mask.GetPixel (x, y); + if (mcolor.B != 0) { + newbmp.SetPixel (x, y, Color.Transparent); + } + } + } + bmp.Dispose (); + bmp = newbmp; + mask.Dispose (); + mask = null; + } + images = new Image [nimages]; + image_size = new Size (cx, cy); + Rectangle dest_rect = new Rectangle (0, 0, cx, cy); + if (grow * bmp.Width > cx) // Some images store a wrong 'grow' factor + grow = (ushort) (bmp.Width / cx); + + for (int r = 0 ; r < nimages ; r++) { + int col = r % grow; + int row = r / grow; + Rectangle area = new Rectangle (col * cx, row * cy, cx, cy); + Bitmap b = new Bitmap (cx, cy); + using (Graphics g = Graphics.FromImage (b)) { + g.DrawImage (bmp, dest_rect, area, GraphicsUnit.Pixel); + } + + images [r] = b; + } + bmp.Dispose (); + } + + /* + static void WriteToFile (MemoryStream st) + { + st.Position = 0; + FileStream fs = File.OpenWrite (Path.GetTempFileName ()); + Console.WriteLine ("Writing to {0}", fs.Name); + st.WriteTo (fs); + fs.Close (); + } + */ + + static byte [] header = new byte []{ 77, 83, 70, 116, 73, 76, 1, 1 }; + public void GetObjectData (SerializationInfo si, StreamingContext context) + { + MemoryStream stream = new MemoryStream (); + BinaryWriter writer = new BinaryWriter (stream); + writer.Write (header); + + Image [] images = (imageCollection != null) ? imageCollection.ToArray () : this.images; + int cols = 4; + int rows = images.Length / cols; + if (images.Length % cols > 0) + ++rows; + + writer.Write ((ushort) images.Length); + writer.Write ((ushort) images.Length); + writer.Write ((ushort) 0x4); + writer.Write ((ushort) (images [0].Width)); + writer.Write ((ushort) (images [0].Height)); + writer.Write (0xFFFFFFFF); //BackColor.ToArgb ()); //FIXME: should set the right one here. + writer.Write ((ushort) 0x21); + for (int i = 0; i < 4; i++) + writer.Write ((short) -1); + + Bitmap main = new Bitmap (cols * ImageSize.Width, rows * ImageSize.Height); + using (Graphics g = Graphics.FromImage (main)) { + g.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (BackColor), 0, 0, + main.Width, main.Height); + for (int i = 0; i < images.Length; i++) { + g.DrawImage (images [i], (i % cols) * ImageSize.Width, + (i / cols) * ImageSize.Height); + } + } + + MemoryStream tmp = new MemoryStream (); + main.Save (tmp, ImageFormat.Bmp); + tmp.WriteTo (stream); + + Bitmap mask = Get1bppMask (main); + main.Dispose (); + main = null; + + tmp = new MemoryStream (); + mask.Save (tmp, ImageFormat.Bmp); + tmp.WriteTo (stream); + mask.Dispose (); + + stream = GetRLEStream (stream, 4); + si.AddValue ("Data", stream.ToArray (), typeof (byte [])); + } + + unsafe Bitmap Get1bppMask (Bitmap main) + { + Rectangle rect = new Rectangle (0, 0, main.Width, main.Height); + Bitmap result = new Bitmap (main.Width, main.Height, PixelFormat.Format1bppIndexed); + BitmapData dresult = result.LockBits (rect, ImageLockMode.ReadWrite, PixelFormat.Format1bppIndexed); + + int w = images [0].Width; + int h = images [0].Height; + byte *scan = (byte *) dresult.Scan0.ToPointer (); + int stride = dresult.Stride; + Bitmap current = null; + for (int idx = 0; idx < images.Length; idx++) { + current = (Bitmap) images [idx]; + // Hack for newly added images. + // Probably has to be done somewhere else. + Color c1 = current.GetPixel (0, 0); + if (c1.A != 0 && c1 == back_color) + current.MakeTransparent (back_color); + // + } + + int yidx = 0; + int imgidx = 0; + int localy = 0; + int localx = 0; + int factor_y = 0; + int factor_x = 0; + for (int y = 0; y < main.Height; y++) { + if (localy == h) { + localy = 0; + factor_y += 4; + } + factor_x = 0; + localx = 0; + for (int x = 0; x < main.Width; x++) { + if (localx == w) { + localx = 0; + factor_x++; + } + imgidx = factor_y + factor_x; + if (imgidx >= images.Length) + break; + current = (Bitmap) images [imgidx]; + Color color = current.GetPixel (localx, localy); + if (color.A == 0) { + int ptridx = yidx + (x >> 3); + scan [ptridx] |= (byte) (0x80 >> (x & 7)); + } + localx++; + } + if (imgidx >= images.Length) + break; + yidx += stride; + localy++; + } + result.UnlockBits (dresult); + + return result; + } + + static MemoryStream GetDecodedStream (byte [] bytes, int offset, int size) + { + byte [] buffer = new byte [512]; + int position = 0; + int count, data; + MemoryStream result = new MemoryStream (); + while (size > 0) { + count = (int) bytes [offset++]; + data = (int) bytes [offset++]; + if ((512 - count) < position) { + result.Write (buffer, 0, position); + position = 0; + } + + for (int i = 0; i < count; i++) + buffer [position++] = (byte) data; + size -= 2; + } + + if (position > 0) + result.Write (buffer, 0, position); + + result.Position = 0; + return result; + } + + //TODO: OptimizeMe + static MemoryStream GetRLEStream (MemoryStream input, int start) + { + MemoryStream result = new MemoryStream (); + byte [] ibuffer = input.GetBuffer (); + result.Write (ibuffer, 0, start); + input.Position = start; + + int prev = -1; + int count = 0; + int current; + while ((current = input.ReadByte ()) != -1) { + if (prev != current || count == 255) { + if (prev != -1) { + result.WriteByte ((byte) count); + result.WriteByte ((byte) prev); + } + prev = current; + count = 0; + } + count++; + } + + if (count > 0) { + result.WriteByte ((byte) count); + result.WriteByte ((byte) current); + } + + return result; + } + + internal Image [] Images { + get { return images; } + } + + internal Size ImageSize { + get { return image_size; } + } + + internal ColorDepth ColorDepth { + get { return ColorDepth.Depth32Bit; } + } + + internal Color BackColor { + get { return back_color; } + } + } +} + diff --git a/source/ShiftUI/Internal/InternalWindowManager.cs b/source/ShiftUI/Internal/InternalWindowManager.cs new file mode 100644 index 0000000..95fae49 --- /dev/null +++ b/source/ShiftUI/Internal/InternalWindowManager.cs @@ -0,0 +1,1211 @@ +// 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: +// Jackson Harper ([email protected]) +// +// + + +using System; +using System.Drawing; +using System.Runtime.InteropServices; + + +namespace ShiftUI { + + internal abstract class InternalWindowManager { + private TitleButtons title_buttons; + internal Form form; + + // moving windows + internal Point start; + internal State state; + protected Point clicked_point; + private FormPos sizing_edge; + internal Rectangle virtual_position; + + private Rectangle normal_bounds; + private Rectangle iconic_bounds; + + + public enum State { + Idle, + Moving, + Sizing, + } + + [Flags] + public enum FormPos { + None, + + TitleBar = 1, + + Top = 2, + Left = 4, + Right = 8, + Bottom = 16, + + TopLeft = Top | Left, + TopRight = Top | Right, + + BottomLeft = Bottom | Left, + BottomRight = Bottom | Right, + + AnyEdge = Top | Left | Right | Bottom, + } + + public InternalWindowManager (Form form) + { + this.form = form; + + form.SizeChanged += new EventHandler (FormSizeChangedHandler); + + title_buttons = new TitleButtons (form); + ThemeEngine.Current.ManagedWindowSetButtonLocations (this); + } + + public Form Form { + get { return form; } + } + + public int IconWidth { + get { return TitleBarHeight - 5; } + } + + public TitleButtons TitleButtons { + get { + return title_buttons; + } + } + internal Rectangle NormalBounds { + get { + return normal_bounds; + } + set { + normal_bounds = value; + } + } + internal Size IconicSize { + get { + return SystemInformation.MinimizedWindowSize; + } + } + + internal Rectangle IconicBounds { + get { + if (iconic_bounds == Rectangle.Empty) + return Rectangle.Empty; + Rectangle result = iconic_bounds; + result.Y = Form.Parent.ClientRectangle.Bottom - iconic_bounds.Y; + return result; + } + set { + iconic_bounds = value; + iconic_bounds.Y = Form.Parent.ClientRectangle.Bottom - iconic_bounds.Y; + } + } + + internal virtual Rectangle MaximizedBounds { + get { + return Form.Parent.ClientRectangle; + } + } + + public virtual void UpdateWindowState (FormWindowState old_window_state, FormWindowState new_window_state, bool force) + { + if (old_window_state == FormWindowState.Normal) { + NormalBounds = form.Bounds; + } else if (old_window_state == FormWindowState.Minimized) { + IconicBounds = form.Bounds; + } + + switch (new_window_state) { + case FormWindowState.Minimized: + if (IconicBounds == Rectangle.Empty) { + Size size = IconicSize; + Point location = new Point (0, Form.Parent.ClientSize.Height - size.Height); + IconicBounds = new Rectangle (location, size); + } + form.Bounds = IconicBounds; + break; + case FormWindowState.Maximized: + form.Bounds = MaximizedBounds; + break; + case FormWindowState.Normal: + form.Bounds = NormalBounds; + break; + } + + UpdateWindowDecorations (new_window_state); + form.ResetCursor (); + } + + public virtual void UpdateWindowDecorations (FormWindowState window_state) + { + ThemeEngine.Current.ManagedWindowSetButtonLocations (this); + if (form.IsHandleCreated) + XplatUI.RequestNCRecalc (form.Handle); + } + + public virtual bool WndProc (ref Message m) + { +#if debug + Console.WriteLine(DateTime.Now.ToLongTimeString () + " " + this.GetType () .Name + " (Handle={0},Text={1}) received message {2}", form.IsHandleCreated ? form.Handle : IntPtr.Zero, form.Text, m.ToString ()); +#endif + + switch ((Msg)m.Msg) { + + + // The mouse handling messages are actually + // not WM_NC* messages except for the first button and NCMOVEs + // down because we capture on the form + + case Msg.WM_MOUSEMOVE: + return HandleMouseMove (form, ref m); + + case Msg.WM_LBUTTONUP: + HandleLButtonUp (ref m); + break; + + case Msg.WM_RBUTTONDOWN: + return HandleRButtonDown (ref m); + + case Msg.WM_LBUTTONDOWN: + return HandleLButtonDown (ref m); + + case Msg.WM_LBUTTONDBLCLK: + return HandleLButtonDblClick (ref m); + + case Msg.WM_PARENTNOTIFY: + if (Widget.LowOrder(m.WParam.ToInt32()) == (int) Msg.WM_LBUTTONDOWN) + Activate (); + break; + + case Msg.WM_NCHITTEST: + return HandleNCHitTest (ref m); + + // Return true from these guys, otherwise win32 will mess up z-order + case Msg.WM_NCLBUTTONUP: + HandleNCLButtonUp (ref m); + return true; + + case Msg.WM_NCLBUTTONDOWN: + HandleNCLButtonDown (ref m); + return true; + + case Msg.WM_NCMOUSEMOVE: + HandleNCMouseMove (ref m); + return true; + + case Msg.WM_NCLBUTTONDBLCLK: + HandleNCLButtonDblClick (ref m); + break; + + case Msg.WM_NCMOUSELEAVE: + HandleNCMouseLeave (ref m); + break; + + case Msg.WM_MOUSELEAVE: + HandleMouseLeave (ref m); + break; + + case Msg.WM_NCCALCSIZE: + return HandleNCCalcSize (ref m); + + case Msg.WM_NCPAINT: + return HandleNCPaint (ref m); + } + + return false; + } + + protected virtual bool HandleNCPaint (ref Message m) + { + PaintEventArgs pe = XplatUI.PaintEventStart (ref m, form.Handle, false); + + Rectangle clip; + + if (form.ActiveMenu != null) { + Point pnt; + + pnt = GetMenuOrigin (); + + // The entire menu has to be in the clip rectangle because the + // control buttons are right-aligned and otherwise they would + // stay painted when the window gets resized. + clip = new Rectangle (pnt.X, pnt.Y, form.ClientSize.Width, 0); + clip = Rectangle.Union (clip, pe.ClipRectangle); + pe.SetClip (clip); + pe.Graphics.SetClip (clip); + + form.ActiveMenu.Draw (pe, new Rectangle (pnt.X, pnt.Y, form.ClientSize.Width, 0)); + } + if (HasBorders || IsMinimized && !(Form.IsMdiChild && IsMaximized)) { + // clip region is not correct on win32. + // use the entire form's area. + clip = new Rectangle (0, 0, form.Width, form.Height); + ThemeEngine.Current.DrawManagedWindowDecorations (pe.Graphics, clip, this); + } + XplatUI.PaintEventEnd (ref m, form.Handle, false); + return true; + } + + protected virtual bool HandleNCCalcSize (ref Message m) + { + XplatUIWin32.NCCALCSIZE_PARAMS ncp; + XplatUIWin32.RECT rect; + + if (m.WParam == (IntPtr)1) { + ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure (m.LParam, + typeof (XplatUIWin32.NCCALCSIZE_PARAMS)); + + ncp.rgrc1 = NCCalcSize (ncp.rgrc1); + + Marshal.StructureToPtr (ncp, m.LParam, true); + } else { + rect = (XplatUIWin32.RECT) Marshal.PtrToStructure (m.LParam, typeof (XplatUIWin32.RECT)); + + rect = NCCalcSize (rect); + + Marshal.StructureToPtr (rect, m.LParam, true); + } + + return true; + } + + protected virtual XplatUIWin32.RECT NCCalcSize (XplatUIWin32.RECT proposed_window_rect) + { + int bw = ThemeEngine.Current.ManagedWindowBorderWidth (this); + + if (HasBorders) { + proposed_window_rect.top += TitleBarHeight + bw; + proposed_window_rect.bottom -= bw; + proposed_window_rect.left += bw; + proposed_window_rect.right -= bw; + } + + if (XplatUI.RequiresPositiveClientAreaSize) { + // This is necessary for Linux, can't handle <= 0-sized + // client areas correctly. + if (proposed_window_rect.right <= proposed_window_rect.left) { + proposed_window_rect.right += proposed_window_rect.left - proposed_window_rect.right + 1; + } + if (proposed_window_rect.top >= proposed_window_rect.bottom) { + proposed_window_rect.bottom += proposed_window_rect.top - proposed_window_rect.bottom + 1; + } + } + + return proposed_window_rect; + } + + protected virtual bool HandleNCHitTest (ref Message m) + { + + int x = Widget.LowOrder ((int)m.LParam.ToInt32 ()); + int y = Widget.HighOrder ((int)m.LParam.ToInt32 ()); + + NCPointToClient (ref x, ref y); + + FormPos pos = FormPosForCoords (x, y); + + if (pos == FormPos.TitleBar) { + m.Result = new IntPtr ((int)HitTest.HTCAPTION); + return true; + } + + if (!IsSizable) + return false; + + switch (pos) { + case FormPos.Top: + m.Result = new IntPtr ((int)HitTest.HTTOP); + break; + case FormPos.Left: + m.Result = new IntPtr ((int)HitTest.HTLEFT); + break; + case FormPos.Right: + m.Result = new IntPtr ((int)HitTest.HTRIGHT); + break; + case FormPos.Bottom: + m.Result = new IntPtr ((int)HitTest.HTBOTTOM); + break; + case FormPos.TopLeft: + m.Result = new IntPtr ((int)HitTest.HTTOPLEFT); + break; + case FormPos.TopRight: + m.Result = new IntPtr ((int)HitTest.HTTOPRIGHT); + break; + case FormPos.BottomLeft: + m.Result = new IntPtr ((int)HitTest.HTBOTTOMLEFT); + break; + case FormPos.BottomRight: + m.Result = new IntPtr ((int)HitTest.HTBOTTOMRIGHT); + break; + default: + // We return false so that DefWndProc handles things + return false; + } + return true; + } + + public virtual void UpdateBorderStyle (FormBorderStyle border_style) + { + if (form.IsHandleCreated) { + XplatUI.SetBorderStyle (form.Handle, border_style); + } + + if (ShouldRemoveWindowManager (border_style)) { + form.RemoveWindowManager (); + return; + } + + ThemeEngine.Current.ManagedWindowSetButtonLocations (this); + } + + + + public virtual void SetWindowState (FormWindowState old_state, FormWindowState window_state) + { + UpdateWindowState (old_state, window_state, false); + } + + public virtual FormWindowState GetWindowState () + { + return form.window_state; + } + + public virtual void PointToClient (ref int x, ref int y) + { + // toolwindows stay in screencoords we just have to make sure + // they obey the working area + Rectangle working = SystemInformation.WorkingArea; + + if (x > working.Right) + x = working.Right; + if (x < working.Left) + x = working.Left; + + if (y < working.Top) + y = working.Top; + if (y > working.Bottom) + y = working.Bottom; + } + + public virtual void PointToScreen (ref int x, ref int y) + { + XplatUI.ClientToScreen (form.Handle, ref x, ref y); + } + + protected virtual bool ShouldRemoveWindowManager (FormBorderStyle style) + { + return style != FormBorderStyle.FixedToolWindow && style != FormBorderStyle.SizableToolWindow; + } + + public bool IconRectangleContains (int x, int y) + { + if (!ShowIcon) + return false; + + Rectangle icon = ThemeEngine.Current.ManagedWindowGetTitleBarIconArea (this); + return icon.Contains (x, y); + } + + public bool ShowIcon { + get { + if (!Form.ShowIcon) + return false; + if (!HasBorders) + return false; + if (IsMinimized) + return true; + if (IsToolWindow || Form.FormBorderStyle == FormBorderStyle.FixedDialog) + return false; + return true; + } + } + + protected virtual void Activate () + { + form.Invalidate (true); + form.Update (); + } + + public virtual bool IsActive { + get { + return true; + } + } + + + private void FormSizeChangedHandler (object sender, EventArgs e) + { + if (form.IsHandleCreated) { + ThemeEngine.Current.ManagedWindowSetButtonLocations (this); + XplatUI.InvalidateNC (form.Handle); + } + } + + protected virtual bool HandleRButtonDown (ref Message m) + { + Activate (); + return false; + } + + protected virtual bool HandleLButtonDown (ref Message m) + { + Activate (); + return false; + } + + protected virtual bool HandleLButtonDblClick(ref Message m) + { + return false; + } + + protected virtual bool HandleNCMouseLeave (ref Message m) + { + int x = Widget.LowOrder ((int)m.LParam.ToInt32 ()); + int y = Widget.HighOrder ((int)m.LParam.ToInt32 ()); + + NCPointToClient (ref x, ref y); + FormPos pos = FormPosForCoords (x, y); + + if (pos != FormPos.TitleBar) { + HandleTitleBarLeave (x, y); + return true; + } + + return true; + } + + protected virtual bool HandleNCMouseMove (ref Message m) + { + int x = Widget.LowOrder((int)m.LParam.ToInt32( )); + int y = Widget.HighOrder((int)m.LParam.ToInt32( )); + + NCPointToClient (ref x, ref y); + FormPos pos = FormPosForCoords (x, y); + + if (pos == FormPos.TitleBar) { + HandleTitleBarMouseMove (x, y); + return true; + } + + if (form.ActiveMenu != null && XplatUI.IsEnabled (form.Handle)) { + MouseEventArgs mea = new MouseEventArgs (Form.FromParamToMouseButtons (m.WParam.ToInt32 ()), form.mouse_clicks, x, y, 0); + form.ActiveMenu.OnMouseMove (form, mea); + } + + return true; + + } + + protected virtual bool HandleNCLButtonDown (ref Message m) + { + Activate (); + + start = Cursor.Position; + virtual_position = form.Bounds; + + int x = Widget.LowOrder ((int) m.LParam.ToInt32 ()); + int y = Widget.HighOrder ((int) m.LParam.ToInt32 ()); + + // Need to adjust because we are in NC land + NCPointToClient (ref x, ref y); + FormPos pos = FormPosForCoords (x, y); + + if (form.ActiveMenu != null && XplatUI.IsEnabled (form.Handle)) { + MouseEventArgs mea = new MouseEventArgs (Form.FromParamToMouseButtons (m.WParam.ToInt32 ()), form.mouse_clicks, x, y - TitleBarHeight, 0); + form.ActiveMenu.OnMouseDown (form, mea); + } + + if (pos == FormPos.TitleBar) { + HandleTitleBarDown (x, y); + return true; + } + + if (IsSizable) { + if ((pos & FormPos.AnyEdge) == 0) + return false; + + virtual_position = form.Bounds; + state = State.Sizing; + sizing_edge = pos; + form.Capture = true; + return true; + } + + return false; + } + + protected virtual void HandleNCLButtonDblClick (ref Message m) + { + int x = Widget.LowOrder ((int)m.LParam.ToInt32 ()); + int y = Widget.HighOrder ((int)m.LParam.ToInt32 ()); + + // Need to adjust because we are in NC land + NCPointToClient (ref x, ref y); + + FormPos pos = FormPosForCoords (x, y); + if (pos == FormPos.TitleBar || pos == FormPos.Top) + HandleTitleBarDoubleClick (x, y); + + } + + protected virtual void HandleTitleBarDoubleClick (int x, int y) + { + + } + + protected virtual void HandleTitleBarLeave (int x, int y) + { + title_buttons.MouseLeave (x, y); + } + + protected virtual void HandleTitleBarMouseMove (int x, int y) + { + if (title_buttons.MouseMove (x, y)) + XplatUI.InvalidateNC (form.Handle); + } + + protected virtual void HandleTitleBarUp (int x, int y) + { + title_buttons.MouseUp (x, y); + + return; + } + + protected virtual void HandleTitleBarDown (int x, int y) + { + title_buttons.MouseDown (x, y); + + if (!TitleButtons.AnyPushedTitleButtons && !IsMaximized) { + state = State.Moving; + clicked_point = new Point (x, y); + if (form.Parent != null) { + form.CaptureWithConfine (form.Parent); + } else { + form.Capture = true; + } + } + + XplatUI.InvalidateNC (form.Handle); + } + + private bool HandleMouseMove (Form form, ref Message m) + { + switch (state) { + case State.Moving: + HandleWindowMove (m); + return true; + case State.Sizing: + HandleSizing (m); + return true; + } + + return false; + } + + private void HandleMouseLeave (ref Message m) + { + form.ResetCursor (); + } + + protected virtual void HandleWindowMove (Message m) + { + Point move = MouseMove (Cursor.Position); + + UpdateVP (virtual_position.X + move.X, virtual_position.Y + move.Y, + virtual_position.Width, virtual_position.Height); + } + + private void HandleSizing (Message m) + { + Rectangle pos = virtual_position; + int mw; + int mh; + if (IsToolWindow) { + int border_width = BorderWidth; + mw = 2 * (border_width + Theme.ManagedWindowSpacingAfterLastTitleButton) + ThemeEngine.Current.ManagedWindowButtonSize (this).Width; + mh = 2 * border_width + TitleBarHeight; + } else { + Size minimum_size = SystemInformation.MinWindowTrackSize; + mw = minimum_size.Width; + mh = minimum_size.Height; + } + int x = Cursor.Position.X; + int y = Cursor.Position.Y; + + PointToClient (ref x, ref y); + + if ((sizing_edge & FormPos.Top) != 0) { + if (pos.Bottom - y < mh) + y = pos.Bottom - mh; + pos.Height = pos.Bottom - y; + pos.Y = y; + } else if ((sizing_edge & FormPos.Bottom) != 0) { + int height = y - pos.Top; + if (height <= mh) + height = mh; + pos.Height = height; + } + + if ((sizing_edge & FormPos.Left) != 0) { + if (pos.Right - x < mw) + x = pos.Right - mw; + pos.Width = pos.Right - x; + pos.X = x; + } else if ((sizing_edge & FormPos.Right) != 0) { + int width = x - form.Left; + if (width <= mw) + width = mw; + pos.Width = width; + } + + UpdateVP (pos); + } + + public bool IsMaximized { + get { return GetWindowState () == FormWindowState.Maximized; } + } + + public bool IsMinimized { + get { return GetWindowState () == FormWindowState.Minimized; } + } + + public bool IsSizable { + get { + switch (form.FormBorderStyle) { + case FormBorderStyle.Sizable: + case FormBorderStyle.SizableToolWindow: + return (form.window_state != FormWindowState.Minimized); + default: + return false; + } + } + } + + public bool HasBorders { + get { + return form.FormBorderStyle != FormBorderStyle.None; + } + } + + public bool IsToolWindow { + get { + if (form.FormBorderStyle == FormBorderStyle.SizableToolWindow || + form.FormBorderStyle == FormBorderStyle.FixedToolWindow || + form.GetCreateParams().IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) + return true; + return false; + } + } + + public int TitleBarHeight { + get { + return ThemeEngine.Current.ManagedWindowTitleBarHeight (this); + } + } + + public int BorderWidth { + get { + return ThemeEngine.Current.ManagedWindowBorderWidth (this); + } + } + + public virtual int MenuHeight { + get { + return (form.Menu != null ? ThemeEngine.Current.MenuHeight : 0); + } + } + + protected void UpdateVP (Rectangle r) + { + UpdateVP (r.X, r.Y, r.Width, r.Height); + } + + protected void UpdateVP (Point loc, int w, int h) + { + UpdateVP (loc.X, loc.Y, w, h); + } + + protected void UpdateVP (int x, int y, int w, int h) + { + virtual_position.X = x; + virtual_position.Y = y; + virtual_position.Width = w; + virtual_position.Height = h; + + DrawVirtualPosition (virtual_position); + } + + protected virtual void HandleLButtonUp (ref Message m) + { + if (state == State.Idle) + return; + + ClearVirtualPosition (); + + form.Capture = false; + if (state == State.Moving && form.Location != virtual_position.Location) + form.Location = virtual_position.Location; + else if (state == State.Sizing && form.Bounds != virtual_position) + form.Bounds = virtual_position; + state = State.Idle; + + OnWindowFinishedMoving (); + } + + private bool HandleNCLButtonUp (ref Message m) + { + if (form.Capture) { + ClearVirtualPosition (); + + form.Capture = false; + state = State.Idle; + if (form.MdiContainer != null) + form.MdiContainer.SizeScrollBars(); + } + + int x = Widget.LowOrder ((int) m.LParam.ToInt32 ()); + int y = Widget.HighOrder ((int) m.LParam.ToInt32 ()); + + NCPointToClient (ref x, ref y); + FormPos pos = FormPosForCoords (x, y); + + if (pos == FormPos.TitleBar) { + HandleTitleBarUp (x, y); + return true; + } + + return true; + } + + protected void DrawTitleButton (Graphics dc, TitleButton button, Rectangle clip) + { + if (!button.Rectangle.IntersectsWith (clip)) + return; + + ThemeEngine.Current.ManagedWindowDrawMenuButton (dc, button, clip, this); + } + + public virtual void DrawMaximizedButtons (object sender, PaintEventArgs pe) + { + } + + protected Point MouseMove (Point pos) + { + return new Point (pos.X - start.X, pos.Y - start.Y); + } + + protected virtual void DrawVirtualPosition (Rectangle virtual_position) + { + form.Bounds = virtual_position; + start = Cursor.Position; + } + + protected virtual void ClearVirtualPosition () + { + + } + + protected virtual void OnWindowFinishedMoving () + { + } + + protected virtual void NCPointToClient(ref int x, ref int y) { + form.PointToClient(ref x, ref y); + NCClientToNC (ref x, ref y); + } + + protected virtual void NCClientToNC (ref int x, ref int y) { + y += TitleBarHeight; + y += BorderWidth; + y += MenuHeight; + } + + internal Point GetMenuOrigin () + { + return new Point (BorderWidth, BorderWidth + TitleBarHeight); + } + + protected FormPos FormPosForCoords (int x, int y) + { + int bw = BorderWidth; + if (y < TitleBarHeight + bw) { + // Console.WriteLine ("A"); + if (y > bw && x > bw && + x < form.Width - bw) + return FormPos.TitleBar; + + if (x < bw || (x < 20 && y < bw)) + return FormPos.TopLeft; + + if (x > form.Width - bw || + (x > form.Width - 20 && y < bw)) + return FormPos.TopRight; + + if (y < bw) + return FormPos.Top; + + } else if (y > form.Height - 20) { + // Console.WriteLine ("B"); + if (x < bw || + (x < 20 && y > form.Height - bw)) + return FormPos.BottomLeft; + + if (x > form.Width - (bw * 2) || + (x > form.Width - 20 && + y > form.Height - bw)) + return FormPos.BottomRight; + + if (y > form.Height - (bw * 2)) + return FormPos.Bottom; + + + } else if (x < bw) { + // Console.WriteLine ("C"); + return FormPos.Left; + } else if (x > form.Width - (bw * 2)) { +// Console.WriteLine ("D"); + return FormPos.Right; + } else { + // Console.WriteLine ("E {0}", form.Width - bw); + } + + return FormPos.None; + } + } + internal class TitleButton + { + public Rectangle Rectangle; + public ButtonState State; + public CaptionButton Caption; + private EventHandler Clicked; + public bool Visible; + bool entered; + + public TitleButton (CaptionButton caption, EventHandler clicked) + { + Caption = caption; + Clicked = clicked; + } + + public void OnClick () + { + if (Clicked != null) { + Clicked (this, EventArgs.Empty); + } + } + + public bool Entered { + get { return entered; } + set { entered = value; } + } + } + + internal class TitleButtons : System.Collections.IEnumerable + { + public TitleButton MinimizeButton; + public TitleButton MaximizeButton; + public TitleButton RestoreButton; + public TitleButton CloseButton; + public TitleButton HelpButton; + + public TitleButton [] AllButtons; + public bool Visible; + + private ToolTip.ToolTipWindow tooltip; + private Timer tooltip_timer; + private TitleButton tooltip_hovered_button; + private TitleButton tooltip_hidden_button; + private const int tooltip_hide_interval = 3000; + private const int tooltip_show_interval = 1000; + private Form form; + + public TitleButtons (Form frm) + { + this.form = frm; + this.Visible = true; + + MinimizeButton = new TitleButton (CaptionButton.Minimize, new EventHandler (ClickHandler)); + MaximizeButton = new TitleButton (CaptionButton.Maximize, new EventHandler (ClickHandler)); + RestoreButton = new TitleButton (CaptionButton.Restore, new EventHandler (ClickHandler)); + CloseButton = new TitleButton (CaptionButton.Close, new EventHandler (ClickHandler)); + HelpButton = new TitleButton (CaptionButton.Help, new EventHandler (ClickHandler)); + + AllButtons = new TitleButton [] { MinimizeButton, MaximizeButton, RestoreButton, CloseButton, HelpButton }; + } + + private void ClickHandler (object sender, EventArgs e) + { + if (!Visible) { + return; + } + + TitleButton button = (TitleButton) sender; + + switch (button.Caption) { + case CaptionButton.Close: + form.Close (); + break; + case CaptionButton.Help: + Console.WriteLine ("Help not implemented."); + break; + case CaptionButton.Maximize: + form.WindowState = FormWindowState.Maximized; + break; + case CaptionButton.Minimize: + form.WindowState = FormWindowState.Minimized; + break; + case CaptionButton.Restore: + form.WindowState = FormWindowState.Normal; + break; + } + } + + public TitleButton FindButton (int x, int y) + { + if (!Visible) { + return null; + } + + foreach (TitleButton button in AllButtons) { + if (button.Visible && button.Rectangle.Contains (x, y)) { + return button; + } + } + return null; + } + + public bool AnyPushedTitleButtons { + get { + if (!Visible) { + return false; + } + + foreach (TitleButton button in AllButtons) { + if (button.Visible && button.State == ButtonState.Pushed) { + return true; + } + } + return false; + } + } + + #region IEnumerable Members + + public System.Collections.IEnumerator GetEnumerator () + { + return AllButtons.GetEnumerator (); + } + #endregion + + #region ToolTip helpers + // Called from MouseMove if mouse is over a button + public void ToolTipStart (TitleButton button) + { + tooltip_hovered_button = button; + + if (tooltip_hovered_button == tooltip_hidden_button) + return; + tooltip_hidden_button = null; + + if (tooltip != null && tooltip.Visible) + ToolTipShow (true); + + if (tooltip_timer == null) { + + tooltip_timer = new Timer (); + tooltip_timer.Tick += new EventHandler (ToolTipTimerTick); + } + + tooltip_timer.Interval = tooltip_show_interval; + tooltip_timer.Start (); + tooltip_hovered_button = button; + } + + public void ToolTipTimerTick (object sender, EventArgs e) + { + if (tooltip_timer.Interval == tooltip_hide_interval) { + tooltip_hidden_button = tooltip_hovered_button; + ToolTipHide (false); + } else { + ToolTipShow (false); + } + } + // Called from timer (with only_refresh = false) + // Called from ToolTipStart if tooltip is already shown (with only_refresh = true) + public void ToolTipShow (bool only_refresh) + { + if (!form.Visible) + return; + + string text = String.Format (tooltip_hovered_button.Caption.ToString ()); + + tooltip_timer.Interval = tooltip_hide_interval; + tooltip_timer.Enabled = true; + + if (only_refresh && (tooltip == null || !tooltip.Visible)) { + return; + } + + if (tooltip == null) + tooltip = new ToolTip.ToolTipWindow (); + else if (tooltip.Text == text && tooltip.Visible) + return; + else if (tooltip.Visible) + tooltip.Visible = false; + + if (form.WindowState == FormWindowState.Maximized && form.MdiParent != null) + tooltip.Present (form.MdiParent, text); + else + tooltip.Present (form, text); + + } + + // Called from MouseLeave (with reset_hidden_button = true) + // Called from MouseDown (with reset_hidden_button = false) + // Called from MouseMove if mouse isn't over any button (with reset_hidden_button = false) + // Called from Timer if hiding (with reset_hidden_button = false) + public void ToolTipHide (bool reset_hidden_button) + { + if (tooltip_timer != null) + tooltip_timer.Enabled = false; + if (tooltip != null && tooltip.Visible) + tooltip.Visible = false; + if (reset_hidden_button) + tooltip_hidden_button = null; + } + #endregion + + public bool MouseMove (int x, int y) + { + if (!Visible) { + return false; + } + + bool any_change = false; + bool any_pushed_buttons = AnyPushedTitleButtons; + bool any_tooltip = false; + TitleButton over_button = FindButton (x, y); + + foreach (TitleButton button in this) { + if (button == null) + continue; + + if (button.State == ButtonState.Inactive) + continue; + + if (button == over_button) { + if (any_pushed_buttons) { + any_change |= button.State != ButtonState.Pushed; + button.State = ButtonState.Pushed; + } + ToolTipStart (button); + any_tooltip = true; + if (!button.Entered) { + button.Entered = true; + if (ThemeEngine.Current.ManagedWindowTitleButtonHasHotElementStyle (button, form)) + any_change = true; + } + } else { + if (any_pushed_buttons) { + any_change |= button.State != ButtonState.Normal; + button.State = ButtonState.Normal; + } + if (button.Entered) { + button.Entered = false; + if (ThemeEngine.Current.ManagedWindowTitleButtonHasHotElementStyle (button, form)) + any_change = true; + } + } + } + + if (!any_tooltip) + ToolTipHide (false); + + return any_change; + } + + public void MouseDown (int x, int y) + { + if (!Visible) { + return; + } + + ToolTipHide (false); + + foreach (TitleButton button in this) { + if (button != null && button.State != ButtonState.Inactive) { + button.State = ButtonState.Normal; + } + } + TitleButton clicked_button = FindButton (x, y); + if (clicked_button != null && clicked_button.State != ButtonState.Inactive) { + clicked_button.State = ButtonState.Pushed; + } + } + + public void MouseUp (int x, int y) + { + if (!Visible) { + return; + } + + TitleButton clicked_button = FindButton (x, y); + if (clicked_button != null && clicked_button.State != ButtonState.Inactive) { + clicked_button.OnClick (); + } + + foreach (TitleButton button in this) { + if (button == null || button.State == ButtonState.Inactive) + continue; + + button.State = ButtonState.Normal; + } + + if (clicked_button == CloseButton && !form.closing) + XplatUI.InvalidateNC (form.Handle); + + ToolTipHide (true); + } + + internal void MouseLeave (int x, int y) + { + if (!Visible) { + return; + } + + foreach (TitleButton button in this) { + if (button == null || button.State == ButtonState.Inactive) + continue; + + button.State = ButtonState.Normal; + } + + ToolTipHide (true); + } + } +} + + diff --git a/source/ShiftUI/Internal/KeyboardHandler.cs b/source/ShiftUI/Internal/KeyboardHandler.cs new file mode 100644 index 0000000..5122e7b --- /dev/null +++ b/source/ShiftUI/Internal/KeyboardHandler.cs @@ -0,0 +1,329 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton ([email protected]) +// +// +using System; +using System.Collections; +using System.Text; +using System.Globalization; +using System.Runtime.InteropServices; + +namespace ShiftUI.CarbonInternal { + internal class KeyboardHandler : EventHandlerBase, IEventHandler { + internal const uint kEventRawKeyDown = 1; + internal const uint kEventRawKeyRepeat = 2; + internal const uint kEventRawKeyUp = 3; + internal const uint kEventRawKeyModifiersChanged = 4; + internal const uint kEventHotKeyPressed = 5; + internal const uint kEventHotKeyReleased = 6; + + internal const uint kEventParamKeyMacCharCodes = 1801676914; + internal const uint kEventParamKeyCode = 1801678692; + internal const uint kEventParamKeyModifiers = 1802334052; + internal const uint kEventTextInputUnicodeForKeyEvent = 2; + internal const uint kEventParamTextInputSendText = 1953723512; + + internal const uint typeChar = 1413830740; + internal const uint typeUInt32 = 1835100014; + internal const uint typeUnicodeText = 1970567284; + + internal static byte [] key_filter_table; + internal static byte [] key_modifier_table; + internal static byte [] key_translation_table; + internal static byte [] char_translation_table; + + internal static bool translate_modifier = false; + + internal string ComposedString; + + static KeyboardHandler () { + // our key filter table is a 256 byte array - if the corresponding byte + // is set the key should be filtered from WM_CHAR (apple pushes unicode events + // for some keys which win32 only handles as KEYDOWN + // currently filtered: + // fn+f* == 16 + // left == 28 + // right == 29 + // up == 30 + // down == 31 + // Please update this list as well as the table as more keys are found + key_filter_table = new byte [256] { +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + // our char translation table is a set of translations from mac char codes + // to win32 vkey codes + // most things map directly + char_translation_table = new byte [256] { +0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, +16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 0x25, 0x27, 0x26, 0x28, +32, 49, 34, 51, 52, 53, 55, 222, 57, 48, 56, 187, 188, 189, 190, 191, +48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 186, 60, 61, 62, 63, +50, 65, 66, 67, 68, 187, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, +80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 219, 220, 221, 54, 189, +192, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, +80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123, 124, 125, 126, 0x2e, +128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, +144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, +160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, +176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, +192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, +208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, +224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, +240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 + }; + key_translation_table = new byte [256] { +0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, +16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, +32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, +48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, +64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, +80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, +0x74, 0x75, 0x76, 0x72, 0x77, 0x78, 0x79, 103, 104, 105, 106, 107, 108, 109, 0x7a, 0x7b, +112, 113, 114, 115, 116, 117, 0x73, 119, 0x71, 121, 0x70, 123, 124, 125, 126, 127, +128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, +144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, +160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, +176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, +192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, +208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, +224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, +240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 + }; + // the key modifier table is a state table of the possible modifier keys + // apple currently only goes up to 1 << 14 keys, we've extended this to 32 + // bytes as thats the size that apple uses + key_modifier_table = new byte [32]; + } + + internal KeyboardHandler (XplatUICarbon driver) : base (driver) {} + + private void ModifierToVirtualKey (int i, ref MSG msg, bool down) { + msg.hwnd = XplatUICarbon.FocusWindow; + + if (i == 9 || i == 13) { + msg.message = (down ? Msg.WM_KEYDOWN : Msg.WM_KEYUP); + msg.wParam = (IntPtr) VirtualKeys.VK_SHIFT; + msg.lParam = IntPtr.Zero; + return; + } + if (i == 12 || i == 14) { + msg.message = (down ? Msg.WM_KEYDOWN : Msg.WM_KEYUP); + msg.wParam = (IntPtr) VirtualKeys.VK_CONTROL; + msg.lParam = IntPtr.Zero; + return; + } + if (i == 8) { + msg.message = (down ? Msg.WM_SYSKEYDOWN : Msg.WM_SYSKEYUP); + msg.wParam = (IntPtr) VirtualKeys.VK_MENU; + msg.lParam = new IntPtr (0x20000000); + return; + } + + return; + } + + public void ProcessModifiers (IntPtr eventref, ref MSG msg) { + // we get notified when modifiers change, but not specifically what changed + UInt32 modifiers = 0; + + GetEventParameter (eventref, kEventParamKeyModifiers, typeUInt32, IntPtr.Zero, (uint)Marshal.SizeOf (typeof (UInt32)), IntPtr.Zero, ref modifiers); + + for (int i = 0; i < 32; i++) { + if (key_modifier_table [i] == 0x01 && (modifiers & (1 << i)) == 0) { + ModifierToVirtualKey (i, ref msg, false); + key_modifier_table [i] = 0x00; + return; + } else if (key_modifier_table [i] == 0x00 && (modifiers & (1 << i)) == (1 << i)) { + ModifierToVirtualKey (i, ref msg, true); + key_modifier_table [i] = 0x01; + return; + } + } + + return; + } + + public void ProcessText (IntPtr eventref, ref MSG msg) { + UInt32 size = 0; + IntPtr buffer = IntPtr.Zero; + byte [] bdata; + + // get the size of the unicode buffer + GetEventParameter (eventref, kEventParamTextInputSendText, typeUnicodeText, IntPtr.Zero, 0, ref size, IntPtr.Zero); + + buffer = Marshal.AllocHGlobal ((int) size); + bdata = new byte [size]; + + // get the actual text buffer + GetEventParameter (eventref, kEventParamTextInputSendText, typeUnicodeText, IntPtr.Zero, size, IntPtr.Zero, buffer); + + Marshal.Copy (buffer, bdata, 0, (int) size); + Marshal.FreeHGlobal (buffer); + + if (key_filter_table [bdata [0]] == 0x00) { + if (size == 1) { + msg.message = Msg.WM_CHAR; + msg.wParam = BitConverter.IsLittleEndian ? (IntPtr) bdata [0] : (IntPtr) bdata [size-1]; + msg.lParam = IntPtr.Zero; + msg.hwnd = XplatUICarbon.FocusWindow; + } else { + msg.message = Msg.WM_IME_COMPOSITION; + Encoding enc = BitConverter.IsLittleEndian ? Encoding.Unicode : Encoding.BigEndianUnicode; + ComposedString = enc.GetString (bdata); + msg.hwnd = XplatUICarbon.FocusWindow; + } + } + } + + public void ProcessKeyPress (IntPtr eventref, ref MSG msg) { + byte charCode = 0x0; + byte keyCode = 0x0; + + GetEventParameter (eventref, kEventParamKeyMacCharCodes, typeChar, IntPtr.Zero, (uint)Marshal.SizeOf (typeof (byte)), IntPtr.Zero, ref charCode); + GetEventParameter (eventref, kEventParamKeyCode, typeUInt32, IntPtr.Zero, (uint)Marshal.SizeOf (typeof (byte)), IntPtr.Zero, ref keyCode); + + msg.lParam = (IntPtr) charCode; + msg.wParam = charCode == 0x10 ? (IntPtr) key_translation_table [keyCode] : (IntPtr) char_translation_table [charCode]; + msg.hwnd = XplatUICarbon.FocusWindow; + } + + public bool ProcessEvent (IntPtr callref, IntPtr eventref, IntPtr handle, uint kind, ref MSG msg) { + uint klass = EventHandler.GetEventClass (eventref); + bool result = true; + + if (klass == EventHandler.kEventClassTextInput) { + switch (kind) { + case kEventTextInputUnicodeForKeyEvent: + ProcessText (eventref, ref msg); + break; + default: + Console.WriteLine ("WARNING: KeyboardHandler.ProcessEvent default handler for kEventClassTextInput should not be reached"); + break; + } + } else if (klass == EventHandler.kEventClassKeyboard) { + switch (kind) { + case kEventRawKeyDown: + case kEventRawKeyRepeat: + msg.message = Msg.WM_KEYDOWN; + ProcessKeyPress (eventref, ref msg); + break; + case kEventRawKeyUp: + msg.message = Msg.WM_KEYUP; + ProcessKeyPress (eventref, ref msg); + break; + case kEventRawKeyModifiersChanged: + ProcessModifiers (eventref, ref msg); + break; + default: + Console.WriteLine ("WARNING: KeyboardHandler.ProcessEvent default handler for kEventClassKeyboard should not be reached"); + break; + } + } else { + Console.WriteLine ("WARNING: KeyboardHandler.ProcessEvent default handler for kEventClassTextInput should not be reached"); + } + + return result; + } + + public bool TranslateMessage (ref MSG msg) { + bool res = false; + + if (msg.message >= Msg.WM_KEYFIRST && msg.message <= Msg.WM_KEYLAST) + res = true; + + if (msg.message != Msg.WM_KEYDOWN && msg.message != Msg.WM_SYSKEYDOWN && msg.message != Msg.WM_KEYUP && msg.message != Msg.WM_SYSKEYUP && msg.message != Msg.WM_CHAR && msg.message != Msg.WM_SYSCHAR) + return res; + + if (key_modifier_table [8] == 0x01 && key_modifier_table [12] == 0x00 && key_modifier_table [14] == 0x00) { + if (msg.message == Msg.WM_KEYDOWN) { + msg.message = Msg.WM_SYSKEYDOWN; + } else if (msg.message == Msg.WM_CHAR) { + msg.message = Msg.WM_SYSCHAR; + translate_modifier = true; + } else if (msg.message == Msg.WM_KEYUP) { + msg.message = Msg.WM_SYSKEYUP; + } else { + return res; + } + + msg.lParam = new IntPtr (0x20000000); + } else if (msg.message == Msg.WM_SYSKEYUP && translate_modifier && msg.wParam == (IntPtr) 18) { + msg.message = Msg.WM_KEYUP; + + msg.lParam = IntPtr.Zero; + translate_modifier = false; + } + + return res; + } + + internal Keys ModifierKeys { + get { + Keys keys = Keys.None; + if (key_modifier_table [9] == 0x01 || key_modifier_table [13] == 0x01) { keys |= Keys.Shift; } + if (key_modifier_table [8] == 0x01) { keys |= Keys.Alt; } + if (key_modifier_table [12] == 0x01 || key_modifier_table [14] == 0x01) { keys |= Keys.Widget; } + return keys; + } + } + + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int GetEventParameter (IntPtr eventref, uint name, uint type, IntPtr outtype, uint size, ref UInt32 outsize, IntPtr data); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int GetEventParameter (IntPtr eventref, uint name, uint type, IntPtr outtype, uint size, IntPtr outsize, IntPtr data); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int GetEventParameter (IntPtr eventref, uint name, uint type, IntPtr outtype, uint size, IntPtr outsize, ref byte data); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int GetEventParameter (IntPtr eventref, uint name, uint type, IntPtr outtype, uint size, IntPtr outsize, ref UInt32 data); + } + + internal enum KeyboardModifiers : uint { + activeFlag = 1 << 0, + btnState = 1 << 7, + cmdKey = 1 << 8, + shiftKey = 1 << 9, + alphaLock = 1 << 10, + optionKey = 1 << 11, + WidgetKey = 1 << 12, + rightShiftKey = 1 << 13, + rightOptionKey = 1 << 14, + rightWidgetKey = 1 << 14, + } +} diff --git a/source/ShiftUI/Internal/KeysConverter.cs b/source/ShiftUI/Internal/KeysConverter.cs new file mode 100644 index 0000000..6f24eae --- /dev/null +++ b/source/ShiftUI/Internal/KeysConverter.cs @@ -0,0 +1,139 @@ +// 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.Collections; +using System.ComponentModel; +using System.Text; +using System; + +namespace ShiftUI { + public class KeysConverter : TypeConverter, IComparer { + #region Public Constructors + public KeysConverter() { + } + #endregion // Public Constructors + + #region Public Instance Methods + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { + if (sourceType == typeof(string)) { + return true; + } + return false; + } + + public override bool CanConvertTo (ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof (Enum[])) + return true; + + return base.CanConvertTo (context, destinationType); + } + + public int Compare(object a, object b) { + if (a is string && b is string) { + return String.Compare((string) a, (string)b); + } + return String.Compare(a.ToString(), b.ToString()); + } + + public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { + if (value is string) { + string[] keys; + Keys key; + + keys = ((string)value).Split(new char[] {'+'}); + key = Keys.None; + + if (keys.Length > 1) { + for (int i = 0; i < keys.Length - 1; i++) { + if (keys[i].Equals("Ctrl")) { + key |= Keys.Widget; + } else { + key |= (Keys)Enum.Parse(typeof(Keys), keys[i], true); + } + } + } + if (keys [keys.Length - 1].Equals ("Ctrl")) + key |= Keys.Widget; + else + key |= (Keys)Enum.Parse(typeof(Keys), keys[keys.Length - 1], true); + return key; + } + return base.ConvertFrom (context, culture, value); + } + + public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { + if (destinationType == typeof(string)) { + StringBuilder sb; + Keys key; + + sb = new StringBuilder(); + key = (Keys)value; + + // Modifiers first + if ((key & Keys.Widget) != 0) { + sb.Append("Ctrl+"); + } + + if ((key & Keys.Alt) != 0) { + sb.Append("Alt+"); + } + + if ((key & Keys.Shift) != 0) { + sb.Append("Shift+"); + } + + // Keycode last + sb.Append(Enum.GetName(typeof(Keys), key & Keys.KeyCode)); + + return sb.ToString(); + } + return base.ConvertTo (context, culture, value, destinationType); + } + + public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { + Keys [] stdVal = new Keys [] { Keys.D0, Keys.D1, Keys.D2, Keys.D3, Keys.D4, Keys.D5, Keys.D6, Keys.D7, + Keys.D8, Keys.D9, Keys.Alt, Keys.Back, Keys.Widget, Keys.Delete, Keys.End, Keys.Return, Keys.F1, + Keys.F10, Keys.F11, Keys.F12, Keys.F2, Keys.F3, Keys.F4, Keys.F5, Keys.F6, Keys.F7, Keys.F8, Keys.F9, + Keys.Home, Keys.Insert, Keys.Next, Keys.PageUp, Keys.Shift }; + + return new TypeConverter.StandardValuesCollection (stdVal); + } + + public override bool GetStandardValuesExclusive(ITypeDescriptorContext context) { + + return false; + } + + public override bool GetStandardValuesSupported(ITypeDescriptorContext context) { + return true; + } + + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/LayoutEngine.cs b/source/ShiftUI/Internal/LayoutEngine.cs new file mode 100644 index 0000000..7b2ce71 --- /dev/null +++ b/source/ShiftUI/Internal/LayoutEngine.cs @@ -0,0 +1,43 @@ +// 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. +// +// +// Author: +// Miguel de Icaza ([email protected]) +// +// (C) 2004 Novell, Inc. +// + +using System; +using System.ComponentModel; + +namespace ShiftUI.Layout { + + public abstract class LayoutEngine { + + public virtual void InitLayout (object child, BoundsSpecified specified) + { + } + + public virtual bool Layout (object container, LayoutEventArgs layoutEventArgs) + { + return false; + } + } +} diff --git a/source/ShiftUI/Internal/LayoutSettings.cs b/source/ShiftUI/Internal/LayoutSettings.cs new file mode 100644 index 0000000..a97d744 --- /dev/null +++ b/source/ShiftUI/Internal/LayoutSettings.cs @@ -0,0 +1,40 @@ +// 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. +// +// +// Author: +// Miguel de Icaza ([email protected]) +// +// (C) 2004 Novell, Inc. +// + +using System; +using System.ComponentModel; +using ShiftUI.Layout; + +namespace ShiftUI { + + public abstract class LayoutSettings { + public virtual LayoutEngine LayoutEngine { + get { + return null; + } + } + } +} diff --git a/source/ShiftUI/Internal/Line.cs b/source/ShiftUI/Internal/Line.cs new file mode 100644 index 0000000..a523047 --- /dev/null +++ b/source/ShiftUI/Internal/Line.cs @@ -0,0 +1,811 @@ +// 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) 2004-2006 Novell, Inc. (http://www.novell.com) +// +// Authors: +// Peter Bartok [email protected] +// +// + +using System; +using System.Collections; +using System.Drawing; +using System.Drawing.Text; +using System.Text; + +namespace ShiftUI +{ + internal class Line : ICloneable, IComparable + { + #region Local Variables + + internal Document document; + // Stuff that matters for our line + internal StringBuilder text; // Characters for the line + internal float[] widths; // Width of each character; always one larger than text.Length + internal int space; // Number of elements in text and widths + internal int line_no; // Line number + internal LineTag tags; // Tags describing the text + internal int offset; // Baseline can be on the X or Y axis depending if we are in multiline mode or not + internal int height; // Height of the line (height of tallest tag) + internal int ascent; // Ascent of the line (ascent of the tallest tag) + internal HorizontalAlignment alignment; // Alignment of the line + internal int align_shift; // Pixel shift caused by the alignment + internal int indent; // Left indent for the first line + internal int hanging_indent; // Hanging indent (left indent for all but the first line) + internal int right_indent; // Right indent for all lines + internal LineEnding ending; + + // Stuff that's important for the tree + internal Line parent; // Our parent line + internal Line left; // Line with smaller line number + internal Line right; // Line with higher line number + internal LineColor color; // We're doing a black/red tree. this is the node color + static int DEFAULT_TEXT_LEN = 0; // + internal bool recalc; // Line changed + + private static Hashtable kerning_fonts = new Hashtable (); // record which fonts use kerning + #endregion // Local Variables + + #region Constructors + internal Line (Document document, LineEnding ending) + { + this.document = document; + color = LineColor.Red; + left = null; + right = null; + parent = null; + text = null; + recalc = true; + alignment = document.alignment; + + this.ending = ending; + } + + internal Line (Document document, int LineNo, string Text, Font font, Color color, LineEnding ending) : this (document, ending) + { + space = Text.Length > DEFAULT_TEXT_LEN ? Text.Length+1 : DEFAULT_TEXT_LEN; + + text = new StringBuilder (Text, space); + line_no = LineNo; + this.ending = ending; + + widths = new float[space + 1]; + + + tags = new LineTag(this, 1); + tags.Font = font; + tags.Color = color; + } + + internal Line (Document document, int LineNo, string Text, HorizontalAlignment align, Font font, Color color, LineEnding ending) : this(document, ending) + { + space = Text.Length > DEFAULT_TEXT_LEN ? Text.Length+1 : DEFAULT_TEXT_LEN; + + text = new StringBuilder (Text, space); + line_no = LineNo; + this.ending = ending; + alignment = align; + + widths = new float[space + 1]; + + + tags = new LineTag(this, 1); + tags.Font = font; + tags.Color = color; + } + + internal Line (Document document, int LineNo, string Text, LineTag tag, LineEnding ending) : this(document, ending) + { + space = Text.Length > DEFAULT_TEXT_LEN ? Text.Length+1 : DEFAULT_TEXT_LEN; + + text = new StringBuilder (Text, space); + this.ending = ending; + line_no = LineNo; + + widths = new float[space + 1]; + tags = tag; + } + + #endregion // Constructors + + #region Internal Properties + internal HorizontalAlignment Alignment { + get { return alignment; } + set { + if (alignment != value) { + alignment = value; + recalc = true; + } + } + } + + internal int HangingIndent { + get { return hanging_indent; } + set { + hanging_indent = value; + recalc = true; + } + } + + // UIA: Method used via reflection in TextRangeProvider + internal int Height { + get { return height; } + set { height = value; } + } + + internal int Indent { + get { return indent; } + set { + indent = value; + recalc = true; + } + } + + internal int LineNo { + get { return line_no; } + set { line_no = value; } + } + + internal int RightIndent { + get { return right_indent; } + set { + right_indent = value; + recalc = true; + } + } + + // UIA: Method used via reflection in TextRangeProvider + internal int Width { + get { + int res = (int) widths [text.Length]; + return res; + } + } + + internal string Text { + get { return text.ToString(); } + set { + int prev_length = text.Length; + text = new StringBuilder(value, value.Length > DEFAULT_TEXT_LEN ? value.Length + 1 : DEFAULT_TEXT_LEN); + + if (text.Length > prev_length) + Grow (text.Length - prev_length); + } + } + + // UIA: Method used via reflection in TextRangeProvider + internal int X { + get { + if (document.multiline) + return align_shift; + return offset + align_shift; + } + } + + // UIA: Method used via reflection in TextRangeProvider + internal int Y { + get { + if (!document.multiline) + return document.top_margin; + return document.top_margin + offset; + } + } + #endregion // Internal Properties + + #region Internal Methods + + /// <summary> + /// Builds a simple code to record which tags are links and how many tags + /// used to compare lines before and after to see if the scan for links + /// process has changed anything. + /// </summary> + internal void LinkRecord (StringBuilder linkRecord) + { + LineTag tag = tags; + + while (tag != null) { + if (tag.IsLink) + linkRecord.Append ("L"); + else + linkRecord.Append ("N"); + + tag = tag.Next; + } + } + + /// <summary> + /// Clears all link properties from tags + /// </summary> + internal void ClearLinks () + { + LineTag tag = tags; + + while (tag != null) { + tag.IsLink = false; + tag = tag.Next; + } + } + + public void DeleteCharacters(int pos, int count) + { + LineTag tag; + bool streamline = false; + + // Can't delete more than the line has + if (pos >= text.Length) + return; + + // Find the first tag that we are deleting from + tag = FindTag (pos + 1); + + // Remove the characters from the line + text.Remove (pos, count); + + if (tag == null) + return; + + // Check if we're crossing tag boundaries + if ((pos + count) > (tag.Start + tag.Length - 1)) { + int left; + + // We have to delete cross tag boundaries + streamline = true; + left = count; + + left -= tag.Start + tag.Length - pos - 1; + tag = tag.Next; + + // Update the start of each tag + while ((tag != null) && (left > 0)) { + // Cache tag.Length as is will be indireclty modified + // by changes to tag.Start + int tag_length = tag.Length; + tag.Start -= count - left; + + if (tag_length > left) { + left = 0; + } else { + left -= tag_length; + tag = tag.Next; + } + + } + } else { + // We got off easy, same tag + + if (tag.Length == 0) + streamline = true; + } + + // Delete empty orphaned tags at the end + LineTag walk = tag; + while (walk != null && walk.Next != null && walk.Next.Length == 0) { + LineTag t = walk; + walk.Next = walk.Next.Next; + if (walk.Next != null) + walk.Next.Previous = t; + walk = walk.Next; + } + + // Adjust the start point of any tags following + if (tag != null) { + tag = tag.Next; + while (tag != null) { + tag.Start -= count; + tag = tag.Next; + } + } + + recalc = true; + + if (streamline) + Streamline (document.Lines); + } + + // This doesn't do exactly what you would think, it just pulls off the \n part of the ending + internal void DrawEnding (Graphics dc, float y) + { + if (document.multiline) + return; + LineTag last = tags; + while (last.Next != null) + last = last.Next; + + string end_str = null; + switch (document.LineEndingLength (ending)) { + case 0: + return; + case 1: + end_str = "\u0013"; + break; + case 2: + end_str = "\u0013\u0013"; + break; + case 3: + end_str = "\u0013\u0013\u0013"; + break; + } + + TextBoxTextRenderer.DrawText (dc, end_str, last.Font, last.Color, X + widths [TextLengthWithoutEnding ()] - document.viewport_x + document.OffsetX, y, true); + } + + /// <summary> Find the tag on a line based on the character position, pos is 0-based</summary> + internal LineTag FindTag (int pos) + { + LineTag tag; + + if (pos == 0) + return tags; + + tag = this.tags; + + if (pos >= text.Length) + pos = text.Length - 1; + + while (tag != null) { + if (((tag.Start - 1) <= pos) && (pos <= (tag.Start + tag.Length - 1))) + return LineTag.GetFinalTag (tag); + + tag = tag.Next; + } + + return null; + } + + public override int GetHashCode () + { + return base.GetHashCode (); + } + + // Get the tag that contains this x coordinate + public LineTag GetTag (int x) + { + LineTag tag = tags; + + // Coord is to the left of the first character + if (x < tag.X) + return LineTag.GetFinalTag (tag); + + // All we have is a linked-list of tags, so we have + // to do a linear search. But there shouldn't be + // too many tags per line in general. + while (true) { + if (x >= tag.X && x < (tag.X + tag.Width)) + return tag; + + if (tag.Next != null) + tag = tag.Next; + else + return LineTag.GetFinalTag (tag); + } + } + + // Make sure we always have enoughs space in text and widths + internal void Grow (int minimum) + { + int length; + float[] new_widths; + + length = text.Length; + + if ((length + minimum) > space) { + // We need to grow; double the size + + if ((length + minimum) > (space * 2)) { + new_widths = new float[length + minimum * 2 + 1]; + space = length + minimum * 2; + } else { + new_widths = new float[space * 2 + 1]; + space *= 2; + } + widths.CopyTo (new_widths, 0); + + widths = new_widths; + } + } + public void InsertString (int pos, string s) + { + InsertString (pos, s, FindTag (pos)); + } + + // Inserts a string at the given position + public void InsertString (int pos, string s, LineTag tag) + { + int len = s.Length; + + // Insert the text into the StringBuilder + text.Insert (pos, s); + + // Update the start position of every tag after this one + tag = tag.Next; + + while (tag != null) { + tag.Start += len; + tag = tag.Next; + } + + // Make sure we have room in the widths array + Grow (len); + + // This line needs to be recalculated + recalc = true; + } + + /// <summary> + /// Go through all tags on a line and recalculate all size-related values; + /// returns true if lineheight changed + /// </summary> + internal bool RecalculateLine (Graphics g, Document doc) + { + return RecalculateLine (g, doc, kerning_fonts.ContainsKey (tags.Font.GetHashCode ())); + } + + private bool RecalculateLine (Graphics g, Document doc, bool handleKerning) + { + LineTag tag; + int pos; + int len; + SizeF size; + float w; + int prev_offset; + bool retval; + bool wrapped; + Line line; + int wrap_pos; + int prev_height; + int prev_ascent; + + pos = 0; + len = this.text.Length; + tag = this.tags; + prev_offset = this.offset; // For drawing optimization calculations + prev_height = this.height; + prev_ascent = this.ascent; + this.height = 0; // Reset line height + this.ascent = 0; // Reset the ascent for the line + tag.Shift = 0; // Reset shift (which should be stored as pixels, not as points) + + if (ending == LineEnding.Wrap) + widths[0] = document.left_margin + hanging_indent; + else + widths[0] = document.left_margin + indent; + + this.recalc = false; + retval = false; + wrapped = false; + + wrap_pos = 0; + + while (pos < len) { + + while (tag.Length == 0) { // We should always have tags after a tag.length==0 unless len==0 + //tag.Ascent = 0; + tag.Shift = (tag.Line.ascent - tag.Ascent) / 72; + tag = tag.Next; + } + + // kerning is a problem. The original code in this method assumed that the + // width of a string equals the sum of the widths of its characters. This is + // not true when kerning takes place during the display process. Since it's + // impossible to find out easily whether a font does kerning, and with which + // characters, we just detect that kerning must have happened and use a slower + // (but accurate) measurement for those fonts henceforth. Without handling + // kerning, many fonts for English become unreadable during typing for many + // input strings, and text in many other languages is even worse trying to + // type in TextBoxes. + // See https://bugzilla.xamarin.com/show_bug.cgi?id=26478 for details. + float newWidth; + if (handleKerning && !Char.IsWhiteSpace(text[pos])) + { + // MeasureText doesn't measure trailing spaces, so we do the best we can for those + // in the else branch. + size = TextBoxTextRenderer.MeasureText (g, text.ToString (0, pos + 1), tag.Font); + newWidth = widths[0] + size.Width; + } + else + { + size = tag.SizeOfPosition (g, pos); + w = size.Width; + newWidth = widths[pos] + w; + } + + if (Char.IsWhiteSpace (text[pos])) + wrap_pos = pos + 1; + + if (doc.wrap) { + if ((wrap_pos > 0) && (wrap_pos != len) && (newWidth + 5) > (doc.viewport_width - this.right_indent)) { + // Make sure to set the last width of the line before wrapping + widths[pos + 1] = newWidth; + + pos = wrap_pos; + len = text.Length; + doc.Split (this, tag, pos); + ending = LineEnding.Wrap; + len = this.text.Length; + + retval = true; + wrapped = true; + } else if (pos > 1 && newWidth > (doc.viewport_width - this.right_indent)) { + // No suitable wrap position was found so break right in the middle of a word + + // Make sure to set the last width of the line before wrapping + widths[pos + 1] = newWidth; + + doc.Split (this, tag, pos); + ending = LineEnding.Wrap; + len = this.text.Length; + retval = true; + wrapped = true; + } + } + + // Contract all wrapped lines that follow back into our line + if (!wrapped) { + pos++; + + widths[pos] = newWidth; + + if (pos == len) { + line = doc.GetLine (this.line_no + 1); + if ((line != null) && (ending == LineEnding.Wrap || ending == LineEnding.None)) { + // Pull the two lines together + doc.Combine (this.line_no, this.line_no + 1); + len = this.text.Length; + retval = true; + } + } + } + + if (pos == (tag.Start - 1 + tag.Length)) { + // We just found the end of our current tag + tag.Height = tag.MaxHeight (); + + // Check if we're the tallest on the line (so far) + if (tag.Height > this.height) + this.height = tag.Height; // Yep; make sure the line knows + + if (tag.Ascent > this.ascent) { + LineTag t; + + // We have a tag that has a taller ascent than the line; + t = tags; + while (t != null && t != tag) { + t.Shift = (tag.Ascent - t.Ascent) / 72; + t = t.Next; + } + + // Save on our line + this.ascent = tag.Ascent; + } else { + tag.Shift = (this.ascent - tag.Ascent) / 72; + } + + tag = tag.Next; + if (tag != null) { + tag.Shift = 0; + wrap_pos = pos; + } + } + } + + var fullText = text.ToString(); + if (!handleKerning && fullText.Length > 1 && !wrapped) + { + // Check whether kerning takes place for this string and font. + var realSize = TextBoxTextRenderer.MeasureText(g, fullText, tags.Font); + float realWidth = realSize.Width + widths[0]; + // MeasureText ignores trailing whitespace, so we will too at this point. + int length = fullText.TrimEnd().Length; + float sumWidth = widths[length]; + if (realWidth != sumWidth) + { + kerning_fonts.Add(tags.Font.GetHashCode (), true); + // Using a slightly incorrect width this time around isn't that bad. All that happens + // is that the cursor is a pixel or two off until the next character is typed. It's + // the accumulation of pixel after pixel that causes display problems. + } + } + + while (tag != null) { + tag.Shift = (tag.Line.ascent - tag.Ascent) / 72; + tag = tag.Next; + } + + if (this.height == 0) { + this.height = tags.Font.Height; + tags.Height = this.height; + tags.Shift = 0; + } + + if (prev_offset != offset || prev_height != this.height || prev_ascent != this.ascent) + retval = true; + + return retval; + } + + /// <summary> + /// Recalculate a single line using the same char for every character in the line + /// </summary> + internal bool RecalculatePasswordLine (Graphics g, Document doc) + { + LineTag tag; + int pos; + int len; + float w; + bool ret; + + pos = 0; + len = this.text.Length; + tag = this.tags; + ascent = 0; + tag.Shift = 0; + + this.recalc = false; + widths[0] = document.left_margin + indent; + + w = TextBoxTextRenderer.MeasureText (g, doc.password_char, tags.Font).Width; + + if (this.height != (int)tag.Font.Height) + ret = true; + else + ret = false; + + this.height = (int)tag.Font.Height; + tag.Height = this.height; + + this.ascent = tag.Ascent; + + while (pos < len) { + pos++; + widths[pos] = widths[pos - 1] + w; + } + + return ret; + } + + internal void Streamline (int lines) + { + LineTag current; + LineTag next; + + current = this.tags; + next = current.Next; + + // + // Catch what the loop below wont; eliminate 0 length + // tags, but only if there are other tags after us + // We only eliminate text tags if there is another text tag + // after it. Otherwise we wind up trying to type on picture tags + // + while ((current.Length == 0) && (next != null) && (next.IsTextTag)) { + tags = next; + tags.Previous = null; + current = next; + next = current.Next; + } + + + if (next == null) + return; + + while (next != null) { + // Take out 0 length tags unless it's the last tag in the document + if (current.IsTextTag && next.Length == 0 && next.IsTextTag) { + if ((next.Next != null) || (line_no != lines)) { + current.Next = next.Next; + if (current.Next != null) { + current.Next.Previous = current; + } + next = current.Next; + continue; + } + } + + if (current.Combine (next)) { + next = current.Next; + continue; + } + + current = current.Next; + next = current.Next; + } + } + + internal int TextLengthWithoutEnding () + { + return text.Length - document.LineEndingLength (ending); + } + + internal string TextWithoutEnding () + { + return text.ToString (0, text.Length - document.LineEndingLength (ending)); + } + #endregion // Internal Methods + + #region Administrative + public object Clone () + { + Line clone; + + clone = new Line (document, ending); + + clone.text = text; + + if (left != null) + clone.left = (Line)left.Clone(); + + if (left != null) + clone.left = (Line)left.Clone(); + + return clone; + } + + internal object CloneLine () + { + Line clone; + + clone = new Line (document, ending); + + clone.text = text; + + return clone; + } + + public int CompareTo (object obj) + { + if (obj == null) + return 1; + + if (! (obj is Line)) + throw new ArgumentException("Object is not of type Line", "obj"); + + if (line_no < ((Line)obj).line_no) + return -1; + else if (line_no > ((Line)obj).line_no) + return 1; + else + return 0; + } + + public override bool Equals (object obj) + { + if (obj == null) + return false; + + if (!(obj is Line)) + return false; + + if (obj == this) + return true; + + if (line_no == ((Line)obj).line_no) + return true; + + return false; + } + + public override string ToString() + { + return string.Format ("Line {0}", line_no); + } + #endregion // Administrative + } +} diff --git a/source/ShiftUI/Internal/LineTag.cs b/source/ShiftUI/Internal/LineTag.cs new file mode 100644 index 0000000..e34132c --- /dev/null +++ b/source/ShiftUI/Internal/LineTag.cs @@ -0,0 +1,618 @@ +// 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) 2004-2006 Novell, Inc. (http://www.novell.com) +// +// Authors: +// Peter Bartok [email protected] +// +// + +using System; +using System.Collections; +using System.Drawing; +using System.Drawing.Text; +using System.Text; + +namespace ShiftUI +{ + internal class LineTag + { + #region Local Variables + // Formatting + private Font font; // System.Drawing.Font object for this tag + private Color color; // The font color for this tag + private Color back_color; // In 2.0 tags can have background colours. + private Font link_font; // Cached font used for link if IsLink + private bool is_link; // Whether this tag is a link + private string link_text; // The full link text e.g. this might be + // word-wrapped to "w" but this would be + // "www.mono-project.com" + + // Payload; text + private int start; // start, in chars; index into Line.text + // 1 based!! + + // Drawing support + private int height; // Height in pixels of the text this tag describes + private int ascent; // Ascent of the font for this tag + private int descent; // Descent of the font for this tag + private int shift; // Shift down for this tag, to stay on baseline + + // Administrative + private Line line; // The line we're on + private LineTag next; // Next tag on the same line + private LineTag previous; // Previous tag on the same line + #endregion + + #region Constructors + public LineTag (Line line, int start) + { + this.line = line; + Start = start; + link_font = null; + is_link = false; + link_text = null; + } + #endregion // Constructors + + #region Public Properties + public int Ascent { + get { return ascent; } + } + + public Color BackColor { + get { return back_color; } + set { back_color = value; } + } + + public Color ColorToDisplay { + get { + if (IsLink == true) + return Color.Blue; + + return color; + } + } + + public Color Color { + get { return color; } + set { color = value; } + } + + public int Descent { + get { return descent; } + } + + public int End { + get { return start + Length; } + } + + public Font FontToDisplay { + get { + if (IsLink) { + if (link_font == null) + link_font = new Font (font.FontFamily, font.Size, font.Style | FontStyle.Underline); + + return link_font; + } + + return font; + } + } + + public Font Font { + get { return font; } + set { + if (font != value) { + link_font = null; + font = value; + + height = Font.Height; + XplatUI.GetFontMetrics (Hwnd.GraphicsContext, Font, out ascent, out descent); + line.recalc = true; + } + } + } + + public int Height { + get { return height; } + set { height = value; } + } + + public virtual bool IsTextTag { + get { return true; } + } + + public int Length { + get { + int res = 0; + if (next != null) + res = next.start - start; + else + res = line.text.Length - (start - 1); + + return res > 0 ? res : 0; + } + } + + public Line Line { + get { return line; } + set { line = value; } + } + + public LineTag Next { + get { return next; } + set { next = value; } + } + + public LineTag Previous { + get { return previous; } + set { previous = value; } + } + + public int Shift { + get { return shift; } + set { shift = value; } + } + + public int Start { + get { return start; } + set { +#if DEBUG + if (value <= 0) + throw new Exception("Start of tag must be 1 or higher!"); + + if (this.Previous != null) { + if (this.Previous.Start == value) + System.Console.Write("Creating empty tag"); + if (this.Previous.Start > value) + throw new Exception("New tag makes an insane tag"); + } +#endif + start = value; + } + } + + public int TextEnd { + get { return start + TextLength; } + } + + public int TextLength { + get { + int res = 0; + if (next != null) + res = next.start - start; + else + res = line.TextLengthWithoutEnding () - (start - 1); + + return res > 0 ? res : 0; + } + } + + public float Width { + get { + if (Length == 0) + return 0; + return line.widths [start + Length - 1] - (start != 0 ? line.widths [start - 1] : 0); + } + } + + public float X { + get { + if (start == 0) + return line.X; + return line.X + line.widths [start - 1]; + } + } + + public bool IsLink { + get { return is_link; } + set { is_link = value; } + } + + public string LinkText { + get { return link_text; } + set { link_text = value; } + } + #endregion + + #region Public Methods + ///<summary>Break a tag into two with identical attributes; pos is 1-based; returns tag starting at >pos< or null if end-of-line</summary> + public LineTag Break (int pos) + { + LineTag new_tag; + +#if DEBUG + // Sanity + if (pos < this.Start) + throw new Exception ("Breaking at a negative point"); +#endif + +#if DEBUG + if (pos > End) + throw new Exception ("Breaking past the end of a line"); +#endif + + new_tag = new LineTag(line, pos); + new_tag.CopyFormattingFrom (this); + + new_tag.next = this.next; + this.next = new_tag; + new_tag.previous = this; + + if (new_tag.next != null) + new_tag.next.previous = new_tag; + + return new_tag; + } + + /// <summary>Combines 'this' tag with 'other' tag</summary> + public bool Combine (LineTag other) + { + if (!this.Equals (other)) + return false; + + this.next = other.next; + + if (this.next != null) + this.next.previous = this; + + return true; + } + + public void CopyFormattingFrom (LineTag other) + { + Font = other.font; + color = other.color; + back_color = other.back_color; + } + + public void Delete () + { + // If we are the only tag, we can't be deleted + if (previous == null && next == null) + return; + + // If we are the last tag, deletion is easy + if (next == null) { + previous.next = null; + return; + } + + // Easy cases gone, little tougher, delete ourself + // Update links, and start + next.previous = null; + + LineTag loop = next; + + while (loop != null) { + loop.Start -= Length; + loop = loop.next; + } + + return; + } + + public virtual void Draw (Graphics dc, Color color, float x, float y, int start, int end) + { + TextBoxTextRenderer.DrawText (dc, line.text.ToString (start, end).Replace ("\r", string.Empty), FontToDisplay, color, x, y, false); + } + + public virtual void Draw (Graphics dc, Color color, float xoff, float y, int start, int end, string text) + { + Rectangle measured_text; + Draw (dc, color, xoff, y, start, end, text, out measured_text, false); + } + + /// <summary> + /// + /// </summary> + /// <param name="drawStart">0 based start index</param> + public virtual void Draw (Graphics dc, Color color, float xoff, float y, int drawStart, int drawEnd, + string text, out Rectangle measuredText, bool measureText) + { + if (measureText) { + int xstart = (int)line.widths [drawStart] + (int)xoff; + int xend = (int)line.widths [drawEnd] - (int)line.widths [drawStart]; + int ystart = (int)y; + int yend = (int)TextBoxTextRenderer.MeasureText (dc, Text (), FontToDisplay).Height; + + measuredText = new Rectangle (xstart, ystart, xend, yend); + } else { + measuredText = new Rectangle (); + } + + while (drawStart < drawEnd) { + int tab_index = text.IndexOf ("\t", drawStart); + + if (tab_index == -1) + tab_index = drawEnd; + + TextBoxTextRenderer.DrawText (dc, text.Substring (drawStart, tab_index - drawStart).Replace ("\r", string.Empty), FontToDisplay, color, xoff + line.widths [drawStart], y, false); + + // non multilines get the unknown char + if (!line.document.multiline && tab_index != drawEnd) + TextBoxTextRenderer.DrawText (dc, "\u0013", FontToDisplay, color, xoff + line.widths [tab_index], y, true); + + drawStart = tab_index + 1; + } + } + + /// <summary>Checks if 'this' tag describes the same formatting options as 'obj'</summary> + public override bool Equals (object obj) + { + LineTag other; + + if (obj == null) + return false; + + if (!(obj is LineTag)) + return false; + + if (obj == this) + return true; + + other = (LineTag)obj; + + if (other.IsTextTag != IsTextTag) + return false; + + if (this.IsLink != other.IsLink) + return false; + + if (this.LinkText != other.LinkText) + return false; + + if (this.font.Equals (other.font) && this.color.Equals (other.color)) + return true; + + return false; + } + + /// <summary>Finds the tag that describes the character at position 'pos' (0 based) on 'line'</summary> + public static LineTag FindTag (Line line, int pos) + { + LineTag tag = line.tags; + + // Beginning of line is a bit special + if (pos == 0) + return tag; // Not sure if we should get the final tag here + + while (tag != null) { + // [H e][l][l o _ W][o r] Text + // [1 2][3][4 5 6 7][8 9] Start + // 3 4 8 10 End + // 0 1 2 3 4 5 6 7 8 9 Pos + if ((tag.start <= pos) && (pos < tag.End)) + return GetFinalTag (tag); + + tag = tag.next; + } + + return null; + } + + /// <summary>Applies 'font' and 'brush' to characters starting at 'start' for 'length' chars; + /// Removes any previous tags overlapping the same area; + /// returns true if lineheight has changed</summary> + /// <param name="formatStart">1-based character position on line</param> + public static bool FormatText (Line line, int formatStart, int length, Font font, Color color, Color backColor, FormatSpecified specified) + { + LineTag tag; + LineTag start_tag; + LineTag end_tag; + int end; + bool retval = false; // Assume line-height doesn't change + + // Too simple? + if (((FormatSpecified.Font & specified) == FormatSpecified.Font) && font.Height != line.height) + retval = true; + + line.recalc = true; // This forces recalculation of the line in RecalculateDocument + + // A little sanity, not sure if it's needed, might be able to remove for speed + if (length > line.text.Length) + length = line.text.Length; + + tag = line.tags; + end = formatStart + length; + + // Common special case + if ((formatStart == 1) && (length == tag.Length)) { + SetFormat (tag, font, color, backColor, specified); + return retval; + } + + // empty selection style at begining of line means + // we only need one new tag + if (formatStart == 1 && length == 0) { + line.tags.Break (1); + SetFormat (line.tags, font, color, backColor, specified); + return retval; + } + + start_tag = FindTag (line, formatStart - 1); + + // we are at an empty tag already! + // e.g. [Tag 0 - "He"][Tag 1 = 0 length][Tag 2 "llo world"] + // Find Tag will return tag 0 at position 3, but we should just + // use the empty tag after.. + if (start_tag.End == formatStart && length == 0 && start_tag.Next != null && start_tag.Next.Length == 0) { + SetFormat (start_tag.Next, font, color, backColor, specified); + return retval; + } + + // if we are at the end of a tag, we want to move to the next tag + while (start_tag.End == formatStart && start_tag.Next != null) + start_tag = start_tag.Next; + + tag = start_tag.Break (formatStart); + + // empty selection style at end of line - its the only situation + // where the rest of the tag would be empty, since we moved to the + // begining of next non empty tag + if (tag.Length == 0) { + SetFormat (tag, font, color, backColor, specified); + return retval; + } + + // empty - so we just create another tag for + // after our new (now) empty one.. + if (length == 0) { + tag.Break (formatStart); + SetFormat (tag, font, color, backColor, specified); + return retval; + } + + while (tag != null && tag.End <= end) { + SetFormat (tag, font, color, backColor, specified); + tag = tag.next; + } + + // did the last tag conveniently fit? + if (tag != null && tag.End == end) + return retval; + + /// Now do the last tag + end_tag = FindTag (line, end-1); + + if (end_tag != null) { + end_tag.Break (end); + SetFormat (end_tag, font, color, backColor, specified); + } + + return retval; + } + + // Gets the character at the x-coordinate. Index is based from the + // line, not the start of the tag. + // returns 0 based index (0 means before character at 1, 1 means at character 1) + public int GetCharIndex (int x) + { + int low = start; + int high = low + Length; + int length_no_ending = line.TextLengthWithoutEnding (); + + if (Length == 0) + return low-1; + + if (length_no_ending == 0) + return 0; + + if (x < line.widths [low]) { + if (low == 1 && x > (line.widths [1] / 2)) + return low; + return low - 1; + } + + if (x > line.widths[length_no_ending]) + return length_no_ending; + + while (low < high - 1) { + int mid = (high + low) / 2; + float width = line.widths[mid]; + + if (width < x) + low = mid; + else + high = mid; + } + + float char_width = line.widths[high] - line.widths[low]; + + if ((x - line.widths[low]) >= (char_width / 2)) + return high; + else + return low; + } + + // There can be multiple tags at the same position, we want to make + // sure we are using the very last tag at the given position + // Empty tags are necessary if style is set at a position with + // no length. + public static LineTag GetFinalTag (LineTag tag) + { + LineTag res = tag; + + while (res.Length == 0 && res.next != null && res.next.Length == 0) + res = res.next; + + return res; + } + + public override int GetHashCode () + { + return base.GetHashCode (); + } + + internal virtual int MaxHeight () + { + return font.Height; + } + + private static void SetFormat (LineTag tag, Font font, Color color, Color back_color, FormatSpecified specified) + { + if ((FormatSpecified.Font & specified) == FormatSpecified.Font) { + tag.Font = font; + } + if ((FormatSpecified.Color & specified) == FormatSpecified.Color) + tag.color = color; + if ((FormatSpecified.BackColor & specified) == FormatSpecified.BackColor) { + tag.back_color = back_color; + } + // Console.WriteLine ("setting format: {0} {1} new color {2}", color.Color, specified, tag.color.Color); + } + + public virtual SizeF SizeOfPosition (Graphics dc, int pos) + { + if (pos >= line.TextLengthWithoutEnding () && line.document.multiline) + return SizeF.Empty; + + string text = line.text.ToString (pos, 1); + switch ((int) text [0]) { + case '\t': + if (!line.document.multiline) + goto case 10; + SizeF res = TextBoxTextRenderer.MeasureText (dc, " ", font); + res.Width *= 8.0F; + return res; + case 10: + case 13: + return TextBoxTextRenderer.MeasureText (dc, "\u000D", font); + } + + return TextBoxTextRenderer.MeasureText (dc, text, font); + } + + public virtual string Text () + { + return line.text.ToString (start - 1, Length); + } + + public override string ToString () + { + if (Length > 0) + return string.Format ("{0} Tag starts at index: {1}, length: {2}, text: {3}, font: {4}", GetType (), start, Length, Text (), font.ToString ()); + + return string.Format ("Zero Length tag at index: {0}", start); + } + #endregion // Internal Methods + } +} diff --git a/source/ShiftUI/Internal/ListBindingConverter.cs b/source/ShiftUI/Internal/ListBindingConverter.cs new file mode 100644 index 0000000..46f39e5 --- /dev/null +++ b/source/ShiftUI/Internal/ListBindingConverter.cs @@ -0,0 +1,60 @@ +// 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]) +// +// + +// NOT COMPLETE + +using System.ComponentModel; +using System; + +namespace ShiftUI { + public class ListBindingConverter : TypeConverter { + #region Public Constructors + public ListBindingConverter() { + } + #endregion // Public Constructors + + #region Public Instance Methods + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) { + if (destinationType == typeof(string)) { + return true; + } + return base.CanConvertTo (context, destinationType); + } + + public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { + return base.ConvertTo (context, culture, value, destinationType); + } + + public override object CreateInstance(ITypeDescriptorContext context, System.Collections.IDictionary propertyValues) { + return new Binding((string)propertyValues["PropertyName"], (object)propertyValues["DataSource"], (string)propertyValues["DataMember"]); + } + + public override bool GetCreateInstanceSupported(ITypeDescriptorContext context) { + return true; + } + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/ListBindingHelper.cs b/source/ShiftUI/Internal/ListBindingHelper.cs new file mode 100644 index 0000000..2615a33 --- /dev/null +++ b/source/ShiftUI/Internal/ListBindingHelper.cs @@ -0,0 +1,189 @@ +// 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) 2007 Novell, Inc. +// +// Author: +// Carlos Alberto Cortez <[email protected]> +// Ivan Zlatev <[email protected]> +// + +using System; +using System.Collections; +using System.ComponentModel; +using System.Reflection; +using System.Collections.Generic; + +namespace ShiftUI +{ + + public static class ListBindingHelper + { + public static object GetList (object list) + { + if (list is IListSource) + return ((IListSource) list).GetList (); + return list; + } + + public static object GetList (object dataSource, string dataMember) + { + dataSource = GetList (dataSource); + if (dataSource == null || dataMember == null || dataMember.Length == 0) + return dataSource; + + PropertyDescriptor property = GetListItemProperties (dataSource).Find (dataMember, true); + if (property == null) + throw new ArgumentException ("dataMember"); + + object item = null; + + ICurrencyManagerProvider currencyManagerProvider = dataSource as ICurrencyManagerProvider; + if (currencyManagerProvider != null && currencyManagerProvider.CurrencyManager != null) { + CurrencyManager currencyManager = currencyManagerProvider.CurrencyManager; + if (currencyManager != null && currencyManager.Count > 0 && currencyManager.Current != null) + item = currencyManager.Current; + } + + if (item == null) { + if (dataSource is IEnumerable) { + if (dataSource is IList) { + IList list = (IList) dataSource; + item = list.Count > 0 ? list[0] : null; + } else { + IEnumerator e = ((IEnumerable) dataSource).GetEnumerator (); + if (e != null && e.MoveNext ()) + item = e.Current; + } + } else { + item = dataSource; + } + } + + if (item != null) + return property.GetValue (item); + return null; + } + + public static Type GetListItemType (object list) + { + return GetListItemType (list, String.Empty); + } + + public static Type GetListItemType (object dataSource, string dataMember) + { + if (dataSource == null) + return null; + + if (dataMember != null && dataMember.Length > 0) { + PropertyDescriptor property = GetProperty (dataSource, dataMember); + if (property == null) + return typeof (object); + + return property.PropertyType; + } + + if (dataSource is Array) + return dataSource.GetType ().GetElementType (); + + // IEnumerable seems to have higher precedence over IList + if (dataSource is IEnumerable) { + IEnumerator enumerator = ((IEnumerable) dataSource).GetEnumerator (); + if (enumerator.MoveNext () && enumerator.Current != null) + return enumerator.Current.GetType (); + + if (dataSource is IList || dataSource.GetType () == typeof (IList<>)) { + PropertyInfo property = GetPropertyByReflection (dataSource.GetType (), "Item"); + if (property != null) // `Item' could be interface-explicit, and thus private + return property.PropertyType; + } + + // fallback to object + return typeof (object); + } + + return dataSource.GetType (); + } + + public static PropertyDescriptorCollection GetListItemProperties (object list) + { + return GetListItemProperties (list, null); + } + + public static PropertyDescriptorCollection GetListItemProperties (object list, PropertyDescriptor [] listAccessors) + { + list = GetList (list); + + if (list == null) + return new PropertyDescriptorCollection (null); + + if (list is ITypedList) + return ((ITypedList)list).GetItemProperties (listAccessors); + + if (listAccessors == null || listAccessors.Length == 0) { + Type item_type = GetListItemType (list); + return TypeDescriptor.GetProperties (item_type, + new Attribute [] { new BrowsableAttribute (true) }); + } + + // Take into account only the first property + Type property_type = listAccessors [0].PropertyType; + if (typeof (IList).IsAssignableFrom (property_type) || typeof (IList<>).IsAssignableFrom (property_type)) { + + PropertyInfo property = GetPropertyByReflection (property_type, "Item"); + return TypeDescriptor.GetProperties (property.PropertyType); + } + + return new PropertyDescriptorCollection (new PropertyDescriptor [0]); + } + + public static PropertyDescriptorCollection GetListItemProperties (object dataSource, string dataMember, + PropertyDescriptor [] listAccessors) + { + throw new NotImplementedException (); + } + + public static string GetListName (object list, PropertyDescriptor [] listAccessors) + { + if (list == null) + return String.Empty; + + Type item_type = GetListItemType (list); + return item_type.Name; + } + + static PropertyDescriptor GetProperty (object obj, string property_name) + { + return TypeDescriptor.GetProperties (obj, + new Attribute [] { new BrowsableAttribute (true) })[property_name]; + } + + // + // Need to use reflection as we need to bypass the TypeDescriptor.GetProperties () limitations + // + static PropertyInfo GetPropertyByReflection (Type type, string property_name) + { + foreach (PropertyInfo prop in type.GetProperties (BindingFlags.Public | BindingFlags.Instance)) + if (prop.Name == property_name) + return prop; + + return null; + } + } +} diff --git a/source/ShiftUI/Internal/MONO-NOTES b/source/ShiftUI/Internal/MONO-NOTES new file mode 100644 index 0000000..2775bb9 --- /dev/null +++ b/source/ShiftUI/Internal/MONO-NOTES @@ -0,0 +1,28 @@ +Application.Idle is invoked on the same thread used to add the event + +our hacky double buffering only works on the client area, not the nc +area. need to move to a more XplatUI solution involving server-side +drawing surfaces (pixmaps in the X case). + +right now the expose/configure event aggregating is done in the +XEventThread (in the hwnd code, but in the thread running the x event +loop). There is probably a way to get it to run in the thread doing +GetMessage, probably by making GetMessage know about both the xevent +and paint queue's, and having it consume the x queue until there's +nothing left, doing the AddExpose stuff there. then, once the xqueue +is empty, consume the paint queue. This has the added benefit of +making the paint queue a ThreadQueue local thing - no locking will be +needed on it, since the only thing touching it will be the thread +running the message pump. + +why do we /nowarn:108? we lose tons of possibly important warnings due to that... + +more event work: + +CheckedListBox: nothing done. +DataGridView*: nothing done. +GridColumnStylesCollection: nothing done, no Component inheritance +GridTableStylesCollection: nothing done, no Component inheritance +MenuItem: what do we do about CloneMenu? we can't have assignment of events like that (look for the #if notyet) +MonthCalendar: nothing done. +Panel: nothing done. see whether the events should be "new" or now.. diff --git a/source/ShiftUI/Internal/MONO-TODO b/source/ShiftUI/Internal/MONO-TODO new file mode 100644 index 0000000..76397d0 --- /dev/null +++ b/source/ShiftUI/Internal/MONO-TODO @@ -0,0 +1,112 @@ +plans for XplatUIX11.cs: + + - 1 thread watching X socket, doing nothing but + XNextEvent/hwnd.Queue.Enqueue (with minimal motion + compression/key repeat detection) + + - figure out how to deal with the selection events, since they + busy loop waiting on a response from the X socket. maybe + block that thread with an event and wake it up when the + event thread get enough info? + + - Idle event raised once regardless of how many thread queues + we have (should it come from the X event thread?) + + - X11Hwnd which caches (amongst other things) the properties + for the toplevel window so we can avoid doing all those + XChangeProperty things on every single UpdateStyle call. + + - have RULES for things (like "do not call this function + except from ...", etc) and make sure they're enforced. + + - SendMessage.. can't we just insert the right message on the + hwnd's queue instead of using SendAsyncMethod? + + - what's the difference between PostMessage and SendMessage? + + - clean up the MESS that is: + GetWindowState + SetWindowState + + and especially: + SetHwndStyles + SetWMStyles + DeriveStyles + the Style handling in CreateWindow + + - multiple screens? do we care? xinerama foo? + + - fix the mostly static, somewhat instance nature of + XplatUIX11.cs. Either make it static, or make it an + instance. + + - we need to rethink the expose event handling. right now + expose events are only handled once all the other events in + the queue are handled. So, if you're resizing quickly you + get no redraws until you're done. maybe look at the + _NET_WM_SYNC_REQUEST protocol (for the resize/redraw case + specifically). Also, the current expose handling has us + accessing the invalid list/rectangle from multiple threads. + + - factor out ALL knowledge of the multiple windows + (client/whole) into the X11Hwnd class, so we can try to + factor it out. + + - clean up the systray icon stuff - right now it destroys (!) + the client_window and sets client_window == whole_window. + ugh. + + - hwnds should keep track of the width/height they report to + SWF as well as the x window's width/height. That is, we + should allow hwnds with 0,0 width/height even though X + doesn't allow it. There's some "zero_size" stuff in Hwnd, + but it still appears impossible to have 0,0 sized Widgets. + + - window (subwindow, really) destruction should move to Hwnd + if possible. + + - remove 90% of "lock (XlibLock)" usage. It's not really + needed at all, except perhaps to synchronize the + XEventThread and the PeekMessage/GetMessage methods. + + - the big synchronization problem now is the XEventQueue + class. I think all queue operations need to be done while + holding a lock, as the events are queued from the + XEventThread and dequeued from GetMessage. + +possible classes: + + - XplatUIX11 (creates the first (only?) X11Display class. + Most calls should just get the hwnd/display and make a + method call) + + - X11Display (manages the display handle, creates the event + thread, keeps ref to an X11Atoms and the X11RootHwnd) + + - XEventThread (does this need to be a separate class? can + probably just be a method in X11Display) + + - X11Hwnd (move all the style translation here? handles + property changes and caches them. window title here too) + + - X11RootHwnd (add the special root window property stuff + here) + + - X11Atoms (per display atom list. should these be properties + or fields? fields probably, with the builtins as constants). + + - Xlib (the pinvoke wrapper for Xlib calls) + +window managers we need to test again: + + - metacity on SLED/SUSE + - metacity on ubuntu edgy + - compiz on SLED + - compiz HEAD + - beryl? or should compiz be enough? + +specs: + +Extended Window Manager Hints: http://standards.freedesktop.org/wm-spec/wm-spec-latest.html +XEmbed spec: http://standards.freedesktop.org/xembed-spec/latest/ +Systray spec: http://standards.freedesktop.org/systemtray-spec/systemtray-spec-0.2.html diff --git a/source/ShiftUI/Internal/MWFCategoryAttribute.cs b/source/ShiftUI/Internal/MWFCategoryAttribute.cs new file mode 100644 index 0000000..5e348f1 --- /dev/null +++ b/source/ShiftUI/Internal/MWFCategoryAttribute.cs @@ -0,0 +1,50 @@ +// 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.ComponentModel; +using ShiftUI; + +namespace System { + [AttributeUsage (AttributeTargets.All, AllowMultiple=false)] + internal sealed class MWFCategoryAttribute : System.ComponentModel.CategoryAttribute { + #region Constructors + public MWFCategoryAttribute() : base() { + } + + public MWFCategoryAttribute(string category) : base(category) { + } + #endregion // Constructors + + #region Methods + protected override string GetLocalizedString(string value) { + return String.Format(value); + } + + #endregion // Methods + } +} diff --git a/source/ShiftUI/Internal/MWFDescriptionAttribute.cs b/source/ShiftUI/Internal/MWFDescriptionAttribute.cs new file mode 100644 index 0000000..38ac348 --- /dev/null +++ b/source/ShiftUI/Internal/MWFDescriptionAttribute.cs @@ -0,0 +1,51 @@ +// 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.ComponentModel; +using ShiftUI; + +namespace System { + [AttributeUsage (AttributeTargets.All, AllowMultiple=false)] + internal sealed class MWFDescriptionAttribute : System.ComponentModel.DescriptionAttribute { + #region Constructors + public MWFDescriptionAttribute() : base() { + } + + public MWFDescriptionAttribute(string category) : base(category) { + } + #endregion // Constructors + + #region Properties + public override string Description { + get { + return String.Format(base.Description); + } + } + #endregion // Properties + } +} diff --git a/source/ShiftUI/Internal/MainMenu.cs b/source/ShiftUI/Internal/MainMenu.cs new file mode 100644 index 0000000..2bb0f3f --- /dev/null +++ b/source/ShiftUI/Internal/MainMenu.cs @@ -0,0 +1,216 @@ +// 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) 2004-2005 Novell, Inc. +// +// Authors: +// Jordi Mas i Hernandez, [email protected] +// +// + +// COMPLETE + +using System.ComponentModel; +using System.Drawing; +using System; + +namespace ShiftUI +{ + [ToolboxItemFilter("ShiftUI.MainMenu", ToolboxItemFilterType.Allow)] + public class MainMenu : Menu + { + private RightToLeft right_to_left = RightToLeft.Inherit; + private Form form = null; + + public MainMenu () : base (null) + { + + } + + public MainMenu (MenuItem[] items) : base (items) + { + + } + + public MainMenu (IContainer container) : this () + { + container.Add (this); + } + + #region Events + + static object CollapseEvent = new object (); + + public event EventHandler Collapse { + add { Events.AddHandler (CollapseEvent, value); } + remove { Events.RemoveHandler (CollapseEvent, value); } + } + + #endregion Events + + #region Public Properties + [Localizable(true)] + [AmbientValue (RightToLeft.Inherit)] + public virtual RightToLeft RightToLeft { + get { return right_to_left;} + set { right_to_left = value; } + } + + #endregion Public Properties + + #region Public Methods + + public virtual MainMenu CloneMenu () + { + MainMenu new_menu = new MainMenu (); + new_menu.CloneMenu (this); + return new_menu; + } + + protected override IntPtr CreateMenuHandle () + { + return IntPtr.Zero; + } + + protected override void Dispose (bool disposing) + { + base.Dispose (disposing); + } + + public Form GetForm () + { + return form; + } + + public override string ToString () + { + return base.ToString () + ", GetForm: " + form; + } + + protected internal virtual void OnCollapse (EventArgs e) + { + EventHandler eh = (EventHandler) (Events [CollapseEvent]); + if (eh != null) + eh (this, e); + } + + #endregion Public Methods + + #region Private Methods + + internal void Draw () + { + Message m = Message.Create (Wnd.window.Handle, (int) Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero); + PaintEventArgs pe = XplatUI.PaintEventStart (ref m, Wnd.window.Handle, false); + Draw (pe, Rect); + } + + internal void Draw (Rectangle rect) + { + if (Wnd.IsHandleCreated) { + Point pt = XplatUI.GetMenuOrigin (Wnd.window.Handle); + Message m = Message.Create (Wnd.window.Handle, (int)Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero); + PaintEventArgs pevent = XplatUI.PaintEventStart (ref m, Wnd.window.Handle, false); + pevent.Graphics.SetClip (new Rectangle (rect.X + pt.X, rect.Y + pt.Y, rect.Width, rect.Height)); + Draw (pevent, Rect); + XplatUI.PaintEventEnd (ref m, Wnd.window.Handle, false); + } + } + + internal void Draw (PaintEventArgs pe) + { + Draw (pe, Rect); + } + + internal void Draw (PaintEventArgs pe, Rectangle rect) + { + if (!Wnd.IsHandleCreated) + return; + + X = rect.X; + Y = rect.Y; + Height = Rect.Height; + + ThemeEngine.Current.DrawMenuBar (pe.Graphics, this, rect); + + PaintEventHandler eh = (PaintEventHandler)(Events [PaintEvent]); + if (eh != null) + eh (this, pe); + } + + internal override void InvalidateItem (MenuItem item) + { + Draw (item.bounds); + } + + internal void SetForm (Form form) + { + this.form = form; + Wnd = form; + + if (tracker == null) { + tracker = new MenuTracker (this); + tracker.GrabControl = form; + } + } + + internal override void OnMenuChanged (EventArgs e) + { + base.OnMenuChanged (EventArgs.Empty); + if (form == null) + return; + + Rectangle clip = Rect; + Height = 0; /* need this so the theme code will re-layout the menu items + (why is the theme code doing the layout? argh) */ + + if (!Wnd.IsHandleCreated) + return; + + Message m = Message.Create (Wnd.window.Handle, (int) Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero); + PaintEventArgs pevent = XplatUI.PaintEventStart (ref m, Wnd.window.Handle, false); + pevent.Graphics.SetClip (clip); + + Draw (pevent, clip); + } + + /* Mouse events from the form */ + internal void OnMouseDown (object window, MouseEventArgs args) + { + tracker.OnMouseDown (args); + } + + internal void OnMouseMove (object window, MouseEventArgs e) + { + MouseEventArgs args = new MouseEventArgs (e.Button, e.Clicks, Widget.MousePosition.X, Widget.MousePosition.Y, e.Delta); + tracker.OnMotion (args); + } + + static object PaintEvent = new object (); + + internal event PaintEventHandler Paint { + add { Events.AddHandler (PaintEvent, value); } + remove { Events.RemoveHandler (PaintEvent, value); } + } + + #endregion Private Methods + } +} + + diff --git a/source/ShiftUI/Internal/MdiClient.cs b/source/ShiftUI/Internal/MdiClient.cs new file mode 100644 index 0000000..8c2cf8c --- /dev/null +++ b/source/ShiftUI/Internal/MdiClient.cs @@ -0,0 +1,1003 @@ +// 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] +// +// + +// NOT COMPLETE + +using System.Collections; +using System.ComponentModel; +using System.Drawing; +using System.Runtime.InteropServices; +using System; + +namespace ShiftUI { + [ComVisible (true)] + [ClassInterface(ClassInterfaceType.AutoDispatch)] + [DesignTimeVisible(false)] + [ToolboxItem(false)] + public sealed class MdiClient : Widget { + #region Local Variables + private int mdi_created; + private ImplicitHScrollBar hbar; + private ImplicitVScrollBar vbar; + private SizeGrip sizegrip; + private int hbar_value; + private int vbar_value; + private bool lock_sizing; + private bool initializing_scrollbars; + private int prev_bottom; + private bool setting_windowstates = false; + internal ArrayList mdi_child_list; + private string form_text; + private bool setting_form_text; + private Form active_child; + + #endregion // Local Variables + + #region Public Classes + [ComVisible (false)] + public new class WidgetCollection : Widget.WidgetCollection { + + private MdiClient owner; + + public WidgetCollection(MdiClient owner) : base(owner) { + this.owner = owner; + } + + public override void Add(Widget value) { + if ((value is Form) == false || !(((Form)value).IsMdiChild)) { + throw new ArgumentException("Form must be MdiChild"); + } + owner.mdi_child_list.Add (value); + base.Add (value); + + // newest member is the active one + Form form = (Form) value; + owner.ActiveMdiChild = form; + } + + public override void Remove(Widget value) + { + Form form = value as Form; + if (form != null) { + MdiWindowManager wm = form.WindowManager as MdiWindowManager; + if (wm != null) { + form.Closed -= wm.form_closed_handler; + } + } + + owner.mdi_child_list.Remove (value); + base.Remove (value); + } + } + #endregion // Public Classes + + #region Public Constructors + public MdiClient() + { + mdi_child_list = new ArrayList (); + BackColor = SystemColors.AppWorkspace; + Dock = DockStyle.Fill; + SetStyle (Widgetstyles.Selectable, false); + } + #endregion // Public Constructors + + internal void SendFocusToActiveChild () + { + Form active = this.ActiveMdiChild; + if (active == null) { + ParentForm.SendWidgetFocus (this); + } else { + active.SendWidgetFocus (active); + ParentForm.ActiveWidget = active; + } + } + + internal bool HorizontalScrollbarVisible { + get { return hbar != null && hbar.Visible; } + } + internal bool VerticalScrollbarVisible { + get { return vbar != null && vbar.Visible; } + } + + internal void SetParentText(bool text_changed) + { + if (setting_form_text) + return; + + setting_form_text = true; + + if (text_changed) + form_text = ParentForm.Text; + + if (ParentForm.ActiveMaximizedMdiChild == null) { + ParentForm.Text = form_text; + } else { + string childText = ParentForm.ActiveMaximizedMdiChild.form.Text; + if (childText.Length > 0) { + ParentForm.Text = form_text + " - [" + ParentForm.ActiveMaximizedMdiChild.form.Text + "]"; + } else { + ParentForm.Text = form_text; + } + } + + setting_form_text = false; + } + + internal override void OnPaintBackgroundInternal (PaintEventArgs pe) + { + if (BackgroundImage != null) + return; + + if (Parent == null || Parent.BackgroundImage == null) + return; + Parent.PaintWidgetBackground (pe); + } + + internal Form ParentForm { + get { return (Form) Parent; } + } + + protected override Widget.WidgetCollection CreateWidgetsInstance () + { + return new MdiClient.WidgetCollection (this); + } + + protected override void WndProc(ref Message m) { + switch ((Msg)m.Msg) { + case Msg.WM_NCPAINT: + PaintEventArgs pe = XplatUI.PaintEventStart (ref m, Handle, false); + + Rectangle clip; + clip = new Rectangle (0, 0, Width, Height); + + WidgetPaint.DrawBorder3D (pe.Graphics, clip, Border3DStyle.Sunken); + XplatUI.PaintEventEnd (ref m, Handle, false); + m.Result = IntPtr.Zero; + return ; + } + + base.WndProc (ref m); + } + + protected override void OnResize (EventArgs e) + { + base.OnResize (e); + + if (Parent != null && Parent.IsHandleCreated) + XplatUI.InvalidateNC (Parent.Handle); + // Should probably make this into one loop + SizeScrollBars (); + ArrangeWindows (); + } + + protected override void ScaleWidget (SizeF factor, BoundsSpecified specified) + { + // Never change the MdiClient's location + specified &= ~BoundsSpecified.Location; + + base.ScaleWidget (factor, specified); + } + + [System.ComponentModel.EditorBrowsable (EditorBrowsableState.Never)] + protected override void ScaleCore (float dx, float dy) + { + base.ScaleCore (dx, dy); + } + + protected override void SetBoundsCore (int x, int y, int width, int height, BoundsSpecified specified) + { + base.SetBoundsCore (x, y, width, height, specified); + } + + #region Public Instance Properties + [Localizable(true)] + public override System.Drawing.Image BackgroundImage { + get { + return base.BackgroundImage; + } + set { + base.BackgroundImage = value; + } + } + + //[EditorBrowsable (EditorBrowsableState.Never)] + [Browsable (false)] + public override ImageLayout BackgroundImageLayout { + get { + return base.BackgroundImageLayout; + } + set { + base.BackgroundImageLayout = value; + } + } + + public Form [] MdiChildren { + get { + if (mdi_child_list == null) + return new Form [0]; + return (Form []) mdi_child_list.ToArray (typeof (Form)); + } + } + #endregion // Public Instance Properties + +#region Protected Instance Properties + protected override CreateParams CreateParams { + get { + CreateParams result = base.CreateParams; + result.ExStyle |= (int) WindowExStyles.WS_EX_CLIENTEDGE; + return result; + } + } + #endregion // Protected Instance Properties + + #region Public Instance Methods + public void LayoutMdi (MdiLayout value) { + + // Don't forget to always call ArrangeIconicWindows + ArrangeIconicWindows (true); + + switch (value) { + case MdiLayout.Cascade: { + int i = 0; + for (int c = Widgets.Count - 1; c >= 0; c--) { + Form form = (Form) Widgets [c]; + + if (form.WindowState == FormWindowState.Minimized) + continue; + + if (form.WindowState == FormWindowState.Maximized) + form.WindowState = FormWindowState.Normal; + + form.Width = System.Convert.ToInt32 (ClientSize.Width * 0.8); + form.Height = Math.Max ( + System.Convert.ToInt32 (ClientSize.Height * 0.8), + SystemInformation.MinimumWindowSize.Height + 2); + + int l = 22 * i; + int t = 22 * i; + + if (i != 0 && (l + form.Width > ClientSize.Width || t + form.Height > ClientSize.Height)) { + i = 0; + l = 22 * i; + t = 22 * i; + } + + form.Left = l; + form.Top = t; + + i++; + } + break; + } + case MdiLayout.TileHorizontal: + case MdiLayout.TileVertical: { + // First count number of windows to tile + int total = 0; + + // And space used by iconic windows + int clientHeight = ClientSize.Height; + + for (int i = 0; i < Widgets.Count; i++) { + Form form = Widgets [i] as Form; + + if (form == null) + continue; + + if (!form.Visible) + continue; + + if (form.WindowState == FormWindowState.Maximized) + form.WindowState = FormWindowState.Normal; + else if (form.WindowState == FormWindowState.Minimized) { + if (form.Bounds.Top < clientHeight) + clientHeight = form.Bounds.Top; + continue; + } + + total++; + } + if (total <= 0) + return; + + // Calculate desired height and width + Size newSize; + Size offset; + + if (value == MdiLayout.TileHorizontal) { + newSize = new Size(ClientSize.Width, clientHeight / total); + offset = new Size (0, newSize.Height); + } else { + newSize = new Size(ClientSize.Width / total, clientHeight); + offset = new Size (newSize.Width, 0); + } + + // Loop again and set the size and location. + Point nextLocation = Point.Empty; + + for (int i = 0; i < Widgets.Count; i++) { + Form form = Widgets [i] as Form; + + if (form == null) + continue; + + if (!form.Visible) + continue; + + if (form.WindowState == FormWindowState.Minimized) + continue; + + form.Size = newSize; + form.Location = nextLocation; + nextLocation += offset; + } + + break; + } + } + } + #endregion // Public Instance Methods + + #region Protected Instance Methods + #endregion // Protected Instance Methods + + internal void SizeScrollBars () + { + if (lock_sizing) + return; + + if (!IsHandleCreated) + return; + + if (Widgets.Count == 0 || ((Form) Widgets [0]).WindowState == FormWindowState.Maximized) { + if (hbar != null) + hbar.Visible = false; + if (vbar != null) + vbar.Visible = false; + if (sizegrip != null) + sizegrip.Visible = false; + return; + } + + int right = 0; + int left = 0; + int top = 0; + int bottom = 0; + + foreach (Form child in Widgets) { + if (!child.Visible) + continue; + if (child.Right > right) + right = child.Right; + if (child.Left < left) { + left = child.Left; + } + + if (child.Bottom > bottom) + bottom = child.Bottom; + if (child.Top < 0) { + top = child.Top; + } + } + + int available_width = ClientSize.Width; + int available_height = ClientSize.Height; + + bool need_hbar = false; + bool need_vbar = false; + + if (right - left > available_width || left < 0) { + need_hbar = true; + available_height -= SystemInformation.HorizontalScrollBarHeight; + } + if (bottom - top > available_height || top < 0) { + need_vbar = true; + available_width -= SystemInformation.VerticalScrollBarWidth; + + if (!need_hbar && (right - left > available_width || left < 0)) { + need_hbar = true; + available_height -= SystemInformation.HorizontalScrollBarHeight; + } + } + + if (need_hbar) { + if (hbar == null) { + hbar = new ImplicitHScrollBar (); + Widgets.AddImplicit (hbar); + } + hbar.Visible = true; + CalcHBar (left, right, need_vbar); + } else if (hbar != null) + hbar.Visible = false; + + if (need_vbar) { + if (vbar == null) { + vbar = new ImplicitVScrollBar (); + Widgets.AddImplicit (vbar); + } + vbar.Visible = true; + CalcVBar (top, bottom, need_hbar); + } else if (vbar != null) + vbar.Visible = false; + + if (need_hbar && need_vbar) { + if (sizegrip == null) { + sizegrip = new SizeGrip (this.ParentForm); + Widgets.AddImplicit (sizegrip); + } + sizegrip.Location = new Point (hbar.Right, vbar.Bottom); + sizegrip.Visible = true; + XplatUI.SetZOrder (sizegrip.Handle, vbar.Handle, false, false); + } else if (sizegrip != null) { + sizegrip.Visible = false; + } + + XplatUI.InvalidateNC (Handle); + } + + private void CalcHBar (int left, int right, bool vert_vis) + { + initializing_scrollbars = true; + + hbar.Left = 0; + hbar.Top = ClientRectangle.Bottom - hbar.Height; + hbar.Width = ClientRectangle.Width - (vert_vis ? SystemInformation.VerticalScrollBarWidth : 0); + hbar.LargeChange = 50; + hbar.Minimum = Math.Min (left, 0); + hbar.Maximum = Math.Max (right - ClientSize.Width + 51 + (vert_vis ? SystemInformation.VerticalScrollBarWidth : 0), 0); + hbar.Value = 0; + hbar_value = 0; + hbar.ValueChanged += new EventHandler (HBarValueChanged); + XplatUI.SetZOrder (hbar.Handle, IntPtr.Zero, true, false); + + initializing_scrollbars = false; + } + + private void CalcVBar (int top, int bottom, bool horz_vis) + { + initializing_scrollbars = true; + + vbar.Top = 0; + vbar.Left = ClientRectangle.Right - vbar.Width; + vbar.Height = ClientRectangle.Height - (horz_vis ? SystemInformation.HorizontalScrollBarHeight : 0); + vbar.LargeChange = 50; + vbar.Minimum = Math.Min (top, 0); + vbar.Maximum = Math.Max (bottom - ClientSize.Height + 51 + (horz_vis ? SystemInformation.HorizontalScrollBarHeight : 0), 0); + vbar.Value = 0; + vbar_value = 0; + vbar.ValueChanged += new EventHandler (VBarValueChanged); + XplatUI.SetZOrder (vbar.Handle, IntPtr.Zero, true, false); + + initializing_scrollbars = false; + } + + private void HBarValueChanged (object sender, EventArgs e) + { + if (initializing_scrollbars) + return; + + if (hbar.Value == hbar_value) + return; + + lock_sizing = true; + + try { + int diff = hbar_value - hbar.Value; + foreach (Form child in Widgets) { + child.Left += diff; + } + } finally { + lock_sizing = false; + } + + hbar_value = hbar.Value; + } + + private void VBarValueChanged (object sender, EventArgs e) + { + if (initializing_scrollbars) + return; + + if (vbar.Value == vbar_value) + return; + + lock_sizing = true; + + try { + int diff = vbar_value - vbar.Value; + foreach (Form child in Widgets) { + child.Top += diff; + } + } finally { + lock_sizing = false; + } + + vbar_value = vbar.Value; + } + + private void ArrangeWindows () + { + if (!IsHandleCreated) + return; + + int change = 0; + if (prev_bottom != -1) + change = Bottom - prev_bottom; + + foreach (Widget c in Widgets) { + Form child = c as Form; + + if (c == null || !child.Visible) + continue; + + MdiWindowManager wm = child.WindowManager as MdiWindowManager; + if (wm.GetWindowState () == FormWindowState.Maximized) + child.Bounds = wm.MaximizedBounds; + + if (wm.GetWindowState () == FormWindowState.Minimized) { + child.Top += change; + } + + } + + prev_bottom = Bottom; + } + + internal void ArrangeIconicWindows (bool rearrange_all) + { + Rectangle rect = Rectangle.Empty; + + lock_sizing = true; + foreach (Form form in Widgets) { + if (form.WindowState != FormWindowState.Minimized) + continue; + + MdiWindowManager wm = (MdiWindowManager) form.WindowManager; + + if (wm.IconicBounds != Rectangle.Empty && !rearrange_all) { + if (form.Bounds != wm.IconicBounds) + form.Bounds = wm.IconicBounds; + continue; + } + + bool success = true; + int startx, starty, currentx, currenty; + + rect.Size = wm.IconicSize; + + startx = 0; + starty = ClientSize.Height - rect.Height; + currentx = startx; + currenty = starty; + + do { + rect.X = currentx; + rect.Y = currenty; + success = true; + foreach (Form form2 in Widgets) { + if (form2 == form || form2.window_state != FormWindowState.Minimized) + continue; + + if (form2.Bounds.IntersectsWith(rect)) { + success = false; + break; + } + } + if (!success) { + currentx += rect.Width; + if (currentx + rect.Width > Right) { + currentx = startx; + currenty -= rect.Height; + } + } + } while (!success); + wm.IconicBounds = rect; + form.Bounds = wm.IconicBounds; + } + lock_sizing = false; + } + + internal void ChildFormClosed (Form form) + { + FormWindowState closed_form_windowstate = form.WindowState; + + form.Visible = false; + Widgets.Remove (form); + + if (Widgets.Count == 0) { + ((MdiWindowManager) form.window_manager).RaiseDeactivate (); + } else if (closed_form_windowstate == FormWindowState.Maximized) { + Form current = (Form) Widgets [0]; + current.WindowState = FormWindowState.Maximized; + ActivateChild(current); + } + + if (Widgets.Count == 0) { + XplatUI.RequestNCRecalc (Parent.Handle); + ParentForm.PerformLayout (); + + // If we closed the last child, unmerge the menus. + // If it's not the last child, the menu will be unmerged + // when another child takes focus. + MenuStrip parent_menu = form.MdiParent.MainMenuStrip; + + if (parent_menu != null) + if (parent_menu.IsCurrentlyMerged) + ToolStripManager.RevertMerge (parent_menu); + } + SizeScrollBars (); + SetParentText (false); + form.Dispose(); + } + + internal void ActivateNextChild () + { + if (Widgets.Count < 1) + return; + if (Widgets.Count == 1 && Widgets[0] == ActiveMdiChild) + return; + + Form front = (Form) Widgets [0]; + Form form = (Form) Widgets [1]; + + ActivateChild (form); + front.SendToBack (); + } + + internal void ActivatePreviousChild () + { + if (Widgets.Count <= 1) + return; + + Form back = (Form) Widgets [Widgets.Count - 1]; + + ActivateChild (back); + } + + internal void ActivateChild (Form form) + { + if (Widgets.Count < 1) + return; + + if (ParentForm.is_changing_visible_state > 0) + return; + + Form current = (Form) Widgets [0]; + bool raise_deactivate = ParentForm.ActiveWidget == current; + + // We want to resize the new active form before it is + // made active to avoid flickering. Can't do it in the + // normal way (form.WindowState = Maximized) since it's not + // active yet and everything would just return to before. + // We also won't suspend layout, this way the layout will + // happen before the form is made active (and in many cases + // before it is visible, which avoids flickering as well). + MdiWindowManager wm = (MdiWindowManager)form.WindowManager; + + if (current.WindowState == FormWindowState.Maximized && form.WindowState != FormWindowState.Maximized && form.Visible) { + FormWindowState old_state = form.window_state; + SetWindowState (form, old_state, FormWindowState.Maximized, true); + wm.was_minimized = form.window_state == FormWindowState.Minimized; + form.window_state = FormWindowState.Maximized; + SetParentText (false); + } + + form.BringToFront (); + form.SendWidgetFocus (form); + SetWindowStates (wm); + if (current != form) { + form.has_focus = false; + if (current.IsHandleCreated) + XplatUI.InvalidateNC (current.Handle); + if (form.IsHandleCreated) + XplatUI.InvalidateNC (form.Handle); + if (raise_deactivate) { + MdiWindowManager current_wm = (MdiWindowManager) current.window_manager; + current_wm.RaiseDeactivate (); + + } + } + active_child = (Form) Widgets [0]; + + if (active_child.Visible) { + bool raise_activated = ParentForm.ActiveWidget != active_child; + ParentForm.ActiveWidget = active_child; + if (raise_activated) { + MdiWindowManager active_wm = (MdiWindowManager) active_child.window_manager; + active_wm.RaiseActivated (); + } + } + } + + internal override IntPtr AfterTopMostWidget () + { + // order of scrollbars: + // top = vertical + // sizegrid + // bottom = horizontal + if (hbar != null && hbar.Visible) + return hbar.Handle; + // no need to check for sizegrip since it will only + // be visible if hbar is visible. + if (vbar != null && vbar.Visible) + return vbar.Handle; + + return base.AfterTopMostWidget (); + } + + internal bool SetWindowStates (MdiWindowManager wm) + { + /* + MDI WindowState behaviour: + - If the active window is maximized, all other maximized windows are normalized. + - If a normal window gets focus and the original active window was maximized, + the normal window gets maximized and the original window gets normalized. + - If a minimized window gets focus and the original window was maximized, + the minimzed window gets maximized and the original window gets normalized. + If the ex-minimized window gets deactivated, it will be normalized. + */ + Form form = wm.form; + + if (setting_windowstates) { + return false; + } + + if (!form.Visible) + return false; + + bool is_active = wm.IsActive; + bool maximize_this = false; + + if (!is_active){ + return false; + } + + ArrayList minimize_these = new ArrayList (); + ArrayList normalize_these = new ArrayList (); + + setting_windowstates = true; + foreach (Form frm in mdi_child_list) { + if (frm == form) { + continue; + } else if (!frm.Visible){ + continue; + } + if (frm.WindowState == FormWindowState.Maximized && is_active) { + maximize_this = true; + if (((MdiWindowManager) frm.window_manager).was_minimized) { + minimize_these.Add (frm); + } else { + normalize_these.Add (frm); + } + } + } + + if (maximize_this && form.WindowState != FormWindowState.Maximized) { + wm.was_minimized = form.window_state == FormWindowState.Minimized; + form.WindowState = FormWindowState.Maximized; + } + + foreach (Form frm in minimize_these) + frm.WindowState = FormWindowState.Minimized; + + foreach (Form frm in normalize_these) + frm.WindowState = FormWindowState.Normal; + + + SetParentText (false); + + XplatUI.RequestNCRecalc (ParentForm.Handle); + XplatUI.RequestNCRecalc (Handle); + + SizeScrollBars (); + + setting_windowstates = false; + + if (form.MdiParent.MainMenuStrip != null) + form.MdiParent.MainMenuStrip.RefreshMdiItems (); + + // Implicit menu strip merging + // - When child is activated + // - Parent form must have a MainMenuStrip + // - Find the first menustrip on the child + // - Merge + MenuStrip parent_menu = form.MdiParent.MainMenuStrip; + + if (parent_menu != null) { + if (parent_menu.IsCurrentlyMerged) + ToolStripManager.RevertMerge (parent_menu); + + MenuStrip child_menu = LookForChildMenu (form); + + if (form.WindowState != FormWindowState.Maximized) + RemoveControlMenuItems (wm); + + if (form.WindowState == FormWindowState.Maximized) { + bool found = false; + + foreach (ToolStripItem tsi in parent_menu.Items) { + if (tsi is MdiWidgetStrip.SystemMenuItem) { + (tsi as MdiWidgetStrip.SystemMenuItem).MdiForm = form; + found = true; + } else if (tsi is MdiWidgetStrip.WidgetBoxMenuItem) { + (tsi as MdiWidgetStrip.WidgetBoxMenuItem).MdiForm = form; + found = true; + } + } + + if (!found) { + parent_menu.SuspendLayout (); + parent_menu.Items.Insert (0, new MdiWidgetStrip.SystemMenuItem (form)); + parent_menu.Items.Add (new MdiWidgetStrip.WidgetBoxMenuItem (form, MdiWidgetStrip.ControlBoxType.Close)); + parent_menu.Items.Add (new MdiWidgetStrip.WidgetBoxMenuItem (form, MdiWidgetStrip.ControlBoxType.Max)); + parent_menu.Items.Add (new MdiWidgetStrip.WidgetBoxMenuItem (form, MdiWidgetStrip.ControlBoxType.Min)); + parent_menu.ResumeLayout (); + } + } + + if (child_menu != null) + ToolStripManager.Merge (child_menu, parent_menu); + } + + return maximize_this; + } + + private MenuStrip LookForChildMenu (Widget parent) + { + foreach (Widget c in parent.Widgets) { + if (c is MenuStrip) + return (MenuStrip)c; + + if (c is ToolStripContainer || c is ToolStripPanel) { + MenuStrip ms = LookForChildMenu (c); + + if (ms != null) + return ms; + } + } + + return null; + } + + internal void RemoveControlMenuItems (MdiWindowManager wm) + { + Form form = wm.form; + MenuStrip parent_menu = form.MdiParent.MainMenuStrip; + + // Only remove the items if the form requesting still owns the menu items + if (parent_menu != null) { + parent_menu.SuspendLayout (); + + for (int i = parent_menu.Items.Count - 1; i >= 0; i--) { + if (parent_menu.Items[i] is MdiWidgetStrip.SystemMenuItem) { + if ((parent_menu.Items[i] as MdiWidgetStrip.SystemMenuItem).MdiForm == form) + parent_menu.Items.RemoveAt (i); + } else if (parent_menu.Items[i] is MdiWidgetStrip.WidgetBoxMenuItem) { + if ((parent_menu.Items[i] as MdiWidgetStrip.WidgetBoxMenuItem).MdiForm == form) + parent_menu.Items.RemoveAt (i); + } + } + + parent_menu.ResumeLayout (); + } + } + + internal void SetWindowState (Form form, FormWindowState old_window_state, FormWindowState new_window_state, bool is_activating_child) + { + bool mdiclient_layout; + + MdiWindowManager wm = (MdiWindowManager) form.window_manager; + + if (!is_activating_child && new_window_state == FormWindowState.Maximized && !wm.IsActive) { + ActivateChild (form); + return; + } + + if (old_window_state == FormWindowState.Normal) + wm.NormalBounds = form.Bounds; + + if (SetWindowStates (wm)) + return; + + if (old_window_state == new_window_state) + return; + + mdiclient_layout = old_window_state == FormWindowState.Maximized || new_window_state == FormWindowState.Maximized; + + switch (new_window_state) { + case FormWindowState.Minimized: + ArrangeIconicWindows (false); + break; + case FormWindowState.Maximized: + form.Bounds = wm.MaximizedBounds; + break; + case FormWindowState.Normal: + form.Bounds = wm.NormalBounds; + break; + } + + wm.UpdateWindowDecorations (new_window_state); + + form.ResetCursor (); + + if (mdiclient_layout) + Parent.PerformLayout (); + + XplatUI.RequestNCRecalc (Parent.Handle); + XplatUI.RequestNCRecalc (form.Handle); + if (!setting_windowstates) + SizeScrollBars (); + } + internal int ChildrenCreated { + get { return mdi_created; } + set { mdi_created = value; } + } + + internal Form ActiveMdiChild { + get { + if (ParentForm != null && !ParentForm.Visible) + return null; + + if (Widgets.Count < 1) + return null; + + if (!ParentForm.IsHandleCreated) + return null; + + if (!ParentForm.has_been_visible) + return null; + + if (!ParentForm.Visible) + return active_child; + + active_child = null; + for (int i = 0; i < Widgets.Count; i++) { + if (Widgets [i].Visible) { + active_child = (Form) Widgets [i]; + break; + } + } + return active_child; + } + set { + ActivateChild (value); + } + } + + internal void ActivateActiveMdiChild () + { + if (ParentForm.is_changing_visible_state > 0) + return; + + for (int i = 0; i < Widgets.Count; i++) { + if (Widgets [i].Visible) { + ActivateChild ((Form) Widgets [i]); + return; + } + } + } + } +} + diff --git a/source/ShiftUI/Internal/MdiControlStrip.cs b/source/ShiftUI/Internal/MdiControlStrip.cs new file mode 100644 index 0000000..a04e02a --- /dev/null +++ b/source/ShiftUI/Internal/MdiControlStrip.cs @@ -0,0 +1,207 @@ +// +// MdiWidgetstrip.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +using System; +using System.Runtime.InteropServices; +using System.ComponentModel; +using System.Drawing; +using ShiftUI.Layout; +using System.Collections.Generic; +using System.ComponentModel.Design.Serialization; + +namespace ShiftUI +{ + internal class MdiWidgetStrip + { + public class SystemMenuItem : ToolStripMenuItem + { + private Form form; + + public SystemMenuItem (Form ownerForm) + { + form = ownerForm; + + base.AutoSize = false; + base.Size = new Size (20, 20); + base.Image = ownerForm.Icon.ToBitmap (); + base.MergeIndex = int.MinValue; + base.DisplayStyle = ToolStripItemDisplayStyle.Image; + + DropDownItems.Add ("&Restore", null, RestoreItemHandler); + ToolStripMenuItem tsiMove = (ToolStripMenuItem)DropDownItems.Add ("&Move"); + tsiMove.Enabled = false; + ToolStripMenuItem tsiSize = (ToolStripMenuItem)DropDownItems.Add ("&Size"); + tsiSize.Enabled = false; + DropDownItems.Add ("Mi&nimize", null, MinimizeItemHandler); + ToolStripMenuItem tsiMaximize = (ToolStripMenuItem)DropDownItems.Add ("Ma&ximize"); + tsiMaximize.Enabled = false; + DropDownItems.Add ("-"); + ToolStripMenuItem tsiClose = (ToolStripMenuItem)DropDownItems.Add ("&Close", null, CloseItemHandler); + tsiClose.ShortcutKeys = Keys.Widget | Keys.F4; + DropDownItems.Add ("-"); + ToolStripMenuItem tsiNext = (ToolStripMenuItem)DropDownItems.Add ("Nex&t", null, NextItemHandler); + tsiNext.ShortcutKeys = Keys.Widget | Keys.F6; + } + + protected override void OnPaint (PaintEventArgs e) + { + // Can't render without an owner + if (this.Owner == null) + return; + + // If DropDown.ShowImageMargin is false, we don't display the image + Image draw_image = this.Image; + + // Figure out where our text and image go + Rectangle text_layout_rect; + Rectangle image_layout_rect; + + this.CalculateTextAndImageRectangles (out text_layout_rect, out image_layout_rect); + + if (image_layout_rect != Rectangle.Empty) + this.Owner.Renderer.DrawItemImage (new ToolStripItemImageRenderEventArgs (e.Graphics, this, draw_image, image_layout_rect)); + + return; + } + + public Form MdiForm { + get { return form; } + set { form = value; } + } + + private void RestoreItemHandler (object sender, EventArgs e) + { + form.WindowState = FormWindowState.Normal; + } + + private void MinimizeItemHandler (object sender, EventArgs e) + { + form.WindowState = FormWindowState.Minimized; + } + + private void CloseItemHandler (object sender, EventArgs e) + { + form.Close (); + } + + private void NextItemHandler (object sender, EventArgs e) + { + form.MdiParent.MdiContainer.ActivateNextChild (); + } + } + + public class WidgetBoxMenuItem : ToolStripMenuItem + { + private Form form; + private ControlBoxType type; + + public WidgetBoxMenuItem (Form ownerForm, ControlBoxType type) + { + form = ownerForm; + this.type = type; + + base.AutoSize = false; + base.Alignment = ToolStripItemAlignment.Right; + base.Size = new Size (20, 20); + base.MergeIndex = int.MaxValue; + base.DisplayStyle = ToolStripItemDisplayStyle.None; + + switch (type) { + case ControlBoxType.Close: + this.Click += new EventHandler(CloseItemHandler); + break; + case ControlBoxType.Min: + this.Click += new EventHandler (MinimizeItemHandler); + break; + case ControlBoxType.Max: + this.Click += new EventHandler (RestoreItemHandler); + break; + } + } + + protected override void OnPaint (PaintEventArgs e) + { + base.OnPaint (e); + Graphics g = e.Graphics; + + switch (type) { + case ControlBoxType.Close: + g.FillRectangle (Brushes.Black, 8, 8, 4, 4); + g.FillRectangle (Brushes.Black, 6, 6, 2, 2); + g.FillRectangle (Brushes.Black, 6, 12, 2, 2); + g.FillRectangle (Brushes.Black, 12, 6, 2, 2); + g.FillRectangle (Brushes.Black, 12, 12, 2, 2); + g.DrawLine (Pens.Black, 8, 7, 8, 12); + g.DrawLine (Pens.Black, 7, 8, 12, 8); + g.DrawLine (Pens.Black, 11, 7, 11, 12); + g.DrawLine (Pens.Black, 7, 11, 12, 11); + break; + case ControlBoxType.Min: + g.DrawLine (Pens.Black, 6, 12, 11, 12); + g.DrawLine (Pens.Black, 6, 13, 11, 13); + break; + case ControlBoxType.Max: + g.DrawLines (Pens.Black, new Point[] {new Point (7, 8), new Point (7, 5), new Point (13, 5), new Point (13, 10), new Point (11, 10)}); + g.DrawLine (Pens.Black, 7, 6, 12, 6); + + g.DrawRectangle (Pens.Black, new Rectangle (5, 8, 6, 5)); + g.DrawLine (Pens.Black, 5, 9, 11, 9); + + break; + } + } + + public Form MdiForm { + get { return form; } + set { form = value; } + } + + private void RestoreItemHandler (object sender, EventArgs e) + { + form.WindowState = FormWindowState.Normal; + } + + private void MinimizeItemHandler (object sender, EventArgs e) + { + form.WindowState = FormWindowState.Minimized; + } + + private void CloseItemHandler (object sender, EventArgs e) + { + form.Close (); + } + } + + public enum ControlBoxType + { + Close, + Min, + Max + } + } +} diff --git a/source/ShiftUI/Internal/MdiLayout.cs b/source/ShiftUI/Internal/MdiLayout.cs new file mode 100644 index 0000000..8c610a4 --- /dev/null +++ b/source/ShiftUI/Internal/MdiLayout.cs @@ -0,0 +1,36 @@ +// 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 + +namespace ShiftUI { + public enum MdiLayout { + Cascade = 0, + TileHorizontal = 1, + TileVertical = 2, + ArrangeIcons = 3 + } +} diff --git a/source/ShiftUI/Internal/MdiWindowManager.cs b/source/ShiftUI/Internal/MdiWindowManager.cs new file mode 100644 index 0000000..0344f2c --- /dev/null +++ b/source/ShiftUI/Internal/MdiWindowManager.cs @@ -0,0 +1,624 @@ +// 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: +// Jackson Harper ([email protected]) +// +// + + +using System; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Runtime.InteropServices; + +namespace ShiftUI { + + internal class MdiWindowManager : InternalWindowManager { + + private MainMenu merged_menu; + private MainMenu maximized_menu; + private MenuItem icon_menu; + internal bool was_minimized; + + private PaintEventHandler draw_maximized_buttons; + internal EventHandler form_closed_handler; + + private MdiClient mdi_container; + private Rectangle prev_virtual_position; + + private Point icon_clicked; + private DateTime icon_clicked_time; + private bool icon_dont_show_popup; + + private TitleButtons maximized_title_buttons; + private bool is_visible_pending; + private byte last_activation_event; // 0 = none, 1 = activated, 2 = deactivated. + + public void RaiseActivated () + { + if (last_activation_event == 1) + return; + + last_activation_event = 1; + form.OnActivatedInternal (); + form.SelectActiveWidget (); + } + + public void RaiseDeactivate () + { + if (last_activation_event != 1) + return; + last_activation_event = 2; + form.OnDeactivateInternal (); + } + + public override int MenuHeight { + get { + // Mdi children don't get menus on the form, they're shown on the main form. + return 0; + } + } + + internal bool IsVisiblePending { + get { + return is_visible_pending; + } + set { + is_visible_pending = value; + } + } + + private TitleButtons MaximizedTitleButtons { + get { + if (maximized_title_buttons == null) { + maximized_title_buttons = new TitleButtons (this.Form); + maximized_title_buttons.CloseButton.Visible = true; + maximized_title_buttons.RestoreButton.Visible = true; + maximized_title_buttons.MinimizeButton.Visible = true; + } + return maximized_title_buttons; + } + } + + internal override Rectangle MaximizedBounds { + get { + Rectangle pb = mdi_container.ClientRectangle; + int bw = ThemeEngine.Current.ManagedWindowBorderWidth (this); + int tw = TitleBarHeight; + + Rectangle new_bounds = new Rectangle (pb.Left - bw, + pb.Top - tw - bw, + pb.Width + bw * 2, + pb.Height + tw + bw * 2); + return new_bounds; + } + } + + + + public MdiWindowManager (Form form, MdiClient mdi_container) : base (form) + { + this.mdi_container = mdi_container; + if (form.WindowState == FormWindowState.Normal) { + NormalBounds = form.Bounds; + } + form_closed_handler = new EventHandler (FormClosed); + form.Closed += form_closed_handler; + form.TextChanged += new EventHandler (FormTextChangedHandler); + form.SizeChanged += new EventHandler (FormSizeChangedHandler); + form.LocationChanged += new EventHandler (FormLocationChangedHandler); + form.VisibleChanged += new EventHandler (FormVisibleChangedHandler); + draw_maximized_buttons = new PaintEventHandler (DrawMaximizedButtons); + CreateIconMenus (); + } + + private void FormVisibleChangedHandler (object sender, EventArgs e) + { + if (mdi_container == null) + return; + + if (form.Visible) { + mdi_container.ActivateChild (form); + } else if (mdi_container.Widgets.Count > 1) { + mdi_container.ActivateActiveMdiChild (); + } + } + + private void FormTextChangedHandler (object sender, EventArgs e) + { + mdi_container.SetParentText (false); + + if (form.MdiParent.MainMenuStrip != null) + form.MdiParent.MainMenuStrip.RefreshMdiItems (); + } + + private void FormLocationChangedHandler (object sender, EventArgs e) + { + if (form.window_state == FormWindowState.Minimized) + IconicBounds = form.Bounds; + form.MdiParent.MdiContainer.SizeScrollBars (); + } + + private void FormSizeChangedHandler (object sender, EventArgs e) + { + if (form.window_state == FormWindowState.Maximized && form.Bounds != MaximizedBounds) + form.Bounds = MaximizedBounds; + + form.MdiParent.MdiContainer.SizeScrollBars (); + } + + public MainMenu MergedMenu { + get { + if (merged_menu == null) + merged_menu = CreateMergedMenu (); + return merged_menu; + } + } + + private MainMenu CreateMergedMenu () + { + Form parent = (Form) mdi_container.Parent; + MainMenu clone; + if (parent.Menu != null) + clone = (MainMenu) parent.Menu.CloneMenu (); + else + clone = new MainMenu (); + + if (form.WindowState == FormWindowState.Maximized) { + + } + clone.MergeMenu (form.Menu); + clone.MenuChanged += new EventHandler (MenuChangedHandler); + clone.SetForm (parent); + return clone; + } + + public MainMenu MaximizedMenu { + get { + if (maximized_menu == null) + maximized_menu = CreateMaximizedMenu (); + return maximized_menu; + } + } + + private MainMenu CreateMaximizedMenu () + { + Form parent = (Form) mdi_container.Parent; + + if (form.MainMenuStrip != null || parent.MainMenuStrip != null) + return null; + + MainMenu res = new MainMenu (); + + if (parent.Menu != null) { + MainMenu clone = (MainMenu) parent.Menu.CloneMenu (); + res.MergeMenu (clone); + } + + if (form.Menu != null) { + MainMenu clone = (MainMenu) form.Menu.CloneMenu (); + res.MergeMenu (clone); + } + + if (res.MenuItems.Count == 0) + res.MenuItems.Add (new MenuItem ()); // Dummy item to get the menu height correct + + res.MenuItems.Insert (0, icon_menu); + + res.SetForm (parent); + return res; + } + + private void CreateIconMenus () + { + //TODO: remove this unneeded crap + } + + private void ClickIconMenuItem(object sender, EventArgs e) + { + if ((DateTime.Now - icon_clicked_time).TotalMilliseconds <= SystemInformation.DoubleClickTime) { + form.Close (); + return; + } + icon_clicked_time = DateTime.Now; + Point pnt = Point.Empty; + pnt = form.MdiParent.PointToScreen (pnt); + pnt = form.PointToClient (pnt); + ShowPopup (pnt); + } + + internal void ShowPopup (Point pnt) + { + // If we are using MainMenuStrip, display that menu instead + if (form.WindowState == FormWindowState.Maximized && form.MdiParent.MainMenuStrip != null) + if (form.MdiParent.MainMenuStrip.Items.Count > 0) { + ToolStripItem tsi = form.MdiParent.MainMenuStrip.Items[0]; + + if (tsi is MdiWidgetStrip.SystemMenuItem) { + (tsi as MdiWidgetStrip.SystemMenuItem).ShowDropDown (); + return; + } + } + + } + + private void RestoreItemHandler (object sender, EventArgs e) + { + form.WindowState = FormWindowState.Normal; + } + + private void MoveItemHandler (object sender, EventArgs e) + { + int x = 0; + int y = 0; + + PointToScreen (ref x, ref y); + Cursor.Position = new Point (x, y); + form.Cursor = Cursors.Cross; + state = State.Moving; + form.Capture = true; + } + + private void SizeItemHandler (object sender, EventArgs e) + { + int x = 0; + int y = 0; + + PointToScreen (ref x, ref y); + Cursor.Position = new Point (x, y); + form.Cursor = Cursors.Cross; + state = State.Sizing; + form.Capture = true; + } + + private void MinimizeItemHandler (object sender, EventArgs e) + { + form.WindowState = FormWindowState.Minimized; + } + + private void MaximizeItemHandler (object sender, EventArgs e) + { + if (form.WindowState != FormWindowState.Maximized) + form.WindowState = FormWindowState.Maximized; + } + + private void CloseItemHandler (object sender, EventArgs e) + { + form.Close (); + } + + private void NextItemHandler (object sender, EventArgs e) + { + mdi_container.ActivateNextChild (); + } + + private void DrawIconMenuItem (object sender, DrawItemEventArgs de) + { + de.Graphics.DrawIcon (form.Icon, new Rectangle (de.Bounds.X + 2, de.Bounds.Y + 2, + de.Bounds.Height - 4, de.Bounds.Height - 4)); + } + + private void MeasureIconMenuItem (object sender, MeasureItemEventArgs me) + { + int size = SystemInformation.MenuHeight; + me.ItemHeight = size; + me.ItemWidth = size + 2; // some padding + } + + private void MenuChangedHandler (object sender, EventArgs e) + { + CreateMergedMenu (); + } + + public override void PointToClient (ref int x, ref int y) + { + XplatUI.ScreenToClient (mdi_container.Handle, ref x, ref y); + } + + public override void PointToScreen (ref int x, ref int y) + { + XplatUI.ClientToScreen (mdi_container.Handle, ref x, ref y); + } + + public override void UpdateWindowDecorations (FormWindowState window_state) + { + if (MaximizedMenu != null) { + switch (window_state) { + case FormWindowState.Minimized: + case FormWindowState.Normal: + MaximizedMenu.Paint -= draw_maximized_buttons; + MaximizedTitleButtons.Visible = false; + TitleButtons.Visible = true; + break; + case FormWindowState.Maximized: + MaximizedMenu.Paint += draw_maximized_buttons; + MaximizedTitleButtons.Visible = true; + TitleButtons.Visible = false; + break; + } + } + + base.UpdateWindowDecorations (window_state); + } + + public override void SetWindowState (FormWindowState old_state, FormWindowState window_state) + { + mdi_container.SetWindowState (form, old_state, window_state, false); + } + + private void FormClosed (object sender, EventArgs e) + { + mdi_container.ChildFormClosed (form); + + if (form.MdiParent.MainMenuStrip != null) + form.MdiParent.MainMenuStrip.RefreshMdiItems (); + + mdi_container.RemoveControlMenuItems (this); + } + + public override void DrawMaximizedButtons (object sender, PaintEventArgs pe) + { + Size bs = ThemeEngine.Current.ManagedWindowGetMenuButtonSize (this); + Point pnt = XplatUI.GetMenuOrigin (mdi_container.ParentForm.Handle); + int bw = ThemeEngine.Current.ManagedWindowBorderWidth (this); + TitleButtons buttons = MaximizedTitleButtons; + + buttons.Visible = true; + TitleButtons.Visible = false; + + buttons.CloseButton.Rectangle = new Rectangle (mdi_container.ParentForm.Size.Width - 1 - bw - bs.Width - 2, + pnt.Y + 2, bs.Width, bs.Height); + + buttons.RestoreButton.Rectangle = new Rectangle (buttons.CloseButton.Rectangle.Left - 2 - bs.Width, + pnt.Y + 2, bs.Width, bs.Height); + + buttons.MinimizeButton.Rectangle = new Rectangle (buttons.RestoreButton.Rectangle.Left - bs.Width, + pnt.Y + 2, bs.Width, bs.Height); + + DrawTitleButton (pe.Graphics, buttons.MinimizeButton, pe.ClipRectangle); + DrawTitleButton (pe.Graphics, buttons.RestoreButton, pe.ClipRectangle); + DrawTitleButton (pe.Graphics, buttons.CloseButton, pe.ClipRectangle); + + buttons.MinimizeButton.Rectangle.Y -= pnt.Y; + buttons.RestoreButton.Rectangle.Y -= pnt.Y; + buttons.CloseButton.Rectangle.Y -= pnt.Y; + } + + public bool HandleMenuMouseDown (MainMenu menu, int x, int y) + { + Point pt = MenuTracker.ScreenToMenu (menu, new Point (x, y)); + + HandleTitleBarDown (pt.X, pt.Y); + return TitleButtons.AnyPushedTitleButtons; + } + + public void HandleMenuMouseUp (MainMenu menu, int x, int y) + { + Point pt = MenuTracker.ScreenToMenu (menu, new Point (x, y)); + + HandleTitleBarUp (pt.X, pt.Y); + } + + public void HandleMenuMouseLeave (MainMenu menu, int x, int y) + { + Point pt = MenuTracker.ScreenToMenu (menu, new Point (x, y)); + HandleTitleBarLeave (pt.X, pt.Y); + + } + + public void HandleMenuMouseMove (MainMenu menu, int x, int y) + { + Point pt = MenuTracker.ScreenToMenu (menu, new Point (x, y)); + + HandleTitleBarMouseMove (pt.X, pt.Y); + + } + + protected override void HandleTitleBarLeave (int x, int y) + { + base.HandleTitleBarLeave (x, y); + + if (maximized_title_buttons != null) { + maximized_title_buttons.MouseLeave (x, y); + } + + if (IsMaximized) + XplatUI.InvalidateNC (form.MdiParent.Handle); + } + + protected override void HandleTitleBarUp (int x, int y) + { + if (IconRectangleContains (x, y)) { + if (!icon_dont_show_popup) { + if (IsMaximized) + ClickIconMenuItem (null, null); + else + ShowPopup (Point.Empty); + } else { + icon_dont_show_popup = false; + } + return; + } + + bool was_maximized = IsMaximized; + base.HandleTitleBarUp (x, y); + if (maximized_title_buttons != null && was_maximized) { + maximized_title_buttons.MouseUp (x, y); + } + + if (IsMaximized) + XplatUI.InvalidateNC (mdi_container.Parent.Handle); + } + + protected override void HandleTitleBarDoubleClick (int x, int y) + { + if (IconRectangleContains (x, y)) { + form.Close (); + } else if (form.MaximizeBox == true) { + form.WindowState = FormWindowState.Maximized; + } + base.HandleTitleBarDoubleClick (x, y); + } + + protected override void HandleTitleBarDown (int x, int y) + { + if (IconRectangleContains (x, y)) { + if ((DateTime.Now - icon_clicked_time).TotalMilliseconds <= SystemInformation.DoubleClickTime && icon_clicked.X == x && icon_clicked.Y == y) { + form.Close (); + } else { + icon_clicked_time = DateTime.Now; + icon_clicked.X = x; + icon_clicked.Y = y; + } + + return; + } + + base.HandleTitleBarDown (x, y); + + if (maximized_title_buttons != null) { + maximized_title_buttons.MouseDown (x, y); + } + + if (IsMaximized) { + XplatUI.InvalidateNC (mdi_container.Parent.Handle); + } + } + + protected override void HandleTitleBarMouseMove (int x, int y) + { + base.HandleTitleBarMouseMove (x, y); + + if (maximized_title_buttons != null && maximized_title_buttons.MouseMove (x, y)) + XplatUI.InvalidateNC (form.MdiParent.Handle); + } + + protected override bool HandleLButtonDblClick (ref Message m) + { + + int x = Widget.LowOrder ((int)m.LParam.ToInt32 ()); + int y = Widget.HighOrder ((int)m.LParam.ToInt32 ()); + + // Correct since we are in NC land. + NCClientToNC (ref x, ref y); + + if (IconRectangleContains (x, y)) { + form.Close (); + return true; + } + + return base.HandleLButtonDblClick (ref m); + } + + protected override bool HandleLButtonDown (ref Message m) + { + + int x = Widget.LowOrder ((int)m.LParam.ToInt32 ()); + int y = Widget.HighOrder ((int)m.LParam.ToInt32 ()); + + // Correct y since we are in NC land. + NCClientToNC(ref x, ref y); + + if (IconRectangleContains (x, y)){ + if ((DateTime.Now - icon_clicked_time).TotalMilliseconds <= SystemInformation.DoubleClickTime) { + form.Close (); + return true; + } else if (form.Capture) { + icon_dont_show_popup = true; + } + } + return base.HandleLButtonDown (ref m); + } + + protected override bool ShouldRemoveWindowManager (FormBorderStyle style) + { + return false; + } + + protected override void HandleWindowMove (Message m) + { + Point pos = Cursor.Position; + Point move = MouseMove (pos); + + if (move.X == 0 && move.Y == 0) + return; + + int x = virtual_position.X + move.X; + int y = virtual_position.Y + move.Y; + + Rectangle client = mdi_container.ClientRectangle; + if (mdi_container.VerticalScrollbarVisible) + client.Width -= SystemInformation.VerticalScrollBarWidth; + if (mdi_container.HorizontalScrollbarVisible) + client.Height -= SystemInformation.HorizontalScrollBarHeight; + + UpdateVP (x, y, form.Width, form.Height); + + start = pos; + } + + protected override bool HandleNCMouseMove (ref Message m) + { + XplatUI.RequestAdditionalWM_NCMessages (form.Handle, true, true); + return base.HandleNCMouseMove (ref m); + } + + protected override void DrawVirtualPosition (Rectangle virtual_position) + { + ClearVirtualPosition (); + + if (form.Parent != null) + XplatUI.DrawReversibleRectangle (form.Parent.Handle, virtual_position, 2); + prev_virtual_position = virtual_position; + } + + protected override void ClearVirtualPosition () + { + if (prev_virtual_position != Rectangle.Empty && form.Parent != null) + XplatUI.DrawReversibleRectangle (form.Parent.Handle, + prev_virtual_position, 2); + prev_virtual_position = Rectangle.Empty; + } + + protected override void OnWindowFinishedMoving () + { + form.Refresh (); + } + + public override bool IsActive { + get { + if (mdi_container == null) + return false; + return mdi_container.ActiveMdiChild == form; + } + } + + protected override void Activate () + { + if (mdi_container.ActiveMdiChild != form) { + mdi_container.ActivateChild (form); + } + base.Activate (); + } + } +} + diff --git a/source/ShiftUI/Internal/Message.cs b/source/ShiftUI/Internal/Message.cs new file mode 100644 index 0000000..90881c3 --- /dev/null +++ b/source/ShiftUI/Internal/Message.cs @@ -0,0 +1,118 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] + + +// COMPLETE + +using System; +using System.Runtime.InteropServices; +using System.Text; +using System.Diagnostics; + +namespace ShiftUI { + public struct Message { + private int msg; + private IntPtr hwnd; + private IntPtr lParam; + private IntPtr wParam; + private IntPtr result; + + #region Public Instance Properties + public IntPtr HWnd { + get { return hwnd; } + set { hwnd=value; } + } + + public IntPtr LParam { + get { return lParam; } + set { lParam=value; } + } + + public int Msg { + get { return msg; } + set { msg=value; } + } + + public IntPtr Result { + get { return result; } + set { result=value; } + } + + public IntPtr WParam { + get { return wParam; } + set { wParam=value; } + } + #endregion // Public Instance Properties + + #region Public Static Methods + public static Message Create(IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam) { + Message new_message = new Message(); + + new_message.msg=msg; + new_message.hwnd=hWnd; + new_message.wParam=wparam; + new_message.lParam=lparam; + return new_message; + } + + public static bool operator == (Message a, Message b) + { + return (a.hwnd == b.hwnd) && (a.lParam == b.lParam) && (a.msg == b.msg) && (a.result == b.result) && (a.wParam == b.wParam); + } + + public static bool operator != (Message a, Message b) + { + return !(a == b); + } + #endregion // Public Static Methods + + #region Public Instance Methods + public override bool Equals(object o) { + if (!(o is Message)) { + return false; + } + + return ((this.msg == ((Message)o).msg) && + (this.hwnd == ((Message)o).hwnd) && + (this.lParam == ((Message)o).lParam) && + (this.wParam == ((Message)o).wParam) && + (this.result == ((Message)o).result)); + } + + public override int GetHashCode() { + return base.GetHashCode(); + } + + public object GetLParam(Type cls) { + object o = Marshal.PtrToStructure(this.lParam, cls); + + return(o); + } + + public override string ToString() { + return String.Format ("msg=0x{0:x} ({1}) hwnd=0x{2:x} wparam=0x{3:x} lparam=0x{4:x} result=0x{5:x}", msg, ((Msg) msg).ToString (), hwnd.ToInt32 (), wParam.ToInt32 (), lParam.ToInt32 (), result.ToInt32 ()); + } + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/MethodInvoker.cs b/source/ShiftUI/Internal/MethodInvoker.cs new file mode 100644 index 0000000..e0275f8 --- /dev/null +++ b/source/ShiftUI/Internal/MethodInvoker.cs @@ -0,0 +1,31 @@ +// 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 + +namespace ShiftUI { + public delegate void MethodInvoker(); +} diff --git a/source/ShiftUI/Internal/MouseHandler.cs b/source/ShiftUI/Internal/MouseHandler.cs new file mode 100644 index 0000000..9eb86be --- /dev/null +++ b/source/ShiftUI/Internal/MouseHandler.cs @@ -0,0 +1,228 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton <[email protected]> +// +// + +using System; +using System.Runtime.InteropServices; + +namespace ShiftUI.CarbonInternal { + internal class MouseHandler : EventHandlerBase, IEventHandler { + internal const uint kEventMouseDown = 1; + internal const uint kEventMouseUp = 2; + internal const uint kEventMouseMoved = 5; + internal const uint kEventMouseDragged = 6; + internal const uint kEventMouseEntered = 8; + internal const uint kEventMouseExited = 9; + internal const uint kEventMouseWheelMoved = 10; + internal const uint kEventMouseScroll = 11; + + internal const uint kEventParamMouseLocation = 1835822947; + internal const uint kEventParamMouseButton = 1835168878; + internal const uint kEventParamMouseWheelAxis = 1836540280; + internal const uint kEventParamMouseWheelDelta = 1836541036; + internal const uint typeLongInteger = 1819242087; + internal const uint typeMouseWheelAxis = 1836540280; + internal const uint typeMouseButton = 1835168878; + internal const uint typeQDPoint = 1363439732; + + internal const uint kEventMouseWheelAxisX = 0; + internal const uint kEventMouseWheelAxisY = 1; + + internal const uint DoubleClickInterval = 7500000; + internal static ClickStruct ClickPending; + + internal MouseHandler (XplatUICarbon driver) : base (driver) {} + + public bool ProcessEvent (IntPtr callref, IntPtr eventref, IntPtr handle, uint kind, ref MSG msg) { + QDPoint qdpoint = new QDPoint (); + CGPoint point = new CGPoint (); + Rect window_bounds = new Rect (); + IntPtr view_handle = IntPtr.Zero; + IntPtr window_handle = IntPtr.Zero; + bool client = true; + ushort button = 0; + Hwnd hwnd; + + GetEventParameter (eventref, kEventParamMouseLocation, typeQDPoint, IntPtr.Zero, (uint)Marshal.SizeOf (typeof (QDPoint)), IntPtr.Zero, ref qdpoint); + GetEventParameter (eventref, kEventParamMouseButton, typeMouseButton, IntPtr.Zero, (uint)Marshal.SizeOf (typeof (ushort)), IntPtr.Zero, ref button); + + if (button == 1 && ((Driver.ModifierKeys & Keys.Widget) != 0)) + button = 2; + + point.x = qdpoint.x; + point.y = qdpoint.y; + + if (FindWindow (qdpoint, ref window_handle) == 5) + return true; + + GetWindowBounds (handle, 33, ref window_bounds); + HIViewFindByID (HIViewGetRoot (handle), new HIViewID (EventHandler.kEventClassWindow, 1), ref window_handle); + + point.x -= window_bounds.left; + point.y -= window_bounds.top; + + HIViewGetSubviewHit (window_handle, ref point, true, ref view_handle); + HIViewConvertPoint (ref point, window_handle, view_handle); + + hwnd = Hwnd.ObjectFromHandle (view_handle); + + if (hwnd != null) + client = (hwnd.ClientWindow == view_handle ? true : false); + + if (XplatUICarbon.Grab.Hwnd != IntPtr.Zero) { + hwnd = Hwnd.ObjectFromHandle (XplatUICarbon.Grab.Hwnd); + client = true; + } + if (hwnd == null) + return true; + + if (client) { + qdpoint.x = (short) point.x; + qdpoint.y = (short) point.y; + + Driver.ScreenToClient (hwnd.Handle, ref qdpoint); + } else { + point.x = qdpoint.x; + point.y = qdpoint.y; + } + + msg.hwnd = hwnd.Handle; + msg.lParam = (IntPtr) ((ushort) point.y << 16 | (ushort) point.x); + + switch (kind) { + case kEventMouseDown: + UpdateMouseState (button, true); + msg.message = (client ? Msg.WM_MOUSEMOVE : Msg.WM_NCMOUSEMOVE) + ((button - 1) * 3) + 1; + msg.wParam = Driver.GetMousewParam (0); + if (ClickPending.Pending && (((DateTime.Now.Ticks - ClickPending.Time) < DoubleClickInterval) && (msg.hwnd == ClickPending.Hwnd) && (msg.wParam == ClickPending.wParam) && (msg.lParam == ClickPending.lParam) && (msg.message == ClickPending.Message))) { + msg.message = (client ? Msg.WM_MOUSEMOVE : Msg.WM_NCMOUSEMOVE) + ((button - 1) * 3) + 3; + ClickPending.Pending = false; + } else { + ClickPending.Pending = true; + ClickPending.Hwnd = msg.hwnd; + ClickPending.Message = msg.message; + ClickPending.wParam = msg.wParam; + ClickPending.lParam = msg.lParam; + ClickPending.Time = DateTime.Now.Ticks; + } + break; + case kEventMouseUp: + UpdateMouseState (button, false); + msg.message = (client ? Msg.WM_MOUSEMOVE : Msg.WM_NCMOUSEMOVE) + ((button - 1) * 3) + 2; + msg.wParam = Driver.GetMousewParam (0); + break; + case kEventMouseDragged: + case kEventMouseMoved: + if (XplatUICarbon.Grab.Hwnd == IntPtr.Zero) { + IntPtr ht = IntPtr.Zero; + if (client) { + ht = (IntPtr) HitTest.HTCLIENT; + NativeWindow.WndProc(msg.hwnd, Msg.WM_SETCURSOR, msg.hwnd, (IntPtr)HitTest.HTCLIENT); + } else { + ht = (IntPtr) NativeWindow.WndProc (hwnd.client_window, Msg.WM_NCHITTEST, IntPtr.Zero, msg.lParam).ToInt32 (); + NativeWindow.WndProc(hwnd.client_window, Msg.WM_SETCURSOR, msg.hwnd, ht); + } + } + msg.message = (client ? Msg.WM_MOUSEMOVE : Msg.WM_NCMOUSEMOVE); + msg.wParam = Driver.GetMousewParam (0); + break; + case kEventMouseWheelMoved: + case kEventMouseScroll: + UInt16 axis = 0; + Int32 delta = 0; + + GetEventParameter (eventref, kEventParamMouseWheelAxis, typeMouseWheelAxis, IntPtr.Zero, (uint)Marshal.SizeOf (typeof (UInt16)), IntPtr.Zero, ref axis); + GetEventParameter (eventref, kEventParamMouseWheelDelta, typeLongInteger, IntPtr.Zero, (uint)Marshal.SizeOf (typeof (Int32)), IntPtr.Zero, ref delta); + + if (axis == kEventMouseWheelAxisY) { + msg.hwnd = XplatUICarbon.FocusWindow; + msg.message = Msg.WM_MOUSEWHEEL; + msg.wParam = Driver.GetMousewParam (delta*40); + return true; + } + break; + default: + return false; + } + Driver.mouse_position.X = (int) point.x; + Driver.mouse_position.Y = (int) point.y; + return true; + } + + internal bool TranslateMessage (ref MSG msg) { + if (msg.message == Msg.WM_MOUSEMOVE || msg.message == Msg.WM_NCMOUSEMOVE) { + Hwnd hwnd = Hwnd.ObjectFromHandle (msg.hwnd); + if (XplatUICarbon.MouseHwnd == null) { + Driver.PostMessage (hwnd.Handle, Msg.WM_MOUSE_ENTER, IntPtr.Zero, IntPtr.Zero); + Cursor.SetCursor (hwnd.Cursor); + } else if (XplatUICarbon.MouseHwnd.Handle != hwnd.Handle) { + Driver.PostMessage (XplatUICarbon.MouseHwnd.Handle, Msg.WM_MOUSELEAVE, IntPtr.Zero, IntPtr.Zero); + Driver.PostMessage (hwnd.Handle, Msg.WM_MOUSE_ENTER, IntPtr.Zero, IntPtr.Zero); + Cursor.SetCursor (hwnd.Cursor); + } + XplatUICarbon.MouseHwnd = hwnd; + } + + return false; + } + + private void UpdateMouseState (int button, bool down) { + switch (button) { + case 1: + if (down) XplatUICarbon.MouseState |= MouseButtons.Left; else XplatUICarbon.MouseState &= ~MouseButtons.Left; + break; + case 2: + if (down) XplatUICarbon.MouseState |= MouseButtons.Right; else XplatUICarbon.MouseState &= ~MouseButtons.Right; + break; + case 3: + if (down) XplatUICarbon.MouseState |= MouseButtons.Middle; else XplatUICarbon.MouseState &= ~MouseButtons.Middle; + break; + } + } + + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int GetEventParameter (IntPtr eventref, uint name, uint type, IntPtr outtype, uint size, IntPtr outsize, ref QDPoint data); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int GetEventParameter (IntPtr eventref, uint name, uint type, IntPtr outtype, uint size, IntPtr outsize, ref Int32 data); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int GetEventParameter (IntPtr eventref, uint name, uint type, IntPtr outtype, uint size, IntPtr outsize, ref ushort data); + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal static extern short FindWindow (QDPoint point, ref IntPtr handle); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal static extern int GetWindowBounds (IntPtr handle, uint region, ref Rect bounds); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal static extern int HIViewConvertPoint (ref CGPoint point, IntPtr source_view, IntPtr target_view); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal static extern IntPtr HIViewGetRoot (IntPtr handle); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal static extern int HIViewGetSubviewHit (IntPtr content_view, ref CGPoint point, bool tval, ref IntPtr hit_view); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal static extern int HIViewFindByID (IntPtr root_window, HIViewID id, ref IntPtr view_handle); + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal static extern int GetCurrentEventButtonState (); + } +} diff --git a/source/ShiftUI/Internal/NativeWindow.cs b/source/ShiftUI/Internal/NativeWindow.cs new file mode 100644 index 0000000..4657276 --- /dev/null +++ b/source/ShiftUI/Internal/NativeWindow.cs @@ -0,0 +1,324 @@ +// 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) 2004-2008 Novell, Inc. +// +// Authors: +// Peter Dennis Bartok [email protected] +// Ivan N. Zlatev <[email protected]> +// + + +// COMPLETE + +#define ExternalExceptionHandler + +using System.Runtime.Remoting; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Threading; +using System.Collections; +using System.Diagnostics; +using System.Drawing; +using System; + +namespace ShiftUI +{ + public class NativeWindow : MarshalByRefObject, IWin32Window + { + IntPtr window_handle = IntPtr.Zero; + static Hashtable window_collection = new Hashtable(); + + [ThreadStatic] + static NativeWindow WindowCreating; + + #region Public Constructors + public NativeWindow() + { + window_handle=IntPtr.Zero; + } + #endregion // Public Constructors + + #region Public Instance Properties + public IntPtr Handle { + get { + return window_handle; + } + } + #endregion // Public Instance Properties + + #region Public Static Methods + public static NativeWindow FromHandle(IntPtr handle) + { + return FindFirstInTable (handle); + } + #endregion // Public Static Methods + + #region Private and Internal Methods + internal void InvalidateHandle() + { + RemoveFromTable (this); + window_handle = IntPtr.Zero; + } + #endregion + + #region Public Instance Methods + public void AssignHandle(IntPtr handle) + { + RemoveFromTable (this); + window_handle = handle; + AddToTable (this); + OnHandleChange(); + } + + private static void AddToTable (NativeWindow window) + { + IntPtr handle = window.Handle; + if (handle == IntPtr.Zero) + return; + + lock (window_collection) { + object current = window_collection[handle]; + if (current == null) { + window_collection.Add (handle, window); + } else { + NativeWindow currentWindow = current as NativeWindow; + if (currentWindow != null) { + if (currentWindow != window) { + ArrayList windows = new ArrayList (); + windows.Add (currentWindow); + windows.Add (window); + window_collection[handle] = windows; + } + } else { // list of windows + ArrayList windows = (ArrayList) window_collection[handle]; + if (!windows.Contains (window)) + windows.Add (window); + } + } + } + } + + private static void RemoveFromTable (NativeWindow window) + { + IntPtr handle = window.Handle; + if (handle == IntPtr.Zero) + return; + + lock (window_collection) { + object current = window_collection[handle]; + if (current != null) { + NativeWindow currentWindow = current as NativeWindow; + if (currentWindow != null) { + window_collection.Remove (handle); + } else { // list of windows + ArrayList windows = (ArrayList) window_collection[handle]; + windows.Remove (window); + if (windows.Count == 0) + window_collection.Remove (handle); + else if (windows.Count == 1) + window_collection[handle] = windows[0]; + } + } + } + } + + private static NativeWindow FindFirstInTable (IntPtr handle) + { + if (handle == IntPtr.Zero) + return null; + + NativeWindow window = null; + lock (window_collection) { + object current = window_collection[handle]; + if (current != null) { + window = current as NativeWindow; + if (window == null) { + ArrayList windows = (ArrayList) current; + if (windows.Count > 0) + window = (NativeWindow) windows[0]; + } + } + } + return window; + } + + public virtual void CreateHandle(CreateParams cp) + { + if (cp != null) { + WindowCreating = this; + window_handle=XplatUI.CreateWindow(cp); + WindowCreating = null; + + if (window_handle != IntPtr.Zero) + AddToTable (this); + } + + } + + public void DefWndProc(ref Message m) + { + m.Result=XplatUI.DefWndProc(ref m); + } + + public virtual void DestroyHandle() + { + if (window_handle != IntPtr.Zero) { + XplatUI.DestroyWindow(window_handle); + } + } + + public virtual void ReleaseHandle() + { + RemoveFromTable (this); + window_handle=IntPtr.Zero; + OnHandleChange(); + } + + #endregion // Public Instance Methods + + #region Protected Instance Methods + ~NativeWindow() + { + } + + protected virtual void OnHandleChange() + { + } + + protected virtual void OnThreadException(Exception e) + { + Application.OnThreadException(e); + } + + protected virtual void WndProc(ref Message m) + { + DefWndProc(ref m); + } + + internal static IntPtr WndProc(IntPtr hWnd, Msg msg, IntPtr wParam, IntPtr lParam) + { + IntPtr result = IntPtr.Zero; + Message m = new Message(); + m.HWnd = hWnd; + m.Msg = (int)msg; + m.WParam = wParam; + m.LParam = lParam; + m.Result = IntPtr.Zero; + +#if debug + Console.WriteLine("NativeWindow.cs ({0}, {1}, {2}, {3}): result {4}", hWnd, msg, wParam, lParam, m.Result); +#endif + NativeWindow window = null; + + try { + object current = null; + lock (window_collection) { + current = window_collection[hWnd]; + } + + window = current as NativeWindow; + if (current == null) + window = EnsureCreated (window, hWnd); + + if (window != null) { + window.WndProc (ref m); + result = m.Result; + } else if (current is ArrayList) { + ArrayList windows = (ArrayList) current; + lock (windows) { + if (windows.Count > 0) { + window = EnsureCreated ((NativeWindow)windows[0], hWnd); + window.WndProc (ref m); + // the first one is the Widget's one. all others are synthetic, + // so we want only the result from the Widget + result = m.Result; + for (int i=1; i < windows.Count; i++) + ((NativeWindow)windows[i]).WndProc (ref m); + } + } + } else { + result = XplatUI.DefWndProc (ref m); + } + } + catch (Exception ex) { +#if !ExternalExceptionHandler + if (window != null) { + if (msg == Msg.WM_PAINT && window is Widget.WidgetNativeWindow) { + // Replace Widget with a red cross + var Widget = ((Widget.WidgetNativeWindow)window).Owner; + Widget.Hide (); + var redCross = new Widget (Widget.Parent, string.Empty); + redCross.BackColor = Color.White; + redCross.ForeColor = Color.Red; + redCross.Bounds = Widget.Bounds; + redCross.Paint += HandleRedCrossPaint; + } + window.OnThreadException (ex); + } +#else + throw ex; +#endif + } + #if debug + Console.WriteLine("NativeWindow.cs: Message {0}, result {1}", msg, m.Result); + #endif + + return result; + } + + private static void HandleRedCrossPaint (object sender, PaintEventArgs e) + { + var Widget = sender as Widget; + using (var pen = new Pen (Widget.ForeColor, 2)) { + var paintRect = Widget.DisplayRectangle; + e.Graphics.DrawRectangle (pen, paintRect.Left + 1, + paintRect.Top + 1, paintRect.Width - 1, paintRect.Height - 1); + // NOTE: .NET's drawing of the red cross seems to have a bug + // that draws the bottom and right of the rectangle only 1 pixel + // wide. We would get a nicer rectangle using the following code, + // but that runs into a problem with libgdiplus. + //var paintRect = Widget.DisplayRectangle; + //paintRect.Inflate (-1, -1); + //e.Graphics.DrawRectangle (pen, paintRect); + e.Graphics.DrawLine (pen, paintRect.Location, + paintRect.Location + paintRect.Size); + e.Graphics.DrawLine (pen, new Point (paintRect.Left, paintRect.Bottom), + new Point (paintRect.Right, paintRect.Top)); + } + } + + private static NativeWindow EnsureCreated (NativeWindow window, IntPtr hWnd) + { + // we need to do this AssignHandle here instead of relying on + // Widget.WndProc to do it, because subclasses can override + // WndProc, install their own WM_CREATE block, and look at + // this.Handle, and it needs to be set. Otherwise, we end up + // recursively creating windows and emitting WM_CREATE. + if (window == null && WindowCreating != null) { + window = WindowCreating; + WindowCreating = null; + if (window.Handle == IntPtr.Zero) + window.AssignHandle (hWnd); + } + return window; + } + #endregion // Protected Instance Methods + } +} diff --git a/source/ShiftUI/Internal/OpacityConverter.cs b/source/ShiftUI/Internal/OpacityConverter.cs new file mode 100644 index 0000000..89fcc63 --- /dev/null +++ b/source/ShiftUI/Internal/OpacityConverter.cs @@ -0,0 +1,74 @@ +// 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.Collections; +using System.ComponentModel; +using System.Globalization; +using System.Text; + +namespace ShiftUI { + public class OpacityConverter : TypeConverter { + #region Public Constructors + public OpacityConverter() { + } + #endregion // Public Constructors + + #region Public Instance Methods + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { + if (sourceType == typeof(string)) { + return true; + } + return false; + } + + public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { + if (value is string) { + string s; + + s = (string)value; + if (s.EndsWith("%")) { + s = ((string)value).Substring(0, ((string)value).Length - 1); + } + return Double.Parse(s, NumberStyles.Any, culture) / 100; + } + return base.ConvertFrom (context, culture, value); + } + + public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { + if (destinationType == typeof(string)) { + double v; + + v = ((double)value) * 100; + return v.ToString() + "%"; + } + return base.ConvertTo (context, culture, value, destinationType); + } + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/OpenTreeNodeEnumerator.cs b/source/ShiftUI/Internal/OpenTreeNodeEnumerator.cs new file mode 100644 index 0000000..f2d9453 --- /dev/null +++ b/source/ShiftUI/Internal/OpenTreeNodeEnumerator.cs @@ -0,0 +1,112 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) + + +using System; +using System.Collections; + +namespace ShiftUI { + + internal class OpenTreeNodeEnumerator : IEnumerator { + + private TreeNode start; + private TreeNode current; + private bool started; + + public OpenTreeNodeEnumerator (TreeNode start) + { + this.start = start; + } + + public object Current { + get { return current; } + } + + public TreeNode CurrentNode { + get { return current; } + } + + public bool MoveNext () + { + if (!started) { + started = true; + current = start; + return (current != null); + } + + if (current.is_expanded && current.Nodes.Count > 0) { + current = current.Nodes [0]; + return true; + } + + TreeNode prev = current; + TreeNode next = current.NextNode; + while (next == null) { + // The next node is null so we need to move back up the tree until we hit the top + if (prev.parent == null) + return false; + prev = prev.parent; + if (prev.parent != null) + next = prev.NextNode; + } + current = next; + return true; + } + + public bool MovePrevious () + { + if (!started) { + started = true; + current = start; + return (current != null); + } + + if (current.PrevNode != null) { + // Drill down as far as possible + TreeNode prev = current.PrevNode; + TreeNode walk = prev; + while (walk != null) { + prev = walk; + if (!walk.is_expanded) + break; + walk = walk.LastNode; + } + current = prev; + return true; + } + + if (current.Parent == null) + return false; + + current = current.Parent; + return true; + } + + public void Reset () + { + started = false; + } + } +} + diff --git a/source/ShiftUI/Internal/OwnerDrawPropertyBag.cs b/source/ShiftUI/Internal/OwnerDrawPropertyBag.cs new file mode 100644 index 0000000..c9f8e6f --- /dev/null +++ b/source/ShiftUI/Internal/OwnerDrawPropertyBag.cs @@ -0,0 +1,101 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) + +using System; +using System.Drawing; +using System.Runtime.Serialization; + +namespace ShiftUI { + + [Serializable] + public class OwnerDrawPropertyBag : MarshalByRefObject, ISerializable { + + private Color fore_color; + private Color back_color; + private Font font; + + internal OwnerDrawPropertyBag () + { + fore_color = back_color = Color.Empty; + } + + private OwnerDrawPropertyBag (Color fore_color, Color back_color, Font font) + { + this.fore_color = fore_color; + this.back_color = back_color; + this.font = font; + } + + protected OwnerDrawPropertyBag(SerializationInfo info, StreamingContext context) { + SerializationInfoEnumerator en; + SerializationEntry e; + + en = info.GetEnumerator(); + + while (en.MoveNext()) { + e = en.Current; + switch(e.Name) { + case "Font": font = (Font)e.Value; break; + case "ForeColor": fore_color = (Color)e.Value; break; + case "BackColor": back_color = (Color)e.Value; break; + } + } + } + + + public Color ForeColor { + get { return fore_color; } + set { fore_color = value; } + } + + public Color BackColor { + get { return back_color; } + set { back_color = value; } + } + + public Font Font { + get { return font; } + set { font = value; } + } + + public virtual bool IsEmpty () + { + return (font == null && fore_color.IsEmpty && back_color.IsEmpty); + } + + void ISerializable.GetObjectData (SerializationInfo si, StreamingContext context) + { + si.AddValue ("BackColor", BackColor); + si.AddValue ("ForeColor", ForeColor); + si.AddValue ("Font", Font); + } + + public static OwnerDrawPropertyBag Copy (OwnerDrawPropertyBag value) + { + return new OwnerDrawPropertyBag (value.ForeColor, value.BackColor, value.Font); + } + } +} + + diff --git a/source/ShiftUI/Internal/Padding.cs b/source/ShiftUI/Internal/Padding.cs new file mode 100644 index 0000000..63bdc64 --- /dev/null +++ b/source/ShiftUI/Internal/Padding.cs @@ -0,0 +1,170 @@ +// 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,2006 Novell, Inc. (http://www.novell.com) +// +// Author: +// Pedro MartÃnez Juliá <[email protected]> +// Daniel Nauck (dna(at)mono-project(dot)de) +// + +using System; +using System.ComponentModel; +using System.Drawing; + +namespace ShiftUI { + + [Serializable] + [TypeConverter(typeof(PaddingConverter))] + public struct Padding { + + //NOTE: "_var" field name is required by serialization. + private int _bottom; + private int _left; + private int _right; + private int _top; + private bool _all; + + public Padding (int all) { + _left = all; + _right = all; + _top = all; + _bottom = all; + _all = true; + } + + public Padding (int left, int top, int right, int bottom) { + _left = left; + _right = right; + _top = top; + _bottom = bottom; + _all = (_left == _top) && (_left == _right) && (_left == _bottom); + } + + public static readonly Padding Empty = new Padding(0); + + [RefreshProperties(RefreshProperties.All)] + public int All { + get { + if(!_all) + return -1; + else + return _top; + } + set { + _all = true; + _left = _top = _right = _bottom = value; + } + } + + [RefreshProperties(RefreshProperties.All)] + public int Bottom { + get { return _bottom; } + set { + _bottom = value; + _all = false; + } + } + + [Browsable(false)] + public int Horizontal { + get { return _left + _right; } + } + + [RefreshProperties(RefreshProperties.All)] + public int Left { + get { return _left; } + set { + _left = value; + _all = false; + } + } + + [RefreshProperties(RefreshProperties.All)] + public int Right { + get { return _right; } + set { + _right = value; + _all = false; + } + } + + [Browsable(false)] + public Size Size { + get { return new Size(Horizontal, Vertical); } + } + + [RefreshProperties(RefreshProperties.All)] + public int Top { + get { return _top; } + set { + _top = value; + _all = false; + } + } + + [Browsable(false)] + public int Vertical { + get { return _top + _bottom; } + } + + public static Padding Add (Padding p1, Padding p2) { + return p1 + p2; + } + + public override bool Equals (object other) { + if (other is Padding) { + Padding other_aux = (Padding) other; + return _left == other_aux.Left && + _top == other_aux.Top && + _right == other_aux.Right && + _bottom == other_aux.Bottom; + } + return false; + } + + public override int GetHashCode () { + return _top ^ _bottom ^ _left ^ _right; + } + + public static Padding operator+ (Padding p1, Padding p2) { + return new Padding(p1.Left + p2.Left, p1.Top + p2.Top, p1.Right + p2.Right, p1.Bottom + p2.Bottom); + } + + public static bool operator== (Padding p1, Padding p2) { + return p1.Equals(p2); + } + + public static bool operator!= (Padding p1, Padding p2) { + return !(p1.Equals(p2)); + } + + public static Padding operator- (Padding p1, Padding p2) { + return new Padding(p1.Left - p2.Left, p1.Top - p2.Top, p1.Right - p2.Right, p1.Bottom - p2.Bottom); + } + + public static Padding Subtract (Padding p1, Padding p2) { + return p1 - p2; + } + + public override string ToString () { + return "{Left=" + Left + ",Top="+ Top + ",Right=" + Right + ",Bottom=" + Bottom + "}"; + } + } +}
\ No newline at end of file diff --git a/source/ShiftUI/Internal/PaddingConverter.cs b/source/ShiftUI/Internal/PaddingConverter.cs new file mode 100644 index 0000000..447f65d --- /dev/null +++ b/source/ShiftUI/Internal/PaddingConverter.cs @@ -0,0 +1,125 @@ +// 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) 2007 Novell, Inc. +// + +using System.ComponentModel; +using System.Collections; +using System.Reflection; +using System.Globalization; +using System.ComponentModel.Design.Serialization; // e.g. InstanceDescriptor +using System; + +namespace ShiftUI +{ + public class PaddingConverter : TypeConverter + { + public PaddingConverter () + { + } + + #region Public Instance Methods + public override bool CanConvertFrom (ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof (string)) + return true; + + return false; + } + + public override bool CanConvertTo (ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof (string)) + return true; + else if (destinationType == typeof(InstanceDescriptor)) + return true; + + return false; + } + + public override object ConvertFrom (ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) + { + if ((value == null) || !(value is String)) + return base.ConvertFrom (context, culture, value); + + if (culture == null) + culture = CultureInfo.CurrentCulture; + + string[] parts = ((string)value).Split (culture.TextInfo.ListSeparator.ToCharArray ()); + + return new Padding (int.Parse (parts[0].Trim ()), int.Parse (parts[1].Trim ()), int.Parse (parts[2].Trim ()), int.Parse (parts[3].Trim ())); + } + + public override object ConvertTo (ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) + { + if (value is Padding) { + Padding p = (Padding)value; + if (destinationType == typeof (string)) { + if (culture == null) + culture = CultureInfo.CurrentCulture; + return string.Format ("{0}{4} {1}{4} {2}{4} {3}", p.Left, p.Top, p.Right, p.Bottom, culture.TextInfo.ListSeparator); + } else if (destinationType == typeof (InstanceDescriptor)) { + Type[] types; + Object[] values; + if (p.All != -1) { + types = new Type[] { typeof(int) }; + values = new Object[] { p.All }; + } else { + types = new Type[] { typeof(int), typeof(int), typeof(int), typeof(int) }; + values = new Object[] { p.Left, p.Top, p.Right, p.Bottom }; + } + ConstructorInfo ci = typeof(Padding).GetConstructor (types); + return new InstanceDescriptor (ci, values); + } + } + return base.ConvertTo (context, culture, value, destinationType); + } + + public override object CreateInstance (ITypeDescriptorContext context, IDictionary propertyValues) + { + if (propertyValues == null) + throw new ArgumentNullException ("propertyValues"); + if (context == null) + throw new ArgumentNullException ("context"); + + Padding old = (Padding)context.PropertyDescriptor.GetValue (context.Instance); + if (old.All == (int)propertyValues["All"]) + return new Padding ((int)propertyValues["Left"], (int)propertyValues["Top"], (int)propertyValues["Right"], (int)propertyValues["Bottom"]); + else + return new Padding ((int)propertyValues["All"]); + } + + public override bool GetCreateInstanceSupported (ITypeDescriptorContext context) + { + return true; + } + + public override PropertyDescriptorCollection GetProperties (ITypeDescriptorContext context, object value, Attribute[] attributes) + { + return TypeDescriptor.GetProperties (typeof (Padding), attributes); + } + + public override bool GetPropertiesSupported (ITypeDescriptorContext context) + { + return true; + } + #endregion + } +} diff --git a/source/ShiftUI/Internal/PaintEventArgs.cs b/source/ShiftUI/Internal/PaintEventArgs.cs new file mode 100644 index 0000000..0f05b84 --- /dev/null +++ b/source/ShiftUI/Internal/PaintEventArgs.cs @@ -0,0 +1,98 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// + + +// COMPLETE + +using System.Drawing; +using System; + +namespace ShiftUI { + public class PaintEventArgs : EventArgs, IDisposable { + private Graphics graphics; + private Rectangle clip_rectangle; + internal bool Handled; + private bool disposed; + + #region Public Constructors + public PaintEventArgs (Graphics graphics, Rectangle clipRect) + { + if (graphics == null) + throw new ArgumentNullException ("graphics"); + + this.graphics=graphics; + this.clip_rectangle=clipRect; + } + #endregion // Public Constructors + + #region Public Instance Properties + public Rectangle ClipRectangle { + get { + return this.clip_rectangle; + } + } + + public Graphics Graphics { + get { + return this.graphics; + } + } + #endregion // Public Instance Properties + + #region Public Instance Methods + public void Dispose() { + Dispose(true); + GC.SuppressFinalize(this); + } + #endregion // Public Instance Methods + + // Returns the previous graphics + internal Graphics SetGraphics (Graphics g) + { + Graphics res = graphics; + graphics = g; + + return res; + } + + internal void SetClip (Rectangle clip) + { + clip_rectangle = clip; + } + + #region Protected Instance Methods + ~PaintEventArgs() { + Dispose(false); + } + + protected virtual void Dispose (bool disposing) + { + if (!disposed) { + disposed = true; + } + } + #endregion // Protected Instance Methods + } +} diff --git a/source/ShiftUI/Internal/PaintEventHandler.cs b/source/ShiftUI/Internal/PaintEventHandler.cs new file mode 100644 index 0000000..9e074ee --- /dev/null +++ b/source/ShiftUI/Internal/PaintEventHandler.cs @@ -0,0 +1,33 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// +// + + +// COMPLETE + +namespace ShiftUI +{ + public delegate void PaintEventHandler (object sender, PaintEventArgs e); +} diff --git a/source/ShiftUI/Internal/Pasteboard.cs b/source/ShiftUI/Internal/Pasteboard.cs new file mode 100644 index 0000000..57a75b4 --- /dev/null +++ b/source/ShiftUI/Internal/Pasteboard.cs @@ -0,0 +1,106 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton ([email protected]) +// +// + + +using System; +using System.Runtime.InteropServices; +using ShiftUI; + +namespace ShiftUI.CarbonInternal { + internal class Pasteboard { + private static IntPtr primary_pbref; + private static IntPtr app_pbref; + + private static IntPtr internal_format; + + static Pasteboard () { + PasteboardCreate (XplatUICarbon.__CFStringMakeConstantString("com.apple.pasteboard.clipboard"), ref primary_pbref); + PasteboardCreate (IntPtr.Zero, ref app_pbref); + internal_format = XplatUICarbon.__CFStringMakeConstantString ("com.novell.mono.mwf.pasteboard"); + } + + internal static object Retrieve (IntPtr pbref, int key) { + UInt32 count = 0; + + key = (int)internal_format; + + PasteboardGetItemCount (pbref, ref count); + for (int i = 1; i <= count; i++) { + UInt32 itemid = 0; + + PasteboardGetItemIdentifier (pbref, (UInt32)i, ref itemid); + //FIXME: We should get all the flavors and enumerate but we're cheating for now + if (itemid == 0xFACE) { + IntPtr pbdata = IntPtr.Zero; + + PasteboardCopyItemFlavorData (pbref, (UInt32)0xFACE, (UInt32)key, ref pbdata); + if (pbdata != IntPtr.Zero) { + GCHandle handle = (GCHandle) Marshal.ReadIntPtr (CFDataGetBytePtr (pbdata)); + + return handle.Target; + } + } + } + return null; + } + + internal static void Store (IntPtr pbref, object data, int key) { + IntPtr gcdata = (IntPtr) GCHandle.Alloc (data); + IntPtr pbdata = CFDataCreate (IntPtr.Zero, ref gcdata, Marshal.SizeOf (typeof (IntPtr))); + + key = (int)internal_format; + + PasteboardClear (pbref); + PasteboardPutItemFlavor (pbref, (UInt32)0xFACE, (UInt32)key, pbdata, 0); + } + + internal static IntPtr Primary { + get { return primary_pbref; } + } + + internal static IntPtr Application { + get { return app_pbref; } + } + + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern IntPtr CFDataCreate (IntPtr allocator, ref IntPtr buf, Int32 length); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern IntPtr CFDataGetBytePtr (IntPtr data); + + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int PasteboardClear (IntPtr pbref); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int PasteboardCreate (IntPtr str, ref IntPtr pbref); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int PasteboardCopyItemFlavorData (IntPtr pbref, UInt32 itemid, UInt32 key, ref IntPtr data); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int PasteboardGetItemCount (IntPtr pbref, ref UInt32 count); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int PasteboardGetItemIdentifier (IntPtr pbref, UInt32 itemindex, ref UInt32 itemid); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int PasteboardPutItemFlavor (IntPtr pbref, UInt32 itemid, UInt32 key, IntPtr data, UInt32 flags); + } +} diff --git a/source/ShiftUI/Internal/PopupEventArgs.cs b/source/ShiftUI/Internal/PopupEventArgs.cs new file mode 100644 index 0000000..b11b837 --- /dev/null +++ b/source/ShiftUI/Internal/PopupEventArgs.cs @@ -0,0 +1,71 @@ +// +// PopupEventArgs.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + + +using System.ComponentModel; +using System.Drawing; + +namespace ShiftUI +{ + public class PopupEventArgs : CancelEventArgs + { + private Widget associated_control; + private IWin32Window associated_window; + private bool is_balloon; + private Size tool_tip_size; + + #region Public Constructors + public PopupEventArgs (IWin32Window associatedWindow, Widget associatedControl, bool isBalloon, Size size) : base () + { + this.associated_window = associatedWindow; + this.associated_control = associatedControl; + this.is_balloon = isBalloon; + this.tool_tip_size = size; + } + #endregion // Public Constructors + + #region Public Instance Properties + public Widget AssociatedControl { + get { return this.associated_control; } + } + + public IWin32Window AssociatedWindow { + get { return this.associated_window; } + } + + public bool IsBalloon { + get { return this.is_balloon; } + } + + public Size ToolTipSize { + get { return this.tool_tip_size; } + set { this.tool_tip_size = value; } + } + #endregion // Public Instance Properties + } +} diff --git a/source/ShiftUI/Internal/PopupEventHandler.cs b/source/ShiftUI/Internal/PopupEventHandler.cs new file mode 100644 index 0000000..ba87315 --- /dev/null +++ b/source/ShiftUI/Internal/PopupEventHandler.cs @@ -0,0 +1,32 @@ +// +// PopupEventHandler.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +namespace ShiftUI +{ + public delegate void PopupEventHandler (object sender, PopupEventArgs e); +} diff --git a/source/ShiftUI/Internal/PreProcessControlState.cs b/source/ShiftUI/Internal/PreProcessControlState.cs new file mode 100644 index 0000000..bd573a5 --- /dev/null +++ b/source/ShiftUI/Internal/PreProcessControlState.cs @@ -0,0 +1,38 @@ +// +// PreProcessWidgetstate.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + + +namespace ShiftUI +{ + public enum PreProcessWidgetstate + { + MessageProcessed = 0, + MessageNeeded = 1, + MessageNotNeeded = 2 + } +}
\ No newline at end of file diff --git a/source/ShiftUI/Internal/ProfessionalColorTable.cs b/source/ShiftUI/Internal/ProfessionalColorTable.cs new file mode 100644 index 0000000..ff42d37 --- /dev/null +++ b/source/ShiftUI/Internal/ProfessionalColorTable.cs @@ -0,0 +1,654 @@ +// +// ProfessionalColorTable.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +using System.Drawing; +using ShiftUI.VisualStyles; + +namespace ShiftUI +{ + public class ProfessionalColorTable + { + #region Private Variables + private bool use_system_colors = false; + + private Color button_checked_gradient_begin; + private Color button_checked_gradient_end; + private Color button_checked_gradient_middle; + private Color button_checked_highlight; + private Color button_checked_highlight_border; + private Color button_pressed_border; + private Color button_pressed_gradient_begin; + private Color button_pressed_gradient_end; + private Color button_pressed_gradient_middle; + private Color button_pressed_highlight; + private Color button_pressed_highlight_border; + private Color button_selected_border; + private Color button_selected_gradient_begin; + private Color button_selected_gradient_end; + private Color button_selected_gradient_middle; + private Color button_selected_highlight; + private Color button_selected_highlight_border; + private Color check_background; + private Color check_pressed_background; + private Color check_selected_background; + private Color grip_dark; + private Color grip_light; + private Color image_margin_gradient_begin; + private Color image_margin_gradient_end; + private Color image_margin_gradient_middle; + private Color image_margin_revealed_gradient_begin; + private Color image_margin_revealed_gradient_end; + private Color image_margin_revealed_gradient_middle; + private Color menu_border; + private Color menu_item_border; + private Color menu_item_pressed_gradient_begin; + private Color menu_item_pressed_gradient_end; + private Color menu_item_pressed_gradient_middle; + private Color menu_item_selected; + private Color menu_item_selected_gradient_begin; + private Color menu_item_selected_gradient_end; + private Color menu_strip_gradient_begin; + private Color menu_strip_gradient_end; + private Color overflow_button_gradient_begin; + private Color overflow_button_gradient_end; + private Color overflow_button_gradient_middle; + private Color rafting_container_gradient_begin; + private Color rafting_container_gradient_end; + private Color separator_dark; + private Color separator_light; + private Color status_strip_gradient_begin; + private Color status_strip_gradient_end; + private Color tool_strip_border; + private Color tool_strip_content_panel_gradient_begin; + private Color tool_strip_content_panel_gradient_end; + private Color tool_strip_drop_down_background; + private Color tool_strip_gradient_begin; + private Color tool_strip_gradient_end; + private Color tool_strip_gradient_middle; + private Color tool_strip_panel_gradient_begin; + private Color tool_strip_panel_gradient_end; + #endregion + + #region Public Constructor + public ProfessionalColorTable () + { + CalculateColors (); + } + #endregion + + #region Public Properties + public virtual Color ButtonCheckedGradientBegin { get { return this.button_checked_gradient_begin; } } + public virtual Color ButtonCheckedGradientEnd { get { return this.button_checked_gradient_end; } } + public virtual Color ButtonCheckedGradientMiddle { get { return this.button_checked_gradient_middle; } } + public virtual Color ButtonCheckedHighlight { get { return this.button_checked_highlight; } } + public virtual Color ButtonCheckedHighlightBorder { get { return this.button_checked_highlight_border; } } + public virtual Color ButtonPressedBorder { get { return this.button_pressed_border; } } + public virtual Color ButtonPressedGradientBegin { get { return this.button_pressed_gradient_begin; } } + public virtual Color ButtonPressedGradientEnd { get { return this.button_pressed_gradient_end; } } + public virtual Color ButtonPressedGradientMiddle { get { return this.button_pressed_gradient_middle; } } + public virtual Color ButtonPressedHighlight { get { return this.button_pressed_highlight; } } + public virtual Color ButtonPressedHighlightBorder { get { return this.button_pressed_highlight_border; } } + public virtual Color ButtonSelectedBorder { get { return this.button_selected_border; } } + public virtual Color ButtonSelectedGradientBegin { get { return this.button_selected_gradient_begin; } } + public virtual Color ButtonSelectedGradientEnd { get { return this.button_selected_gradient_end; } } + public virtual Color ButtonSelectedGradientMiddle { get { return this.button_selected_gradient_middle; } } + public virtual Color ButtonSelectedHighlight { get { return this.button_selected_highlight; } } + public virtual Color ButtonSelectedHighlightBorder { get { return this.button_selected_highlight_border; } } + public virtual Color CheckBackground { get { return this.check_background; } } + public virtual Color CheckPressedBackground { get { return this.check_pressed_background; } } + public virtual Color CheckSelectedBackground { get { return this.check_selected_background; } } + public virtual Color GripDark { get { return this.grip_dark; } } + public virtual Color GripLight { get { return this.grip_light; } } + public virtual Color ImageMarginGradientBegin { get { return this.image_margin_gradient_begin; } } + public virtual Color ImageMarginGradientEnd { get { return this.image_margin_gradient_end; } } + public virtual Color ImageMarginGradientMiddle { get { return this.image_margin_gradient_middle; } } + public virtual Color ImageMarginRevealedGradientBegin { get { return this.image_margin_revealed_gradient_begin; } } + public virtual Color ImageMarginRevealedGradientEnd { get { return this.image_margin_revealed_gradient_end; } } + public virtual Color ImageMarginRevealedGradientMiddle { get { return this.image_margin_revealed_gradient_middle; } } + public virtual Color MenuBorder { get { return this.menu_border; } } + public virtual Color MenuItemBorder { get { return this.menu_item_border; } } + public virtual Color MenuItemPressedGradientBegin { get { return this.menu_item_pressed_gradient_begin; } } + public virtual Color MenuItemPressedGradientEnd { get { return this.menu_item_pressed_gradient_end; } } + public virtual Color MenuItemPressedGradientMiddle { get { return this.menu_item_pressed_gradient_middle; } } + public virtual Color MenuItemSelected { get { return this.menu_item_selected; } } + public virtual Color MenuItemSelectedGradientBegin { get { return this.menu_item_selected_gradient_begin; } } + public virtual Color MenuItemSelectedGradientEnd { get { return this.menu_item_selected_gradient_end; } } + public virtual Color MenuStripGradientBegin { get { return this.menu_strip_gradient_begin; } } + public virtual Color MenuStripGradientEnd { get { return this.menu_strip_gradient_end; } } + public virtual Color OverflowButtonGradientBegin { get { return this.overflow_button_gradient_begin; } } + public virtual Color OverflowButtonGradientEnd { get { return this.overflow_button_gradient_end; } } + public virtual Color OverflowButtonGradientMiddle { get { return this.overflow_button_gradient_middle; } } + public virtual Color RaftingContainerGradientBegin { get { return this.rafting_container_gradient_begin; } } + public virtual Color RaftingContainerGradientEnd { get { return this.rafting_container_gradient_end; } } + public virtual Color SeparatorDark { get { return this.separator_dark; } } + public virtual Color SeparatorLight { get { return this.separator_light; } } + public virtual Color StatusStripGradientBegin { get { return this.status_strip_gradient_begin; } } + public virtual Color StatusStripGradientEnd { get { return this.status_strip_gradient_end; } } + public virtual Color ToolStripBorder { get { return this.tool_strip_border; } } + public virtual Color ToolStripContentPanelGradientBegin { get { return this.tool_strip_content_panel_gradient_begin; } } + public virtual Color ToolStripContentPanelGradientEnd { get { return this.tool_strip_content_panel_gradient_end; } } + public virtual Color ToolStripDropDownBackground { get { return this.tool_strip_drop_down_background; } } + public virtual Color ToolStripGradientBegin { get { return this.tool_strip_gradient_begin; } } + public virtual Color ToolStripGradientEnd { get { return this.tool_strip_gradient_end; } } + public virtual Color ToolStripGradientMiddle { get { return this.tool_strip_gradient_middle; } } + public virtual Color ToolStripPanelGradientBegin { get { return this.tool_strip_panel_gradient_begin; } } + public virtual Color ToolStripPanelGradientEnd { get { return this.tool_strip_panel_gradient_end; } } + public bool UseSystemColors { + get { return use_system_colors; } + set { + if (value != use_system_colors) { + use_system_colors = value; CalculateColors (); + } + } + } + #endregion + + #region Private Methods + private void CalculateColors () + { + switch (GetCurrentStyle ()) { + case ColorSchemes.Classic: + button_checked_gradient_begin = Color.Empty; + button_checked_gradient_end = Color.Empty; + button_checked_gradient_middle = Color.Empty; + button_checked_highlight = Color.FromArgb (184, 191, 211); + button_checked_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + + button_pressed_border = Color.FromKnownColor (KnownColor.Highlight); + button_pressed_gradient_begin = Color.FromArgb (133, 146, 181); + button_pressed_gradient_end = Color.FromArgb (133, 146, 181); + button_pressed_gradient_middle = Color.FromArgb (133, 146, 181); + button_pressed_highlight = Color.FromArgb (131, 144, 179); + button_pressed_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + + button_selected_border = Color.FromKnownColor (KnownColor.Highlight); + button_selected_gradient_begin = Color.FromArgb (182, 189, 210); + button_selected_gradient_end = Color.FromArgb (182, 189, 210); + button_selected_gradient_middle = Color.FromArgb (182, 189, 210); + button_selected_highlight = Color.FromArgb (184, 191, 211); + button_selected_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + + check_background = Color.FromKnownColor (KnownColor.Highlight); + check_pressed_background = Color.FromArgb (133, 146, 181); + check_selected_background = Color.FromArgb (133, 146, 181); + + grip_dark = Color.FromArgb (160, 160, 160); + grip_light = SystemColors.Window; + + image_margin_gradient_begin = Color.FromArgb (245, 244, 242); + image_margin_gradient_end = SystemColors.Control; + image_margin_gradient_middle = Color.FromArgb (234, 232, 228); + image_margin_revealed_gradient_begin = Color.FromArgb (238, 236, 233); + image_margin_revealed_gradient_end = Color.FromArgb (216, 213, 206); + image_margin_revealed_gradient_middle = Color.FromArgb (225, 222, 217); + + menu_border = Color.FromArgb (102, 102, 102); + menu_item_border = SystemColors.Highlight; + + menu_item_pressed_gradient_begin = Color.FromArgb (245, 244, 242); + menu_item_pressed_gradient_end = Color.FromArgb (234, 232, 228); + menu_item_pressed_gradient_middle = Color.FromArgb (225, 222, 217); + menu_item_selected = SystemColors.Window; + menu_item_selected_gradient_begin = Color.FromArgb (182, 189, 210); + menu_item_selected_gradient_end = Color.FromArgb (182, 189, 210); + + menu_strip_gradient_begin = SystemColors.ButtonFace; + menu_strip_gradient_end = Color.FromArgb (246, 245, 244); + + overflow_button_gradient_begin = Color.FromArgb (225, 222, 217); + overflow_button_gradient_end = SystemColors.ButtonShadow; + overflow_button_gradient_middle = Color.FromArgb (216, 213, 206); + + rafting_container_gradient_begin = SystemColors.ButtonFace; + rafting_container_gradient_end = Color.FromArgb (246, 245, 244); + + separator_dark = Color.FromArgb (166, 166, 166); + separator_light = SystemColors.ButtonHighlight; + + status_strip_gradient_begin = SystemColors.ButtonFace; + status_strip_gradient_end = Color.FromArgb (246, 245, 244); + + tool_strip_border = Color.FromArgb (219, 216, 209); + tool_strip_content_panel_gradient_begin = SystemColors.ButtonFace; + tool_strip_content_panel_gradient_end = Color.FromArgb (246, 245, 244); + tool_strip_drop_down_background = SystemColors.Window; + + tool_strip_gradient_begin = Color.FromArgb (245, 244, 242); + tool_strip_gradient_end = SystemColors.ButtonFace; + tool_strip_gradient_middle = Color.FromArgb (234, 232, 228); + + tool_strip_panel_gradient_begin = SystemColors.ButtonFace; + tool_strip_panel_gradient_end = Color.FromArgb (246, 245, 244); + break; + case ColorSchemes.NormalColor: + button_checked_gradient_begin = use_system_colors ? Color.Empty : Color.FromArgb (255, 223, 154); + button_checked_gradient_end = use_system_colors ? Color.Empty : Color.FromArgb (255, 166, 76); + button_checked_gradient_middle = use_system_colors ? Color.Empty : Color.FromArgb (255, 195, 116); + button_checked_highlight = Color.FromArgb (195, 211, 237); + button_checked_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + button_pressed_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (0, 0, 128); + button_pressed_gradient_begin = use_system_colors ? Color.FromArgb (152, 181, 226) : Color.FromArgb (254, 128, 62); + button_pressed_gradient_end = use_system_colors ? Color.FromArgb (152, 181, 226) : Color.FromArgb (255, 223, 154); + button_pressed_gradient_middle = use_system_colors ? Color.FromArgb (152, 181, 226) : Color.FromArgb (255, 177, 109); + button_pressed_highlight = use_system_colors ? Color.FromArgb (150, 179, 225) : Color.FromArgb (150, 179, 225); + button_pressed_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + button_selected_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (0, 0, 128); + button_selected_gradient_begin = use_system_colors ? Color.FromArgb (193, 210, 238) : Color.FromArgb (255, 255, 222); + button_selected_gradient_end = use_system_colors ? Color.FromArgb (193, 210, 238) : Color.FromArgb (255, 203, 136); + button_selected_gradient_middle = use_system_colors ? Color.FromArgb (193, 210, 238) : Color.FromArgb (255, 225, 172); + button_selected_highlight = use_system_colors ? Color.FromArgb (195, 211, 237) : Color.FromArgb (195, 211, 237); + button_selected_highlight_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (0, 0, 128); + + check_background = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (255, 192, 111); + check_pressed_background = use_system_colors ? Color.FromArgb (152, 181, 226) : Color.FromArgb (254, 128, 62); + check_selected_background = use_system_colors ? Color.FromArgb (152, 181, 226) : Color.FromArgb (254, 128, 62); + + grip_dark = use_system_colors ? Color.FromArgb (193, 190, 179) : Color.FromArgb (39, 65, 118); + grip_light = use_system_colors ? SystemColors.Window : Color.FromArgb (255, 255, 255); + + image_margin_gradient_begin = use_system_colors ? Color.FromArgb (251, 250, 246) : Color.FromArgb (227, 239, 255); + image_margin_gradient_end = use_system_colors ? SystemColors.Control : Color.FromArgb (123, 164, 224); + image_margin_gradient_middle = use_system_colors ? Color.FromArgb (246, 244, 236) : Color.FromArgb (203, 225, 252); + image_margin_revealed_gradient_begin = use_system_colors ? Color.FromArgb (247, 246, 239) : Color.FromArgb (203, 221, 246); + image_margin_revealed_gradient_end = use_system_colors ? Color.FromArgb (238, 235, 220) : Color.FromArgb (114, 155, 215); + image_margin_revealed_gradient_middle = use_system_colors ? Color.FromArgb (242, 240, 228) : Color.FromArgb (161, 197, 249); + + menu_border = use_system_colors ? Color.FromArgb (138, 134, 122) : Color.FromArgb (0, 45, 150); + menu_item_border = use_system_colors ? SystemColors.Highlight : Color.FromArgb (0, 0, 128); + + menu_item_pressed_gradient_begin = use_system_colors ? Color.FromArgb (251, 250, 246) : Color.FromArgb (227, 239, 255); + menu_item_pressed_gradient_end = use_system_colors ? Color.FromArgb (246, 244, 236) : Color.FromArgb (123, 164, 224); + menu_item_pressed_gradient_middle = use_system_colors ? Color.FromArgb (242, 240, 228) : Color.FromArgb (161, 197, 249); + menu_item_selected = use_system_colors ? SystemColors.Window : Color.FromArgb (255, 238, 194); + menu_item_selected_gradient_begin = use_system_colors ? Color.FromArgb (193, 210, 238) : Color.FromArgb (255, 255, 222); + menu_item_selected_gradient_end = use_system_colors ? Color.FromArgb (193, 210, 238) : Color.FromArgb (255, 203, 136); + + menu_strip_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (158, 190, 245); + menu_strip_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 247) : Color.FromArgb (196, 218, 250); + + overflow_button_gradient_begin = use_system_colors ? Color.FromArgb (242, 240, 228) : Color.FromArgb (127, 177, 250); + overflow_button_gradient_end = use_system_colors ? SystemColors.ButtonShadow : Color.FromArgb (0, 53, 145); + overflow_button_gradient_middle = use_system_colors ? Color.FromArgb (238, 235, 220) : Color.FromArgb (82, 127, 208); + + rafting_container_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (158, 190, 245); + rafting_container_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 247) : Color.FromArgb (196, 218, 250); + + separator_dark = use_system_colors ? Color.FromArgb (197, 194, 184) : Color.FromArgb (106, 140, 203); + separator_light = use_system_colors ? SystemColors.ButtonHighlight : Color.FromArgb (241, 249, 255); + + status_strip_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (158, 190, 245); + status_strip_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 247) : Color.FromArgb (196, 218, 250); + + tool_strip_border = use_system_colors ? Color.FromArgb (239, 237, 222) : Color.FromArgb (59, 97, 156); + tool_strip_content_panel_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (158, 190, 245); + tool_strip_content_panel_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 247) : Color.FromArgb (196, 218, 250); + tool_strip_drop_down_background = use_system_colors ? Color.FromArgb (252, 252, 249) : Color.FromArgb (246, 246, 246); + + tool_strip_gradient_begin = use_system_colors ? Color.FromArgb (251, 250, 246) : Color.FromArgb (227, 239, 255); + tool_strip_gradient_end = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (123, 164, 224); + tool_strip_gradient_middle = use_system_colors ? Color.FromArgb (246, 244, 236) : Color.FromArgb (203, 225, 252); + + tool_strip_panel_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (158, 190, 245); + tool_strip_panel_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 247) : Color.FromArgb (196, 218, 250); + break; + case ColorSchemes.HomeStead: + button_checked_gradient_begin = use_system_colors ? Color.Empty : Color.FromArgb (255, 223, 154); + button_checked_gradient_end = use_system_colors ? Color.Empty : Color.FromArgb (255, 166, 76); + button_checked_gradient_middle = use_system_colors ? Color.Empty : Color.FromArgb (255, 195, 116); + button_checked_highlight = Color.FromArgb (223, 227, 213); + button_checked_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + + button_pressed_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (63, 93, 56); + button_pressed_gradient_begin = use_system_colors ? Color.FromArgb (201, 208, 184) : Color.FromArgb (254, 128, 62); + button_pressed_gradient_end = use_system_colors ? Color.FromArgb (201, 208, 184) : Color.FromArgb (255, 223, 154); + button_pressed_gradient_middle = use_system_colors ? Color.FromArgb (201, 208, 184) : Color.FromArgb (255, 177, 109); + button_pressed_highlight = use_system_colors ? Color.FromArgb (200, 206, 182) : Color.FromArgb (200, 206, 182); + button_pressed_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + + button_selected_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (63, 93, 56); + button_selected_gradient_begin = use_system_colors ? Color.FromArgb (223, 227, 212) : Color.FromArgb (255, 255, 222); + button_selected_gradient_end = use_system_colors ? Color.FromArgb (223, 227, 212) : Color.FromArgb (255, 203, 136); + button_selected_gradient_middle = use_system_colors ? Color.FromArgb (223, 227, 212) : Color.FromArgb (255, 225, 172); + button_selected_highlight = use_system_colors ? Color.FromArgb (223, 227, 213) : Color.FromArgb (223, 227, 213); + button_selected_highlight_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (63, 93, 56); + + check_background = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (255, 192, 111); + check_pressed_background = use_system_colors ? Color.FromArgb (201, 208, 184) : Color.FromArgb (254, 128, 62); + check_selected_background = use_system_colors ? Color.FromArgb (201, 208, 184) : Color.FromArgb (254, 128, 62); + + grip_dark = use_system_colors ? Color.FromArgb (193, 190, 179) : Color.FromArgb (81, 94, 51); + grip_light = use_system_colors ? SystemColors.Window : Color.FromArgb (255, 255, 255); + + image_margin_gradient_begin = use_system_colors ? Color.FromArgb (251, 250, 246) : Color.FromArgb (255, 255, 237); + image_margin_gradient_end = use_system_colors ? SystemColors.Control : Color.FromArgb (181, 196, 143); + image_margin_gradient_middle = use_system_colors ? Color.FromArgb (246, 244, 236) : Color.FromArgb (206, 220, 167); + image_margin_revealed_gradient_begin = use_system_colors ? Color.FromArgb (247, 246, 239) : Color.FromArgb (230, 230, 209); + image_margin_revealed_gradient_end = use_system_colors ? Color.FromArgb (238, 235, 220) : Color.FromArgb (160, 177, 116); + image_margin_revealed_gradient_middle = use_system_colors ? Color.FromArgb (242, 240, 228) : Color.FromArgb (186, 201, 143); + + menu_border = use_system_colors ? Color.FromArgb (138, 134, 122) : Color.FromArgb (117, 141, 94); + menu_item_border = use_system_colors ? SystemColors.Highlight : Color.FromArgb (63, 93, 56); + + menu_item_pressed_gradient_begin = use_system_colors ? Color.FromArgb (251, 250, 246) : Color.FromArgb (237, 240, 214); + menu_item_pressed_gradient_end = use_system_colors ? Color.FromArgb (246, 244, 236) : Color.FromArgb (181, 196, 143); + menu_item_pressed_gradient_middle = use_system_colors ? Color.FromArgb (242, 240, 228) : Color.FromArgb (186, 201, 143); + menu_item_selected = use_system_colors ? SystemColors.Window : Color.FromArgb (255, 238, 194); + menu_item_selected_gradient_begin = use_system_colors ? Color.FromArgb (223, 227, 212) : Color.FromArgb (255, 255, 222); + menu_item_selected_gradient_end = use_system_colors ? Color.FromArgb (223, 227, 212) : Color.FromArgb (255, 203, 136); + + menu_strip_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (217, 217, 167); + menu_strip_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 247) : Color.FromArgb (242, 241, 228); + + overflow_button_gradient_begin = use_system_colors ? Color.FromArgb (242, 240, 228) : Color.FromArgb (186, 204, 150); + overflow_button_gradient_end = use_system_colors ? SystemColors.ButtonShadow : Color.FromArgb (96, 119, 107); + overflow_button_gradient_middle = use_system_colors ? Color.FromArgb (238, 235, 220) : Color.FromArgb (141, 160, 107); + + rafting_container_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (217, 217, 167); + rafting_container_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 247) : Color.FromArgb (242, 241, 228); + + separator_dark = use_system_colors ? Color.FromArgb (197, 194, 184) : Color.FromArgb (96, 128, 88); + separator_light = use_system_colors ? SystemColors.ButtonHighlight : Color.FromArgb (244, 247, 222); + + status_strip_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (217, 217, 167); + status_strip_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 247) : Color.FromArgb (242, 241, 228); + + tool_strip_border = use_system_colors ? Color.FromArgb (239, 237, 222) : Color.FromArgb (96, 128, 88); + tool_strip_content_panel_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (217, 217, 167); + tool_strip_content_panel_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 247) : Color.FromArgb (242, 241, 228); + tool_strip_drop_down_background = use_system_colors ? Color.FromArgb (252, 252, 249) : Color.FromArgb (244, 244, 238); + + tool_strip_gradient_begin = use_system_colors ? Color.FromArgb (251, 250, 246) : Color.FromArgb (255, 255, 237); + tool_strip_gradient_end = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (181, 196, 143); + tool_strip_gradient_middle = use_system_colors ? Color.FromArgb (246, 244, 236) : Color.FromArgb (206, 220, 167); + + tool_strip_panel_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (217, 217, 167); + tool_strip_panel_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 247) : Color.FromArgb (242, 241, 228); + break; + case ColorSchemes.Metallic: + button_checked_gradient_begin = use_system_colors ? Color.Empty : Color.FromArgb (255, 223, 154); + button_checked_gradient_end = use_system_colors ? Color.Empty : Color.FromArgb (255, 166, 76); + button_checked_gradient_middle = use_system_colors ? Color.Empty : Color.FromArgb (255, 195, 116); + button_checked_highlight = Color.FromArgb (231, 232, 235); + button_checked_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + + button_pressed_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (75, 75, 111); + button_pressed_gradient_begin = use_system_colors ? Color.FromArgb (217, 218, 223) : Color.FromArgb (254, 128, 62); + button_pressed_gradient_end = use_system_colors ? Color.FromArgb (217, 218, 223) : Color.FromArgb (255, 223, 154); + button_pressed_gradient_middle = use_system_colors ? Color.FromArgb (217, 218, 223) : Color.FromArgb (255, 177, 109); + button_pressed_highlight = use_system_colors ? Color.FromArgb (215, 216, 222) : Color.FromArgb (215, 216, 222); + button_pressed_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + + button_selected_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (75, 75, 111); + button_selected_gradient_begin = use_system_colors ? Color.FromArgb (232, 233, 236) : Color.FromArgb (255, 255, 222); + button_selected_gradient_end = use_system_colors ? Color.FromArgb (232, 233, 236) : Color.FromArgb (255, 203, 136); + button_selected_gradient_middle = use_system_colors ? Color.FromArgb (232, 233, 236) : Color.FromArgb (255, 225, 172); + button_selected_highlight = use_system_colors ? Color.FromArgb (231, 232, 235) : Color.FromArgb (231, 232, 235); + button_selected_highlight_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (75, 75, 111); + + check_background = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (255, 192, 111); + check_pressed_background = use_system_colors ? Color.FromArgb (217, 218, 223) : Color.FromArgb (254, 128, 62); + check_selected_background = use_system_colors ? Color.FromArgb (217, 218, 223) : Color.FromArgb (254, 128, 62); + + grip_dark = use_system_colors ? Color.FromArgb (182, 182, 185) : Color.FromArgb (84, 84, 117); + grip_light = use_system_colors ? SystemColors.Window : Color.FromArgb (255, 255, 255); + + image_margin_gradient_begin = use_system_colors ? Color.FromArgb (248, 248, 249) : Color.FromArgb (249, 249, 255); + image_margin_gradient_end = use_system_colors ? SystemColors.Control : Color.FromArgb (147, 145, 176); + image_margin_gradient_middle = use_system_colors ? Color.FromArgb (240, 239, 241) : Color.FromArgb (225, 226, 236); + image_margin_revealed_gradient_begin = use_system_colors ? Color.FromArgb (243, 242, 244) : Color.FromArgb (215, 215, 226); + image_margin_revealed_gradient_end = use_system_colors ? Color.FromArgb (227, 226, 230) : Color.FromArgb (118, 116, 151); + image_margin_revealed_gradient_middle = use_system_colors ? Color.FromArgb (233, 233, 235) : Color.FromArgb (184, 185, 202); + + menu_border = use_system_colors ? Color.FromArgb (126, 126, 129) : Color.FromArgb (124, 124, 148); + menu_item_border = use_system_colors ? SystemColors.Highlight : Color.FromArgb (75, 75, 111); + + menu_item_pressed_gradient_begin = use_system_colors ? Color.FromArgb (248, 248, 249) : Color.FromArgb (232, 233, 242); + menu_item_pressed_gradient_end = use_system_colors ? Color.FromArgb (240, 239, 241) : Color.FromArgb (172, 170, 194); + menu_item_pressed_gradient_middle = use_system_colors ? Color.FromArgb (233, 233, 235) : Color.FromArgb (184, 185, 202); + menu_item_selected = use_system_colors ? SystemColors.Window : Color.FromArgb (255, 238, 194); + menu_item_selected_gradient_begin = use_system_colors ? Color.FromArgb (232, 233, 236) : Color.FromArgb (255, 255, 222); + menu_item_selected_gradient_end = use_system_colors ? Color.FromArgb (232, 233, 236) : Color.FromArgb (255, 203, 136); + + menu_strip_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (215, 215, 229); + menu_strip_gradient_end = use_system_colors ? Color.FromArgb (249, 248, 249) : Color.FromArgb (243, 243, 247); + + overflow_button_gradient_begin = use_system_colors ? Color.FromArgb (233, 233, 235) : Color.FromArgb (186, 185, 206); + overflow_button_gradient_end = use_system_colors ? SystemColors.ButtonShadow : Color.FromArgb (118, 116, 146); + overflow_button_gradient_middle = use_system_colors ? Color.FromArgb (227, 226, 230) : Color.FromArgb (156, 155, 180); + + rafting_container_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (215, 215, 229); + rafting_container_gradient_end = use_system_colors ? Color.FromArgb (249, 248, 249) : Color.FromArgb (243, 243, 247); + + separator_dark = use_system_colors ? Color.FromArgb (186, 186, 189) : Color.FromArgb (110, 109, 143); + separator_light = use_system_colors ? SystemColors.ButtonHighlight : Color.FromArgb (255, 255, 255); + + status_strip_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (215, 215, 229); + status_strip_gradient_end = use_system_colors ? Color.FromArgb (249, 248, 249) : Color.FromArgb (243, 243, 247); + + tool_strip_border = use_system_colors ? Color.FromArgb (229, 228, 232) : Color.FromArgb (124, 124, 148); + tool_strip_content_panel_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (215, 215, 229); + tool_strip_content_panel_gradient_end = use_system_colors ? Color.FromArgb (249, 248, 249) : Color.FromArgb (243, 243, 247); + tool_strip_drop_down_background = use_system_colors ? Color.FromArgb (251, 250, 251) : Color.FromArgb (253, 250, 255); + + tool_strip_gradient_begin = use_system_colors ? Color.FromArgb (248, 248, 249) : Color.FromArgb (249, 249, 255); + tool_strip_gradient_end = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (147, 145, 176); + tool_strip_gradient_middle = use_system_colors ? Color.FromArgb (240, 239, 241) : Color.FromArgb (225, 226, 236); + + tool_strip_panel_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (215, 215, 229); + tool_strip_panel_gradient_end = use_system_colors ? Color.FromArgb (249, 248, 249) : Color.FromArgb (243, 243, 247); + break; + case ColorSchemes.MediaCenter: + button_checked_gradient_begin = use_system_colors ? Color.Empty : Color.FromArgb (226, 229, 238); + button_checked_gradient_end = use_system_colors ? Color.Empty : Color.FromArgb (226, 229, 238); + button_checked_gradient_middle = use_system_colors ? Color.Empty : Color.FromArgb (226, 229, 238); + button_checked_highlight = Color.FromArgb (196, 208, 229); + button_checked_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + + button_pressed_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (51, 94, 168); + button_pressed_gradient_begin = use_system_colors ? Color.FromArgb (153, 175, 212) : Color.FromArgb (153, 175, 212); + button_pressed_gradient_end = use_system_colors ? Color.FromArgb (153, 175, 212) : Color.FromArgb (153, 175, 212); + button_pressed_gradient_middle = use_system_colors ? Color.FromArgb (153, 175, 212) : Color.FromArgb (153, 175, 212); + button_pressed_highlight = use_system_colors ? Color.FromArgb (152, 173, 210) : Color.FromArgb (152, 173, 210); + button_pressed_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + + button_selected_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (51, 94, 168); + button_selected_gradient_begin = use_system_colors ? Color.FromArgb (194, 207, 229) : Color.FromArgb (194, 207, 229); + button_selected_gradient_end = use_system_colors ? Color.FromArgb (194, 207, 229) : Color.FromArgb (194, 207, 229); + button_selected_gradient_middle = use_system_colors ? Color.FromArgb (194, 207, 229) : Color.FromArgb (194, 207, 229); + button_selected_highlight = use_system_colors ? Color.FromArgb (196, 208, 229) : Color.FromArgb (196, 208, 229); + button_selected_highlight_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (51, 94, 168); + + check_background = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (226, 229, 238); + check_pressed_background = use_system_colors ? Color.FromArgb (153, 175, 212) : Color.FromArgb (51, 94, 168); + check_selected_background = use_system_colors ? Color.FromArgb (153, 175, 212) : Color.FromArgb (51, 94, 168); + + grip_dark = use_system_colors ? Color.FromArgb (189, 188, 191) : Color.FromArgb (189, 188, 191); + grip_light = use_system_colors ? SystemColors.Window : Color.FromArgb (255, 255, 255); + + image_margin_gradient_begin = use_system_colors ? Color.FromArgb (250, 250, 251) : Color.FromArgb (252, 252, 252); + image_margin_gradient_end = use_system_colors ? SystemColors.Control : Color.FromArgb (235, 233, 237); + image_margin_gradient_middle = use_system_colors ? Color.FromArgb (245, 244, 246) : Color.FromArgb (245, 244, 246); + image_margin_revealed_gradient_begin = use_system_colors ? Color.FromArgb (247, 246, 248) : Color.FromArgb (247, 246, 248); + image_margin_revealed_gradient_end = use_system_colors ? Color.FromArgb (237, 235, 239) : Color.FromArgb (228, 226, 230); + image_margin_revealed_gradient_middle = use_system_colors ? Color.FromArgb (241, 240, 242) : Color.FromArgb (241, 240, 242); + + menu_border = use_system_colors ? Color.FromArgb (134, 133, 136) : Color.FromArgb (134, 133, 136); + menu_item_border = use_system_colors ? SystemColors.Highlight : Color.FromArgb (51, 94, 168); + + menu_item_pressed_gradient_begin = use_system_colors ? Color.FromArgb (250, 250, 251) : Color.FromArgb (252, 252, 252); + menu_item_pressed_gradient_end = use_system_colors ? Color.FromArgb (245, 244, 246) : Color.FromArgb (245, 244, 246); + menu_item_pressed_gradient_middle = use_system_colors ? Color.FromArgb (241, 240, 242) : Color.FromArgb (241, 240, 242); + menu_item_selected = use_system_colors ? SystemColors.Window : Color.FromArgb (194, 207, 229); + menu_item_selected_gradient_begin = use_system_colors ? Color.FromArgb (194, 207, 229) : Color.FromArgb (194, 207, 229); + menu_item_selected_gradient_end = use_system_colors ? Color.FromArgb (194, 207, 229) : Color.FromArgb (194, 207, 229); + + menu_strip_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (235, 233, 237); + menu_strip_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 251) : Color.FromArgb (251, 250, 251); + + overflow_button_gradient_begin = use_system_colors ? Color.FromArgb (241, 240, 242) : Color.FromArgb (242, 242, 242); + overflow_button_gradient_end = use_system_colors ? SystemColors.ButtonShadow : Color.FromArgb (167, 166, 170); + overflow_button_gradient_middle = use_system_colors ? Color.FromArgb (237, 235, 239) : Color.FromArgb (224, 224, 225); + + rafting_container_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (235, 233, 237); + rafting_container_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 251) : Color.FromArgb (251, 250, 251); + + separator_dark = use_system_colors ? Color.FromArgb (193, 193, 196) : Color.FromArgb (193, 193, 196); + separator_light = use_system_colors ? SystemColors.ButtonHighlight : Color.FromArgb (255, 255, 255); + + status_strip_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (235, 233, 237); + status_strip_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 251) : Color.FromArgb (251, 250, 251); + + tool_strip_border = use_system_colors ? Color.FromArgb (238, 237, 240) : Color.FromArgb (238, 237, 240); + tool_strip_content_panel_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (235, 233, 237); + tool_strip_content_panel_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 251) : Color.FromArgb (251, 250, 251); + tool_strip_drop_down_background = use_system_colors ? Color.FromArgb (252, 252, 252) : Color.FromArgb (252, 252, 252); + + tool_strip_gradient_begin = use_system_colors ? Color.FromArgb (250, 250, 251) : Color.FromArgb (252, 252, 252); + tool_strip_gradient_end = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (235, 233, 237); + tool_strip_gradient_middle = use_system_colors ? Color.FromArgb (245, 244, 246) : Color.FromArgb (245, 244, 246); + + tool_strip_panel_gradient_begin = use_system_colors ? SystemColors.ButtonFace : Color.FromArgb (235, 233, 237); + tool_strip_panel_gradient_end = use_system_colors ? Color.FromArgb (251, 250, 251) : Color.FromArgb (251, 250, 251); + break; + case ColorSchemes.Aero: + button_checked_gradient_begin = Color.Empty; + button_checked_gradient_end = Color.Empty; + button_checked_gradient_middle = Color.Empty; + button_checked_highlight = Color.FromArgb (196, 225, 255); + button_checked_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + + button_pressed_border = Color.FromKnownColor (KnownColor.Highlight); + button_pressed_gradient_begin = Color.FromArgb (153, 204, 255); + button_pressed_gradient_end = Color.FromArgb (153, 204, 255); + button_pressed_gradient_middle = Color.FromArgb (153, 204, 255); + button_pressed_highlight = Color.FromArgb (152, 203, 255); + button_pressed_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + + button_selected_border = use_system_colors ? Color.FromKnownColor (KnownColor.Highlight) : Color.FromArgb (51, 94, 168); + button_selected_gradient_begin = Color.FromArgb (194, 224, 255); + button_selected_gradient_end = Color.FromArgb (194, 224, 255); + button_selected_gradient_middle = Color.FromArgb (194, 224, 255); + button_selected_highlight = Color.FromArgb (196, 225, 255); + button_selected_highlight_border = Color.FromKnownColor (KnownColor.Highlight); + + check_background = Color.FromKnownColor (KnownColor.Highlight); + check_pressed_background = Color.FromArgb (153, 204, 255); + check_selected_background = Color.FromArgb (153, 204, 255); + + grip_dark = Color.FromArgb (184, 184, 184); + grip_light = SystemColors.Window; + + image_margin_gradient_begin = Color.FromArgb (252, 252, 252); + image_margin_gradient_end = SystemColors.Control; + image_margin_gradient_middle = Color.FromArgb (250, 250, 250); + image_margin_revealed_gradient_begin = Color.FromArgb (251, 251, 251); + image_margin_revealed_gradient_end = Color.FromArgb (245, 245, 245); + image_margin_revealed_gradient_middle = Color.FromArgb (247, 247, 247); + + menu_border = Color.FromArgb (128, 128, 128); + menu_item_border = SystemColors.Highlight; + + menu_item_pressed_gradient_begin = Color.FromArgb (252, 252, 252); + menu_item_pressed_gradient_end = Color.FromArgb (250, 250, 250); + menu_item_pressed_gradient_middle = Color.FromArgb (247, 247, 247); + menu_item_selected = SystemColors.Window; + menu_item_selected_gradient_begin = Color.FromArgb (194, 224, 255); + menu_item_selected_gradient_end = Color.FromArgb (194, 224, 255); + + menu_strip_gradient_begin = SystemColors.ButtonFace; + menu_strip_gradient_end = Color.FromArgb (253, 253, 253); + + overflow_button_gradient_begin = Color.FromArgb (247, 247, 247); + overflow_button_gradient_end = SystemColors.ButtonShadow; + overflow_button_gradient_middle = Color.FromArgb (245, 245, 245); + + rafting_container_gradient_begin = SystemColors.ButtonFace; + rafting_container_gradient_end = Color.FromArgb (253, 253, 253); + + separator_dark = Color.FromArgb (189, 189, 189); + separator_light = SystemColors.ButtonHighlight; + + status_strip_gradient_begin = SystemColors.ButtonFace; + status_strip_gradient_end = Color.FromArgb (253, 253, 253); + + tool_strip_border = Color.FromArgb (246, 246, 246); + tool_strip_content_panel_gradient_begin = SystemColors.ButtonFace; + tool_strip_content_panel_gradient_end = Color.FromArgb (253, 253, 253); + tool_strip_drop_down_background = Color.FromArgb (253, 253, 253); + + tool_strip_gradient_begin = Color.FromArgb (252, 252, 252); + tool_strip_gradient_end = SystemColors.ButtonFace; + tool_strip_gradient_middle = Color.FromArgb (250, 250, 250); + + tool_strip_panel_gradient_begin = SystemColors.ButtonFace; + tool_strip_panel_gradient_end = Color.FromArgb (253, 253, 253); + break; + } + } + + private ColorSchemes GetCurrentStyle () + { + if (!VisualStyleInformation.IsEnabledByUser || string.IsNullOrEmpty (VisualStylesEngine.Instance.VisualStyleInformationFileName)) + + + return ColorSchemes.Classic; + else { + switch (System.IO.Path.GetFileNameWithoutExtension (VisualStylesEngine.Instance.VisualStyleInformationFileName).ToLowerInvariant ()) { + case "aero": + return ColorSchemes.Aero; + case "royale": + return ColorSchemes.MediaCenter; + default: + switch (VisualStyleInformation.ColorScheme) { + case "NormalColor": + return ColorSchemes.NormalColor; + case "HomeStead": + return ColorSchemes.HomeStead; + case "Metallic": + return ColorSchemes.Metallic; + default: + return ColorSchemes.Classic; + } + } + } + } + #endregion + + #region Private Enums + private enum ColorSchemes + { + Classic, // Windows Classic (No theme) + NormalColor, // Luna Blue + HomeStead, // Luna Olive + Metallic, // Luna Silver + MediaCenter, // Media Center (Energy Blue) + Aero // Windows Vista + } + #endregion + } +} diff --git a/source/ShiftUI/Internal/PropertyManager.cs b/source/ShiftUI/Internal/PropertyManager.cs new file mode 100644 index 0000000..f31608f --- /dev/null +++ b/source/ShiftUI/Internal/PropertyManager.cs @@ -0,0 +1,166 @@ +// 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. +// +// Authors: +// Jackson Harper [email protected] + +using System; +using System.Collections; +using System.ComponentModel; + +namespace ShiftUI { + + public class PropertyManager : BindingManagerBase { + + internal string property_name; + private PropertyDescriptor prop_desc; + private object data_source; + private EventDescriptor changed_event; + private EventHandler property_value_changed_handler; + + public PropertyManager() { + } + + internal PropertyManager (object data_source) + { + SetDataSource (data_source); + } + + internal PropertyManager (object data_source, string property_name) + { + this.property_name = property_name; + + SetDataSource (data_source); + } + + internal void SetDataSource (object new_data_source) + { + if (changed_event != null) + changed_event.RemoveEventHandler (data_source, property_value_changed_handler); + + data_source = new_data_source; + + if (property_name != null) { + prop_desc = TypeDescriptor.GetProperties (data_source).Find (property_name, true); + + if (prop_desc == null) + return; + + changed_event = TypeDescriptor.GetEvents (data_source).Find (property_name + "Changed", false); + if (changed_event != null) { + property_value_changed_handler = new EventHandler (PropertyValueChanged); + changed_event.AddEventHandler (data_source, property_value_changed_handler); + } + } + } + + void PropertyValueChanged (object sender, EventArgs args) + { + OnCurrentChanged (args); + } + + public override object Current { + get { return prop_desc == null ? data_source : prop_desc.GetValue (data_source); } + } + + public override int Position { + get { return 0; } + set { /* Doesn't do anything on MS" */ } + } + + public override int Count { + get { return 1; } + } + + public override void AddNew () + { + throw new NotSupportedException ("AddNew is not supported for property to property binding"); + } + + public override void CancelCurrentEdit () + { + IEditableObject editable = data_source as IEditableObject; + if (editable == null) + return; + editable.CancelEdit (); + + PushData (); + } + + public override void EndCurrentEdit () + { + PullData (); + + IEditableObject editable = data_source as IEditableObject; + if (editable == null) + return; + editable.EndEdit (); + } + + // Hide this method from the 2.0 public API + internal override PropertyDescriptorCollection GetItemPropertiesInternal () + { + return TypeDescriptor.GetProperties (data_source); + } + + public override void RemoveAt (int index) + { + throw new NotSupportedException ("RemoveAt is not supported for property to property binding"); + } + + public override void ResumeBinding () + { + } + + public override void SuspendBinding () + { + } + + internal override bool IsSuspended { + get { return data_source == null; } + } + + protected internal override string GetListName (ArrayList listAccessors) + { + return String.Empty; + } + + [MonoTODO ("Stub, does nothing")] + protected override void UpdateIsBinding () + { + } + + protected internal override void OnCurrentChanged (EventArgs ea) + { + PushData (); + + if (onCurrentChangedHandler != null) { + onCurrentChangedHandler (this, ea); + } + } + + protected override void OnCurrentItemChanged (EventArgs ea) + { + throw new NotImplementedException (); + } + } +} + diff --git a/source/ShiftUI/Internal/PropertySort.cs b/source/ShiftUI/Internal/PropertySort.cs new file mode 100644 index 0000000..30a9fa6 --- /dev/null +++ b/source/ShiftUI/Internal/PropertySort.cs @@ -0,0 +1,40 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jonathan Chambers ([email protected]) +// + +// COMPLETE + +using System.Runtime.InteropServices; + +namespace ShiftUI +{ + [ComVisible(true)] + public enum PropertySort + { + NoSort = 0, + Alphabetical = 1, + Categorized = 2, + CategorizedAlphabetical = 3 + } +} diff --git a/source/ShiftUI/Internal/PropertyTabChangedEventArgs.cs b/source/ShiftUI/Internal/PropertyTabChangedEventArgs.cs new file mode 100644 index 0000000..3fee1c3 --- /dev/null +++ b/source/ShiftUI/Internal/PropertyTabChangedEventArgs.cs @@ -0,0 +1,66 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jonathan Chambers ([email protected]) +// + +// COMPLETE + +using System; +using System.Runtime.InteropServices; +using ShiftUI.Design; + +namespace ShiftUI +{ + [ComVisible(true)] + public class PropertyTabChangedEventArgs : EventArgs + { + #region Local Variables + private PropertyTab old_tab; + private PropertyTab new_tab; + #endregion // Local Variables + + #region Constructor + public PropertyTabChangedEventArgs ( PropertyTab oldTab , PropertyTab newTab ) + { + old_tab = oldTab; + new_tab = newTab; + } + #endregion // Constructor + + #region Public Instance Properties + public PropertyTab NewTab + { + get { + return new_tab; + } + } + + public PropertyTab OldTab + { + get { + return old_tab; + } + } + #endregion // Public Instance Properties + } +} diff --git a/source/ShiftUI/Internal/PropertyTabChangedEventHandler.cs b/source/ShiftUI/Internal/PropertyTabChangedEventHandler.cs new file mode 100644 index 0000000..498776f --- /dev/null +++ b/source/ShiftUI/Internal/PropertyTabChangedEventHandler.cs @@ -0,0 +1,33 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jonathan Chambers ([email protected]) +// + +// COMPLETE + +namespace ShiftUI +{ + public delegate void PropertyTabChangedEventHandler(object s, PropertyTabChangedEventArgs e); +} + + diff --git a/source/ShiftUI/Internal/PropertyValueChangedEventArgs.cs b/source/ShiftUI/Internal/PropertyValueChangedEventArgs.cs new file mode 100644 index 0000000..ac308af --- /dev/null +++ b/source/ShiftUI/Internal/PropertyValueChangedEventArgs.cs @@ -0,0 +1,66 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jonathan Chambers ([email protected]) +// + +// COMPLETE + +using System; +using System.Runtime.InteropServices; +using ShiftUI.Design; + +namespace ShiftUI +{ + [ComVisible(true)] + public class PropertyValueChangedEventArgs : EventArgs + { + #region Local Variables + private GridItem changed_item; + private object old_value; + #endregion // Local Variables + + #region Constructors + public PropertyValueChangedEventArgs ( GridItem changedItem , object oldValue ) + { + changed_item = changedItem; + old_value = oldValue; + } + #endregion + + #region Public Instance Properties + public GridItem ChangedItem + { + get { + return changed_item; + } + } + + public object OldValue + { + get { + return old_value; + } + } + #endregion // Public Instance Properties + } +} diff --git a/source/ShiftUI/Internal/PropertyValueChangedEventHandler.cs b/source/ShiftUI/Internal/PropertyValueChangedEventHandler.cs new file mode 100644 index 0000000..3e76a86 --- /dev/null +++ b/source/ShiftUI/Internal/PropertyValueChangedEventHandler.cs @@ -0,0 +1,31 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jonathan Chambers ([email protected]) +// + +// COMPLETE + +namespace ShiftUI +{ + public delegate void PropertyValueChangedEventHandler(object s, PropertyValueChangedEventArgs e); +} diff --git a/source/ShiftUI/Internal/RadioButtonRenderer.cs b/source/ShiftUI/Internal/RadioButtonRenderer.cs new file mode 100644 index 0000000..c08eb4f --- /dev/null +++ b/source/ShiftUI/Internal/RadioButtonRenderer.cs @@ -0,0 +1,182 @@ +// +// RadioButtonRenderer.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +using System.Drawing; +using ShiftUI.VisualStyles; +using System; + +namespace ShiftUI +{ + public sealed class RadioButtonRenderer + { + private static bool always_use_visual_styles = false; + + #region Private Constructor + private RadioButtonRenderer () { } + #endregion + + #region Public Static Methods + public static void DrawRadioButton (Graphics g, Point glyphLocation, RadioButtonState state) + { + DrawRadioButton (g, glyphLocation, Rectangle.Empty, String.Empty, null, TextFormatFlags.HorizontalCenter, null, Rectangle.Empty, false, state); + } + + public static void DrawRadioButton (Graphics g, Point glyphLocation, Rectangle textBounds, string radioButtonText, Font font, bool focused, RadioButtonState state) + { + DrawRadioButton (g, glyphLocation, textBounds, radioButtonText, font, TextFormatFlags.HorizontalCenter, null, Rectangle.Empty, focused, state); + } + + public static void DrawRadioButton (Graphics g, Point glyphLocation, Rectangle textBounds, string radioButtonText, Font font, TextFormatFlags flags, bool focused, RadioButtonState state) + { + DrawRadioButton (g, glyphLocation, textBounds, radioButtonText, font, flags, null, Rectangle.Empty, focused, state); + } + + public static void DrawRadioButton (Graphics g, Point glyphLocation, Rectangle textBounds, string radioButtonText, Font font, Image image, Rectangle imageBounds, bool focused, RadioButtonState state) + { + DrawRadioButton (g, glyphLocation, textBounds, radioButtonText, font, TextFormatFlags.HorizontalCenter, image, imageBounds, focused, state); + } + + public static void DrawRadioButton (Graphics g, Point glyphLocation, Rectangle textBounds, string radioButtonText, Font font, TextFormatFlags flags, Image image, Rectangle imageBounds, bool focused, RadioButtonState state) + { + Rectangle bounds = new Rectangle (glyphLocation, GetGlyphSize (g, state)); + + if (Application.RenderWithVisualStyles || always_use_visual_styles == true) { + VisualStyleRenderer vsr = GetRadioButtonRenderer (state); + + vsr.DrawBackground (g, bounds); + + if (image != null) + vsr.DrawImage (g, imageBounds, image); + + if (focused) + WidgetPaint.DrawFocusRectangle (g, textBounds); + + if (radioButtonText != String.Empty) + if (state == RadioButtonState.CheckedDisabled || state == RadioButtonState.UncheckedDisabled) + TextRenderer.DrawText (g, radioButtonText, font, textBounds, SystemColors.GrayText, flags); + else + TextRenderer.DrawText (g, radioButtonText, font, textBounds, SystemColors.ControlText, flags); + } + else { + switch (state) { + case RadioButtonState.CheckedDisabled: + WidgetPaint.DrawRadioButton (g, bounds, ButtonState.Inactive | ButtonState.Checked); + break; + case RadioButtonState.CheckedHot: + case RadioButtonState.CheckedNormal: + WidgetPaint.DrawRadioButton (g, bounds, ButtonState.Checked); + break; + case RadioButtonState.CheckedPressed: + WidgetPaint.DrawRadioButton (g, bounds, ButtonState.Pushed | ButtonState.Checked); + break; + case RadioButtonState.UncheckedDisabled: + case RadioButtonState.UncheckedPressed: + WidgetPaint.DrawRadioButton (g, bounds, ButtonState.Inactive); + break; + case RadioButtonState.UncheckedHot: + case RadioButtonState.UncheckedNormal: + WidgetPaint.DrawRadioButton (g, bounds, ButtonState.Normal); + break; + } + + if (image != null) + g.DrawImage (image, imageBounds); + + if (focused) + WidgetPaint.DrawFocusRectangle (g, textBounds); + + if (radioButtonText != String.Empty) + TextRenderer.DrawText (g, radioButtonText, font, textBounds, SystemColors.ControlText, flags); + } + + } + + public static bool IsBackgroundPartiallyTransparent (RadioButtonState state) + { + if (!VisualStyleRenderer.IsSupported) + return false; + + VisualStyleRenderer vsr = GetRadioButtonRenderer (state); + + return vsr.IsBackgroundPartiallyTransparent (); + } + + public static void DrawParentBackground (Graphics g, Rectangle bounds, Widget childControl) + { + if (!VisualStyleRenderer.IsSupported) + return; + + VisualStyleRenderer vsr = new VisualStyleRenderer (VisualStyleElement.Button.RadioButton.UncheckedNormal); + + vsr.DrawParentBackground (g, bounds, childControl); + } + + public static Size GetGlyphSize (Graphics g, RadioButtonState state) + { + if (!VisualStyleRenderer.IsSupported) + return new Size (13, 13); + + VisualStyleRenderer vsr = GetRadioButtonRenderer(state); + + return vsr.GetPartSize (g, ThemeSizeType.Draw); + } + #endregion + + #region Private Static Methods + private static VisualStyleRenderer GetRadioButtonRenderer (RadioButtonState state) + { + switch (state) { + case RadioButtonState.CheckedDisabled: + return new VisualStyleRenderer (VisualStyleElement.Button.RadioButton.CheckedDisabled); + case RadioButtonState.CheckedHot: + return new VisualStyleRenderer (VisualStyleElement.Button.RadioButton.CheckedHot); + case RadioButtonState.CheckedNormal: + return new VisualStyleRenderer (VisualStyleElement.Button.RadioButton.CheckedNormal); + case RadioButtonState.CheckedPressed: + return new VisualStyleRenderer (VisualStyleElement.Button.RadioButton.CheckedPressed); + case RadioButtonState.UncheckedDisabled: + return new VisualStyleRenderer (VisualStyleElement.Button.RadioButton.UncheckedDisabled); + case RadioButtonState.UncheckedHot: + return new VisualStyleRenderer (VisualStyleElement.Button.RadioButton.UncheckedHot); + case RadioButtonState.UncheckedNormal: + default: + return new VisualStyleRenderer (VisualStyleElement.Button.RadioButton.UncheckedNormal); + case RadioButtonState.UncheckedPressed: + return new VisualStyleRenderer (VisualStyleElement.Button.RadioButton.UncheckedPressed); + } + } + #endregion + + #region Public Static Properties + public static bool RenderMatchingApplicationState { + get { return !always_use_visual_styles; } + set { always_use_visual_styles = !value; } + } + #endregion + } +}
\ No newline at end of file diff --git a/source/ShiftUI/Internal/RelatedCurrencyManager.cs b/source/ShiftUI/Internal/RelatedCurrencyManager.cs new file mode 100644 index 0000000..2957db0 --- /dev/null +++ b/source/ShiftUI/Internal/RelatedCurrencyManager.cs @@ -0,0 +1,54 @@ +// 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) 2006 Novell, Inc. +// +// Authors: +// Chris Toshok ([email protected]) +// + +using System; +using System.Data; +using System.Reflection; +using System.Collections; +using System.ComponentModel; + +namespace ShiftUI { + [DefaultMember("Item")] + internal class RelatedCurrencyManager : CurrencyManager { + + BindingManagerBase parent; + PropertyDescriptor prop_desc; + + public RelatedCurrencyManager (BindingManagerBase parent, PropertyDescriptor prop_desc) + : base (prop_desc.GetValue (parent.Current)) + { + this.parent = parent; + this.prop_desc = prop_desc; + + parent.PositionChanged += new EventHandler (parent_PositionChanged); + } + + private void parent_PositionChanged (object sender, EventArgs args) + { + SetDataSource (prop_desc.GetValue (parent.Current)); + } + } +} + diff --git a/source/ShiftUI/Internal/RelatedImageListAttribute.cs b/source/ShiftUI/Internal/RelatedImageListAttribute.cs new file mode 100644 index 0000000..4c3af82 --- /dev/null +++ b/source/ShiftUI/Internal/RelatedImageListAttribute.cs @@ -0,0 +1,48 @@ +// +// RelatedImageListAttribute.cs +// +// 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) 2007 Novell, Inc. +// +// Author: +// Jonathan Pobst ([email protected]) + + +using System; +using ShiftUI; + +namespace ShiftUI +{ + [AttributeUsageAttribute (AttributeTargets.Property, AllowMultiple = false, Inherited = true)] + public sealed class RelatedImageListAttribute : Attribute + { + private string related_image_list; + + public RelatedImageListAttribute (string relatedImageList) + { + this.related_image_list = relatedImageList; + } + + public string RelatedImageList { + get { return this.related_image_list; } + } + } +} diff --git a/source/ShiftUI/Internal/RelatedPropertyManager.cs b/source/ShiftUI/Internal/RelatedPropertyManager.cs new file mode 100644 index 0000000..0ba4834 --- /dev/null +++ b/source/ShiftUI/Internal/RelatedPropertyManager.cs @@ -0,0 +1,67 @@ +// 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) 2006 Novell, Inc. +// +// Authors: +// Chris Toshok <[email protected]> + +using System; +using System.Collections; +using System.ComponentModel; + +namespace ShiftUI { + + internal class RelatedPropertyManager : PropertyManager { + + BindingManagerBase parent; + + public RelatedPropertyManager (BindingManagerBase parent, string property_name) + { + this.parent = parent; + this.property_name = property_name; + + if (parent.Position != -1) + SetDataSource (parent.Current); + parent.PositionChanged += new EventHandler (parent_PositionChanged); + } + + void parent_PositionChanged (object sender, EventArgs args) + { + if (parent.Position == -1) { + SetDataSource (null); + } + else { + SetDataSource (parent.Current); + } + + OnCurrentChanged (EventArgs.Empty); + } + + public override PropertyDescriptorCollection GetItemProperties () + { + PropertyDescriptor property = parent.GetItemProperties ().Find (property_name, true); + + // We can't just pass property.PropertyType, since the actual object could implement + // more elements and not only those described in the property type + return TypeDescriptor.GetProperties (property.GetValue (parent.Current)); + } + } +} + diff --git a/source/ShiftUI/Internal/RichTextBoxFinds.cs b/source/ShiftUI/Internal/RichTextBoxFinds.cs new file mode 100644 index 0000000..28cd616 --- /dev/null +++ b/source/ShiftUI/Internal/RichTextBoxFinds.cs @@ -0,0 +1,39 @@ +// 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; + +namespace ShiftUI { + [Flags] + public enum RichTextBoxFinds { + None = 0x00000000, + WholeWord = 0x00000002, + MatchCase = 0x00000004, + NoHighlight = 0x00000008, + Reverse = 0x00000010, + } +} diff --git a/source/ShiftUI/Internal/RichTextBoxScrollBars.cs b/source/ShiftUI/Internal/RichTextBoxScrollBars.cs new file mode 100644 index 0000000..b155f53 --- /dev/null +++ b/source/ShiftUI/Internal/RichTextBoxScrollBars.cs @@ -0,0 +1,39 @@ +// 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 + +namespace ShiftUI { + public enum RichTextBoxScrollBars { + None = 0, + Horizontal = 1, + Vertical = 2, + Both = 3, + ForcedHorizontal= 17, + ForcedVertical = 18, + ForcedBoth = 19 + } +} diff --git a/source/ShiftUI/Internal/SUI_NOTES.txt b/source/ShiftUI/Internal/SUI_NOTES.txt new file mode 100644 index 0000000..96350b0 --- /dev/null +++ b/source/ShiftUI/Internal/SUI_NOTES.txt @@ -0,0 +1,3 @@ +The code found in this folder is from the Mono project. + +The Mono project can be found on Github at http://github.com/mono/mono. diff --git a/source/ShiftUI/Internal/Screen.cs b/source/ShiftUI/Internal/Screen.cs new file mode 100644 index 0000000..7da251f --- /dev/null +++ b/source/ShiftUI/Internal/Screen.cs @@ -0,0 +1,221 @@ +// 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]) +// +// + +using System; +using System.Drawing; + +namespace ShiftUI { + public class Screen { + #region Local Variables + private static Screen[] all_screens; + private bool primary; + private Rectangle bounds; + private Rectangle workarea; + private string name; + private int bits_per_pixel; + #endregion // Local Variables + + #region Constructors + static Screen () + { + try { + all_screens = XplatUI.AllScreens; + } + catch (Exception e) { + Console.WriteLine ("{0} trying to get all screens: {1}", e.GetType (), e.Message); + } + + if (all_screens == null || all_screens.Length == 0) { + // just use a default one + all_screens = new[] { new Screen(true, "Mono MWF Primary Display", + XplatUI.VirtualScreen, XplatUI.WorkingArea) }; + } + } + + internal Screen() { + this.primary = true; + this.bounds = XplatUI.WorkingArea; + } + + internal Screen(bool primary, string name, Rectangle bounds, Rectangle workarea) { + this.primary = primary; + this.name = name; + this.bounds = bounds; + this.workarea = workarea; + this.bits_per_pixel = 32; + } + #endregion // Constructors + + #region Public Static Properties + public static Screen[] AllScreens { + get { + return all_screens; + } + } + + public static Screen PrimaryScreen { + get { + return all_screens[0]; + } + } + #endregion // Public Static Properties + + #region Public Instance Properties + [MonoTODO ("Stub, always returns 32")] + public int BitsPerPixel { + get { return bits_per_pixel; } + } + + public Rectangle Bounds { + get { + return this.bounds; + } + } + + public string DeviceName { + get { + return this.name; + } + } + + public bool Primary { + get { + return this.primary; + } + } + + public Rectangle WorkingArea { + get { + return this.workarea; + } + } + #endregion // Public Instance Properties + + #region Public Static Methods + public static Screen FromControl(Widget control) { + var point = control.Parent != null ? control.Parent.PointToScreen(control.Location) : control.Location; + return Screen.FromPoint(point); + } + + public static Screen FromHandle(IntPtr hwnd) { + Widget control; + + control = Widget.FromHandle(hwnd); + if (control != null) { + var point = control.Parent != null ? control.Parent.PointToScreen(control.Location) : control.Location; + return Screen.FromPoint(point); + } + return Screen.PrimaryScreen; + } + + public static Screen FromPoint(Point point) { + for (int i = 0; i < all_screens.Length; i++) { + if (all_screens[i].Bounds.Contains(point)) { + return all_screens[i]; + } + } + return Screen.PrimaryScreen; + } + + public static Screen FromRectangle(Rectangle rect) { + Screen bestScrn = null; + int closest = Int32.MaxValue; + foreach (Screen scrn in Screen.AllScreens) { + Rectangle rcBounds = scrn.Bounds; + int distance = 0; + if (rect.Left > rcBounds.Right) + distance += rect.Left - rcBounds.Right; + else if (rcBounds.Left > rect.Left) + distance += rcBounds.Left - rect.Left; + if (rcBounds.Left > rect.Right) + distance += rcBounds.Left - rect.Right; + else if (rect.Right > rcBounds.Right) + distance += rect.Right - rcBounds.Right; + if (rect.Top > rcBounds.Bottom) + distance += rect.Top - rcBounds.Bottom; + else if (rcBounds.Top > rect.Top) + distance += rcBounds.Top - rect.Top; + if (rcBounds.Top > rect.Bottom) + distance += rcBounds.Top - rect.Bottom; + else if (rect.Bottom > rcBounds.Bottom) + distance += rect.Bottom - rcBounds.Bottom; + if (distance < closest) { + bestScrn = scrn; + closest = distance; + } + } + return bestScrn; + } + + public static Rectangle GetBounds(Widget ctl) { + return Screen.FromControl(ctl).Bounds; + } + + public static Rectangle GetBounds(Point pt) { + return Screen.FromPoint(pt).Bounds; + } + + public static Rectangle GetBounds(Rectangle rect) { + return Screen.FromRectangle(rect).Bounds; + } + + public static Rectangle GetWorkingArea(Widget ctl) { + return Screen.FromControl(ctl).WorkingArea; + } + + public static Rectangle GetWorkingArea(Point pt) { + return Screen.FromPoint(pt).WorkingArea; + } + + public static Rectangle GetWorkingArea(Rectangle rect) { + return Screen.FromRectangle(rect).WorkingArea; + } + #endregion // Public Static Methods + + #region Public Instance Methods + public override bool Equals(object obj) { + if (obj is Screen) { + Screen s = (Screen)obj; + + if (name.Equals(s.name) && (primary == s.primary) && (bounds.Equals(s.Bounds)) && (workarea.Equals(s.workarea))) { + return true; + } + } + return false; + } + + public override int GetHashCode() { + return base.GetHashCode (); + } + + public override string ToString() { + return "Screen[Bounds={" + this.Bounds + "} WorkingArea={" + this.WorkingArea + "} Primary={" + this.Primary + "} DeviceName=" + this.DeviceName; + } + + + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/ScrollProperties.cs b/source/ShiftUI/Internal/ScrollProperties.cs new file mode 100644 index 0000000..a5f59ee --- /dev/null +++ b/source/ShiftUI/Internal/ScrollProperties.cs @@ -0,0 +1,97 @@ +// 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. +// +// Authors: +// Olivier Dufour [email protected] +// Jonathan Pobst [email protected] +// + +using System.ComponentModel; + +namespace ShiftUI +{ + public abstract class ScrollProperties + { + #region Private Fields + private ScrollableWidget parentControl; + internal ScrollBar scroll_bar; + #endregion + + #region constructor + protected ScrollProperties (ScrollableWidget container) + { + parentControl = container; + } + #endregion + + #region Public Properties + [DefaultValue (true)] + public bool Enabled { + get { return scroll_bar.Enabled; } + set { scroll_bar.Enabled = value; } + } + + [DefaultValue (10)] + [RefreshProperties (RefreshProperties.Repaint)] + public int LargeChange { + get { return scroll_bar.LargeChange; } + set { scroll_bar.LargeChange = value; } + } + + [DefaultValue (100)] + [RefreshProperties (RefreshProperties.Repaint)] + public int Maximum { + get { return scroll_bar.Maximum; } + set { scroll_bar.Maximum = value; } + } + + [DefaultValue (0)] + [RefreshProperties (RefreshProperties.Repaint)] + public int Minimum { + get { return scroll_bar.Minimum; } + set { scroll_bar.Minimum = value; } + } + + [DefaultValue (1)] + public int SmallChange { + get { return scroll_bar.SmallChange; } + set { scroll_bar.SmallChange = value; } + } + + [DefaultValue (0)] + [BindableAttribute (true)] + public int Value { + get { return scroll_bar.Value; } + set { scroll_bar.Value = value; } + } + + [DefaultValue (false)] + public bool Visible { + get { return scroll_bar.Visible; } + set { scroll_bar.Visible = value; } + } + #endregion + + #region Protected Properties + protected ScrollableWidget ParentControl { + get { return parentControl; } + } + #endregion + } +} diff --git a/source/ShiftUI/Internal/SelectedGridItemChangedEventArgs.cs b/source/ShiftUI/Internal/SelectedGridItemChangedEventArgs.cs new file mode 100644 index 0000000..8a6149c --- /dev/null +++ b/source/ShiftUI/Internal/SelectedGridItemChangedEventArgs.cs @@ -0,0 +1,65 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jonathan Chambers ([email protected]) +// + +// COMPLETE + +using System; +using ShiftUI.Design; + +namespace ShiftUI +{ + public class SelectedGridItemChangedEventArgs : EventArgs + { + #region Local Variables + private GridItem new_selection; + private GridItem old_selection; + #endregion + + #region Constructors + public SelectedGridItemChangedEventArgs ( GridItem oldSel , GridItem newSel ) + { + old_selection = oldSel; + new_selection = newSel; + } + #endregion // Constructors + + #region Public Instance Properties + public GridItem NewSelection + { + get { + return new_selection; + } + } + + public GridItem OldSelection + { + get { + return old_selection; + } + } + #endregion // Public Instance Properties + } +} + diff --git a/source/ShiftUI/Internal/SelectedGridItemChangedEventHandler.cs b/source/ShiftUI/Internal/SelectedGridItemChangedEventHandler.cs new file mode 100644 index 0000000..da69bf3 --- /dev/null +++ b/source/ShiftUI/Internal/SelectedGridItemChangedEventHandler.cs @@ -0,0 +1,31 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jonathan Chambers ([email protected]) +// + +// COMPLETE + +namespace ShiftUI +{ + public delegate void SelectedGridItemChangedEventHandler(object sender, SelectedGridItemChangedEventArgs e); +} diff --git a/source/ShiftUI/Internal/SelectionRangeConverter.cs b/source/ShiftUI/Internal/SelectionRangeConverter.cs new file mode 100644 index 0000000..07f18ef --- /dev/null +++ b/source/ShiftUI/Internal/SelectionRangeConverter.cs @@ -0,0 +1,110 @@ +// 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.ComponentModel; +using System.Globalization; +using System; + +namespace ShiftUI { + public class SelectionRangeConverter : TypeConverter { + #region Public Constructors + public SelectionRangeConverter() { + } + #endregion // Public Constructors + + #region Public Instance Methods + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { + if (sourceType == typeof(string)) { + return true; + } + return false; + } + + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) { + if (destinationType == typeof(string)) { + return true; + } + return false; + } + + public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { + string[] parts; + DateTime start; + DateTime end; + + if ((value == null) || !(value is String)) { + return base.ConvertFrom (context, culture, value); + } + + if (culture == null) { + culture = CultureInfo.CurrentCulture; + } + + parts = ((string)value).Split(culture.TextInfo.ListSeparator.ToCharArray()); + + start = (DateTime)TypeDescriptor.GetConverter(typeof(DateTime)).ConvertFromString(context, culture, parts[0]); + end = (DateTime)TypeDescriptor.GetConverter(typeof(DateTime)).ConvertFromString(context, culture, parts[1]); + + return new SelectionRange(start, end); + } + + public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { + SelectionRange s; + + if ((value == null) || !(value is SelectionRange) || (destinationType != typeof(string))) { + return base.ConvertTo (context, culture, value, destinationType); + } + + if (culture == null) { + culture = CultureInfo.CurrentCulture; + } + + s = (SelectionRange)value; + + + return s.Start.ToShortDateString() + culture.TextInfo.ListSeparator + s.End.ToShortDateString(); + } + + public override object CreateInstance(ITypeDescriptorContext context, System.Collections.IDictionary propertyValues) { + return new SelectionRange((DateTime)propertyValues["Start"], (DateTime)propertyValues["End"]); + } + + public override bool GetCreateInstanceSupported(ITypeDescriptorContext context) { + return true; + } + + public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes) { + return TypeDescriptor.GetProperties(typeof(SelectionRange), attributes); + } + + public override bool GetPropertiesSupported(ITypeDescriptorContext context) { + return true; + } + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/Splitter.cs b/source/ShiftUI/Internal/Splitter.cs new file mode 100644 index 0000000..761f6ee --- /dev/null +++ b/source/ShiftUI/Internal/Splitter.cs @@ -0,0 +1,707 @@ +// 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-2008 Novell, Inc. (http://www.novell.com) +// +// Authors: +// Peter Dennis Bartok ([email protected]) +// Ivan N. Zlatev (contact i-nz.net) +// +// + +// COMPLETE + +#undef Debug + +using System; +using System.ComponentModel; +using System.Drawing; +using System.Reflection; +using System.Runtime.InteropServices; + +namespace ShiftUI { + [ComVisible (true)] + [ClassInterface (ClassInterfaceType.AutoDispatch)] + [DefaultEvent("SplitterMoved")] + [Designer("ShiftUI.Design.SplitterDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")] + [DefaultProperty("Dock")] + public class Splitter : Widget + { + #region Local Variables + static private Cursor splitter_ns; + static private Cursor splitter_we; + // XXX this "new" shouldn't be here. Widget shouldn't define border_style as internal. + new private BorderStyle border_style; + private int min_extra; + private int min_size; + private int max_size; + private int splitter_size; // Size (width or height) of our splitter control + private bool horizontal; // true if we've got a horizontal splitter + private Widget affected; // The control that the splitter resizes + private int split_requested; // If the user requests a position before we have ever laid out the doc + private int splitter_prev_move; + private Rectangle splitter_rectangle_moving; + private int moving_offset; + #endregion // Local Variables + + #region Constructors + static Splitter() { + splitter_ns = Cursors.HSplit; + splitter_we = Cursors.VSplit; + } + + public Splitter() { + + min_extra = 25; + min_size = 25; + split_requested = -1; + splitter_size = 3; + horizontal = false; + + SetStyle(Widgetstyles.Selectable, false); + Anchor = AnchorStyles.None; + Dock = DockStyle.Left; + + Layout += new LayoutEventHandler(LayoutSplitter); + this.ParentChanged += new EventHandler(ReparentSplitter); + Cursor = splitter_we; + } + #endregion // Constructors + + #region Public Instance Properties + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public override bool AllowDrop { + get { + return base.AllowDrop; + } + + set { + base.AllowDrop = value; + } + } + + [Browsable(false)] + [DefaultValue(AnchorStyles.None)] + [EditorBrowsable(EditorBrowsableState.Never)] + public override AnchorStyles Anchor { + get { + return AnchorStyles.None; + } + + set { + ; // MS doesn't set it + } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public override Image BackgroundImage { + get { + return base.BackgroundImage; + } + + set { + base.BackgroundImage = value; + } + } + + [Browsable (false)] + [EditorBrowsable (EditorBrowsableState.Never)] + public override ImageLayout BackgroundImageLayout { + get { return base.BackgroundImageLayout; } + set { base.BackgroundImageLayout = value; } + } + + [DispId(-504)] + [DefaultValue (BorderStyle.None)] + [MWFDescription("Sets the border style for the splitter")] + [MWFCategory("Appearance")] + public BorderStyle BorderStyle { + get { + return border_style; + } + + set { + border_style = value; + + switch(value) { + case BorderStyle.FixedSingle: + splitter_size = 4; // We don't get motion events for 1px wide windows on X11. sigh. + break; + + case BorderStyle.Fixed3D: + value = BorderStyle.None; + splitter_size = 3; + break; + + case BorderStyle.None: + splitter_size = 3; + break; + + default: + throw new InvalidEnumArgumentException (string.Format("Enum argument value '{0}' is not valid for BorderStyle", value)); + } + + base.InternalBorderStyle = value; + } + } + + [DefaultValue(DockStyle.Left)] + [Localizable(true)] + public override DockStyle Dock { + get { + return base.Dock; + } + + set { + if (!Enum.IsDefined (typeof (DockStyle), value) || (value == DockStyle.None) || (value == DockStyle.Fill)) { + throw new ArgumentException("Splitter must be docked left, top, bottom or right"); + } + + if ((value == DockStyle.Top) || (value == DockStyle.Bottom)) { + horizontal = true; + Cursor = splitter_ns; + } else { + horizontal = false; + Cursor = splitter_we; + } + base.Dock = value; + } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public override Font Font { + get { + return base.Font; + } + + set { + base.Font = value; + } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public override Color ForeColor { + get { + return base.ForeColor; + } + + set { + base.ForeColor = value; + } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new ImeMode ImeMode { + get { + return base.ImeMode; + } + + set { + base.ImeMode = value; + } + } + + [DefaultValue(25)] + [Localizable(true)] + [MWFDescription("Sets minimum size of undocked window")] + [MWFCategory("Behaviour")] + public int MinExtra { + get { + return min_extra; + } + + set { + min_extra = value; + } + } + + [DefaultValue(25)] + [Localizable(true)] + [MWFDescription("Sets minimum size of the resized control")] + [MWFCategory("Behaviour")] + public int MinSize { + get { + return min_size; + } + + set { + min_size = value; + } + } + + internal int MaxSize { + get { + if (this.Parent == null) + return 0; + + if (affected == null) + affected = AffectedControl; + + int widths = 0; + int heights = 0; + int vert_offset = 0; + int horiz_offset = 0; + foreach (Widget c in this.Parent.Widgets) { + if (c != affected) { + switch (c.Dock) { + case DockStyle.Left: + case DockStyle.Right: + widths += c.Width; + + if (c.Location.X < this.Location.X) + vert_offset += c.Width; + break; + case DockStyle.Top: + case DockStyle.Bottom: + heights += c.Height; + + if (c.Location.Y < this.Location.Y) + horiz_offset += c.Height; + break; + } + } + } + + if (horizontal) { + moving_offset = horiz_offset; + + return Parent.ClientSize.Height - heights - MinExtra; + } else { + moving_offset = vert_offset; + + return Parent.ClientSize.Width - widths - MinExtra; + } + } + } + + [Browsable(false)] + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + [MWFDescription("Current splitter position")] + [MWFCategory("Layout")] + public int SplitPosition { + get { + affected = AffectedControl; + if (affected == null) { + return -1; + } + + if (Capture) { + return CalculateSplitPosition(); + } + + if (horizontal) { + return affected.Height; + } else { + return affected.Width; + } + } + + set { + if (value > MaxSize) + value = MaxSize; + if (value < MinSize) + value = MinSize; + + affected = AffectedControl; + if (affected == null) + split_requested = value; + else { + if (horizontal) + affected.Height = value; + else + affected.Width = value; + OnSplitterMoved (new SplitterEventArgs (Left, Top, value, value)); + } + } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new bool TabStop { + get { return base.TabStop; } + set { base.TabStop = value; } + } + + [Bindable(false)] + [Browsable(false)] + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + [EditorBrowsable(EditorBrowsableState.Never)] + public override string Text { + get { + return base.Text; + } + + set { + base.Text = value; + } + } + + #endregion // Public Instance Properties + + #region Protected Instance Properties + protected override CreateParams CreateParams { + get { + return base.CreateParams; + } + } + + protected override Cursor DefaultCursor { + get { return base.DefaultCursor; } + } + + protected override ImeMode DefaultImeMode { + get { + return ImeMode.Disable; + } + } + + protected override Size DefaultSize { + get { + return new Size (3, 3); + } + } + #endregion // Protected Instance Properties + + #region Public Instance Methods + public override string ToString() { + return base.ToString () + String.Format(", MinExtra: {0}, MinSize: {1}", min_extra, min_size); + } + #endregion // Public Instance Methods + + #region Protected Instance Methods + protected override void OnKeyDown(KeyEventArgs e) { + base.OnKeyDown (e); + if (Capture && (e.KeyCode == Keys.Escape)) { + Capture = false; + SplitterEndMove (Point.Empty, true); + } + } + + protected override void OnMouseDown(MouseEventArgs e) { + base.OnMouseDown (e); + + // Only allow if we are set up properly + if (affected == null) + affected = AffectedControl; + max_size = MaxSize; + + if (affected == null || e.Button != MouseButtons.Left) + return; + + Capture = true; + SplitterBeginMove (Parent.PointToClient (PointToScreen (new Point (e.X, e.Y)))); + } + + protected override void OnMouseMove (MouseEventArgs e) + { + base.OnMouseMove (e); + + if (!Capture || e.Button != MouseButtons.Left || affected == null) + return; + + // We need our mouse coordinates relative to our parent + SplitterMove (Parent.PointToClient (PointToScreen (e.Location))); + } + + protected override void OnMouseUp (MouseEventArgs e) + { + base.OnMouseUp (e); + if (!Capture || e.Button != MouseButtons.Left || affected == null) + return; + + SplitterEndMove (Parent.PointToClient (PointToScreen (e.Location)), false); + Capture = false; + } + + private void SplitterBeginMove (Point location) + { + splitter_rectangle_moving = new Rectangle (Bounds.X, Bounds.Y, + Width, Height); + splitter_prev_move = horizontal ? location.Y : location.X; + } + + private void SplitterMove (Point location) + { + int currentMove = horizontal ? location.Y : location.X; + int delta = currentMove - splitter_prev_move; + Rectangle prev_location = splitter_rectangle_moving; + bool moved = false; + int min = this.MinSize + moving_offset; + int max = max_size + moving_offset; + + if (horizontal) { + if (splitter_rectangle_moving.Y + delta > min && splitter_rectangle_moving.Y + delta < max) { + splitter_rectangle_moving.Y += delta; + moved = true; + } else { + // Ensure that the splitter is set to minimum or maximum position, + // even if the mouse "skips". + // + if (splitter_rectangle_moving.Y + delta <= min && splitter_rectangle_moving.Y != min) { + splitter_rectangle_moving.Y = min; + moved = true; + } else if (splitter_rectangle_moving.Y + delta >= max && splitter_rectangle_moving.Y != max) { + splitter_rectangle_moving.Y = max; + moved = true; + } + } + } else { + if (splitter_rectangle_moving.X + delta > min && splitter_rectangle_moving.X + delta < max) { + splitter_rectangle_moving.X += delta; + moved = true; + } else { + // Ensure that the splitter is set to minimum or maximum position, + // even if the mouse "skips". + // + if (splitter_rectangle_moving.X + delta <= min && splitter_rectangle_moving.X != min) { + splitter_rectangle_moving.X = min; + moved = true; + } else if (splitter_rectangle_moving.X + delta >= max && splitter_rectangle_moving.X != max) { + splitter_rectangle_moving.X = max; + moved = true; + } + } + } + + if (moved) { + splitter_prev_move = currentMove; + OnSplitterMoving (new SplitterEventArgs (location.X, location.Y, + splitter_rectangle_moving.X, + splitter_rectangle_moving.Y)); + XplatUI.DrawReversibleRectangle (this.Parent.Handle, prev_location, 1); + XplatUI.DrawReversibleRectangle (this.Parent.Handle, splitter_rectangle_moving, 1); + } + } + + private void SplitterEndMove (Point location, bool cancel) + { + if (!cancel) { + // Resize the affected window + if (horizontal) + affected.Height = CalculateSplitPosition(); + else + affected.Width = CalculateSplitPosition(); + } + + this.Parent.Refresh (); // to clean up the drag handle artifacts from all Widgets + SplitterEventArgs args = new SplitterEventArgs (location.X, location.Y, + splitter_rectangle_moving.X, + splitter_rectangle_moving.Y); + OnSplitterMoved (args); + } + + protected virtual void OnSplitterMoved(SplitterEventArgs sevent) { + SplitterEventHandler eh = (SplitterEventHandler)(Events [SplitterMovedEvent]); + if (eh != null) + eh (this, sevent); + } + + protected virtual void OnSplitterMoving(SplitterEventArgs sevent) { + SplitterEventHandler eh = (SplitterEventHandler)(Events [SplitterMovingEvent]); + if (eh != null) + eh (this, sevent); + } + + protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified) { + // enforce our width / height + if (horizontal) { + splitter_size = height; + if (splitter_size < 1) { + splitter_size = 3; + } + base.SetBoundsCore (x, y, width, splitter_size, specified); + } else { + splitter_size = width; + if (splitter_size < 1) { + splitter_size = 3; + } + base.SetBoundsCore (x, y, splitter_size, height, specified); + } + } + #endregion // Protected Instance Methods + + #region Private Properties and Methods + private Widget AffectedControl { + get { + if (Parent == null) + return null; + + // Doc says the first control preceeding us in the zorder + for (int i = Parent.Widgets.GetChildIndex(this) + 1; i < Parent.Widgets.Count; i++) { + switch (Dock) { + case DockStyle.Top: + if (Top == Parent.Widgets[i].Bottom) + return Parent.Widgets[i]; + break; + case DockStyle.Bottom: + if (Bottom == Parent.Widgets[i].Top) + return Parent.Widgets[i]; + break; + case DockStyle.Left: + if (Left == Parent.Widgets[i].Right) + return Parent.Widgets[i]; + break; + case DockStyle.Right: + if (Right == Parent.Widgets[i].Left) + return Parent.Widgets[i]; + break; + } + } + return null; + } + } + + private int CalculateSplitPosition() { + if (horizontal) { + if (Dock == DockStyle.Top) + return splitter_rectangle_moving.Y - affected.Top; + else + return affected.Bottom - splitter_rectangle_moving.Y - splitter_size; + } else { + if (Dock == DockStyle.Left) + return splitter_rectangle_moving.X - affected.Left; + else + return affected.Right - splitter_rectangle_moving.X - splitter_size; + } + } + + internal override void OnPaintInternal (PaintEventArgs e) { + e.Graphics.FillRectangle(ThemeEngine.Current.ResPool.GetSolidBrush(this.BackColor), e.ClipRectangle); + } + + private void LayoutSplitter(object sender, LayoutEventArgs e) { + affected = AffectedControl; + if (split_requested != -1) { + SplitPosition = split_requested; + split_requested = -1; + } + } + + private void ReparentSplitter(object sender, EventArgs e) { + affected = null; + } + + #endregion // Private Properties and Methods + + #region Events + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler BackgroundImageChanged { + add { base.BackgroundImageChanged += value; } + remove { base.BackgroundImageChanged -= value; } + } + + [Browsable (false)] + [EditorBrowsable (EditorBrowsableState.Never)] + public new event EventHandler BackgroundImageLayoutChanged + { + add { base.BackgroundImageLayoutChanged += value; } + remove { base.BackgroundImageLayoutChanged -= value; } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler Enter { + add { base.Enter += value; } + remove { base.Enter -= value; } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler FontChanged { + add { base.FontChanged += value; } + remove { base.FontChanged -= value; } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler ForeColorChanged { + add { base.ForeColorChanged += value; } + remove { base.ForeColorChanged -= value; } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler ImeModeChanged { + add { base.ImeModeChanged += value; } + remove { base.ImeModeChanged -= value; } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event KeyEventHandler KeyDown { + add { base.KeyDown += value; } + remove { base.KeyDown -= value; } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event KeyPressEventHandler KeyPress { + add { base.KeyPress += value; } + remove { base.KeyPress -= value; } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event KeyEventHandler KeyUp { + add { base.KeyUp += value; } + remove { base.KeyUp -= value; } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler Leave { + add { base.Leave += value; } + remove { base.Leave -= value; } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler TabStopChanged { + add { base.TabStopChanged += value; } + remove { base.TabStopChanged -= value; } + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public new event EventHandler TextChanged { + add { base.TextChanged += value; } + remove { base.TextChanged -= value; } + } + + static object SplitterMovedEvent = new object (); + static object SplitterMovingEvent = new object (); + + public event SplitterEventHandler SplitterMoved { + add { Events.AddHandler (SplitterMovedEvent, value); } + remove { Events.RemoveHandler (SplitterMovedEvent, value); } + } + + public event SplitterEventHandler SplitterMoving { + add { Events.AddHandler (SplitterMovingEvent, value); } + remove { Events.RemoveHandler (SplitterMovingEvent, value); } + } + #endregion // Events + } +} diff --git a/source/ShiftUI/Internal/Structs.cs b/source/ShiftUI/Internal/Structs.cs new file mode 100644 index 0000000..087964d --- /dev/null +++ b/source/ShiftUI/Internal/Structs.cs @@ -0,0 +1,157 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton <[email protected]> +// + +using System; + +namespace ShiftUI.CarbonInternal { + internal struct CGSize { + public float width; + public float height; + + public CGSize (int w, int h) { + this.width = (float)w; + this.height = (float)h; + } + } + + internal struct QDPoint { + public short y; + public short x; + + public QDPoint (short x, short y) { + this.x = x; + this.y = y; + } + } + + internal struct CGPoint { + public float x; + public float y; + + public CGPoint (int x, int y) { + this.x = (float)x; + this.y = (float)y; + } + } + + internal struct HIRect { + public CGPoint origin; + public CGSize size; + + public HIRect (int x, int y, int w, int h) { + this.origin = new CGPoint (x, y); + this.size = new CGSize (w, h); + } + } + + internal struct HIViewID { + public uint type; + public uint id; + + public HIViewID (uint type, uint id) { + this.type = type; + this.id = id; + } + } + + internal struct EventTypeSpec { + public UInt32 eventClass; + public UInt32 eventKind; + + public EventTypeSpec (UInt32 eventClass, UInt32 eventKind) + { + this.eventClass = eventClass; + this.eventKind = eventKind; + } + } + + internal struct CarbonEvent { + public IntPtr hWnd; + public IntPtr evt; + + public CarbonEvent (IntPtr hWnd, IntPtr evt) + { + this.hWnd = hWnd; + this.evt = evt; + } + } + + internal struct RGBColor { + public short red; + public short green; + public short blue; + } + + internal struct Rect { + public short top; + public short left; + public short bottom; + public short right; + } + + internal struct Caret { + internal Timer Timer; + internal IntPtr Hwnd; + internal int X; + internal int Y; + internal int Width; + internal int Height; + internal int Visible; + internal bool On; + internal bool Paused; + } + + internal struct Hover { + internal Timer Timer; + internal IntPtr Hwnd; + internal int X; + internal int Y; + internal int Interval; + } + + internal struct CGAffineTransform { + internal float a; + internal float b; + internal float c; + internal float d; + internal float tx; + internal float ty; + } + + internal struct MouseTrackingRegionID { + public uint signature; + public uint id; + + public MouseTrackingRegionID (uint signature, uint id) { + this.signature = signature; + this.id = id; + } + } + + internal struct ProcessSerialNumber { + public ulong highLongOfPSN; + public ulong lowLongOfPSN; + } +} diff --git a/source/ShiftUI/Internal/SystemInformation.cs b/source/ShiftUI/Internal/SystemInformation.cs new file mode 100644 index 0000000..a27f039 --- /dev/null +++ b/source/ShiftUI/Internal/SystemInformation.cs @@ -0,0 +1,611 @@ +// 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) 2004,2006 Novell, Inc. (http://www.novell.com) +// +// Authors: +// Miguel de Icaza ([email protected]). +// Peter Bartok ([email protected]) +// + +// NOT COMPLETE + +using System; +using System.Drawing; +using System.ComponentModel; + +namespace ShiftUI +{ + public class SystemInformation + { + private SystemInformation () + { + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int ActiveWindowTrackingDelay { get { return XplatUI.ActiveWindowTrackingDelay; } } + + public static ArrangeDirection ArrangeDirection { + get { + return ThemeEngine.Current.ArrangeDirection; + } + } + + public static ArrangeStartingPosition ArrangeStartingPosition { + get { + return ThemeEngine.Current.ArrangeStartingPosition; + } + } + + public static BootMode BootMode { + get { + return BootMode.Normal; + } + } + + public static Size Border3DSize { + get { + return ThemeEngine.Current.Border3DSize; + } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int BorderMultiplierFactor { get { return ThemeEngine.Current.BorderMultiplierFactor; } } + + public static Size BorderSize { + get { + return ThemeEngine.Current.BorderSize; + } + } + + public static Size CaptionButtonSize { + get { + return ThemeEngine.Current.CaptionButtonSize; + } + } + + public static int CaptionHeight { + get { + return ThemeEngine.Current.CaptionHeight; + } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int CaretBlinkTime { get { return XplatUI.CaretBlinkTime; } } + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int CaretWidth { get { return XplatUI.CaretWidth; } } + + public static string ComputerName { + get { + return Environment.MachineName; + } + } + + public static Size CursorSize { + get { + return XplatUI.CursorSize; + } + } + + public static bool DbcsEnabled { + get { + return false; + } + } + + public static bool DebugOS { + get { + return false; + } + } + + public static Size DoubleClickSize { + get { + return ThemeEngine.Current.DoubleClickSize; + } + } + + public static int DoubleClickTime { + get { + return ThemeEngine.Current.DoubleClickTime; + } + } + + public static bool DragFullWindows { + get { + return XplatUI.DragFullWindows; + } + } + + public static Size DragSize { + get { + return XplatUI.DragSize; + } + } + + public static Size FixedFrameBorderSize { + get { + return ThemeEngine.Current.FixedFrameBorderSize; + } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int FontSmoothingContrast { get { return XplatUI.FontSmoothingContrast; } } + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int FontSmoothingType { get { return XplatUI.FontSmoothingType; } } + + public static Size FrameBorderSize { + get { + return ThemeEngine.Current.FrameBorderSize; + } + } + + public static bool HighContrast { + get { + return false; + } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int HorizontalFocusThickness { get { return ThemeEngine.Current.HorizontalFocusThickness; } } + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int HorizontalResizeBorderThickness { get { return XplatUI.HorizontalResizeBorderThickness; } } + + public static int HorizontalScrollBarArrowWidth { + get { + return ThemeEngine.Current.HorizontalScrollBarArrowWidth; + } + } + + public static int HorizontalScrollBarHeight { + get { + return ThemeEngine.Current.HorizontalScrollBarHeight; + } + } + + public static int HorizontalScrollBarThumbWidth { + get { + return ThemeEngine.Current.HorizontalScrollBarThumbWidth; + } + } + + public static Size IconSize { + get { + return XplatUI.IconSize; + } + } + + public static int IconHorizontalSpacing { + get { + return IconSpacingSize.Width; + } + } + + public static int IconVerticalSpacing { + get { + return IconSpacingSize.Height; + } + } + + public static Size IconSpacingSize { + get { + return ThemeEngine.Current.IconSpacingSize; + } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsActiveWindowTrackingEnabled { + get { return XplatUI.IsActiveWindowTrackingEnabled; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsComboBoxAnimationEnabled { + get { return XplatUI.IsComboBoxAnimationEnabled; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsDropShadowEnabled { + get { return XplatUI.IsDropShadowEnabled; } + } + + public static bool IsFlatMenuEnabled { + get { return false; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsFontSmoothingEnabled { + get { return XplatUI.IsFontSmoothingEnabled; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsHotTrackingEnabled { + get { return XplatUI.IsHotTrackingEnabled; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsIconTitleWrappingEnabled { + get { return XplatUI.IsIconTitleWrappingEnabled; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsKeyboardPreferred { + get { return XplatUI.IsKeyboardPreferred; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsListBoxSmoothScrollingEnabled { + get { return XplatUI.IsListBoxSmoothScrollingEnabled; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsMenuAnimationEnabled { + get { return XplatUI.IsMenuAnimationEnabled; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsMenuFadeEnabled { + get { return XplatUI.IsMenuFadeEnabled; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsMinimizeRestoreAnimationEnabled { + get { return XplatUI.IsMinimizeRestoreAnimationEnabled; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsSelectionFadeEnabled { + get { return XplatUI.IsSelectionFadeEnabled; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsSnapToDefaultEnabled { + get { return XplatUI.IsSnapToDefaultEnabled; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsTitleBarGradientEnabled { + get { return XplatUI.IsTitleBarGradientEnabled; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool IsToolTipAnimationEnabled { + get { return XplatUI.IsToolTipAnimationEnabled; } + } + + public static int KanjiWindowHeight { + get { + return 0; + } + } + + public static int KeyboardDelay { + get { + return XplatUI.KeyboardDelay; + } + } + + public static int KeyboardSpeed { + get { + return XplatUI.KeyboardSpeed; + } + } + + public static Size MaxWindowTrackSize { + get { + return XplatUI.MaxWindowTrackSize; + } + } + + public static bool MenuAccessKeysUnderlined { + get { + return ThemeEngine.Current.MenuAccessKeysUnderlined; + } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static Size MenuBarButtonSize { + get { return ThemeEngine.Current.MenuBarButtonSize; } + } + + public static Size MenuButtonSize { + get { + return ThemeEngine.Current.MenuButtonSize; + } + } + + public static Size MenuCheckSize { + get { + return ThemeEngine.Current.MenuCheckSize; + } + } + + public static Font MenuFont { + get { + // note: we MUST return a clone of the Font instance as anyone + // can dispose it. However we shouldn't expect the theme to do + // the cloning for performance reason + return (Font) ThemeEngine.Current.MenuFont.Clone (); + } + } + + public static int MenuHeight { + get { + return ThemeEngine.Current.MenuHeight; + } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int MenuShowDelay { get { return XplatUI.MenuShowDelay; } } + + public static bool MidEastEnabled { + get { + return false; // ??? how do we decide? + } + } + + public static Size MinimizedWindowSize { + get { + return XplatUI.MinimizedWindowSize; + } + } + + public static Size MinimizedWindowSpacingSize { + get { + return XplatUI.MinimizedWindowSpacingSize; + } + } + + public static Size MinimumWindowSize { + get { + return XplatUI.MinimumWindowSize; + } + } + + public static Size MinWindowTrackSize { + get { + return XplatUI.MinWindowTrackSize; + } + } + + public static int MonitorCount { + get { + return Screen.AllScreens.Length; + } + } + + public static bool MonitorsSameDisplayFormat { + get { + return true; + } + } + + public static int MouseButtons { + get { + return XplatUI.MouseButtonCount; + } + } + + public static bool MouseButtonsSwapped { + get { + return XplatUI.MouseButtonsSwapped; + } + } + + public static Size MouseHoverSize { + get { + return XplatUI.MouseHoverSize; + } + } + + public static int MouseHoverTime { + get { + return XplatUI.MouseHoverTime; + } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int MouseSpeed { + get { return XplatUI.MouseSpeed; } + } + + public static int MouseWheelScrollDelta { + get { + return XplatUI.MouseWheelScrollDelta; + } + } + + //[EditorBrowsable (EditorBrowsableState.Never)] + public static bool MousePresent { + get { + return true; + } + } + + public static bool MouseWheelPresent { + get { + return XplatUI.MouseWheelPresent; + } + } + + public static int MouseWheelScrollLines { + get { + return ThemeEngine.Current.MouseWheelScrollLines; + } + } + + public static bool NativeMouseWheelSupport { + get { + return MouseWheelPresent; + } + } + + public static bool Network { + get { + return true; + } + } + + public static bool PenWindows { + get { + return false; + } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static LeftRightAlignment PopupMenuAlignment { + get { return XplatUI.PopupMenuAlignment; } + } + + [MonoTODO ("Only implemented for Win32.")] + public static PowerStatus PowerStatus { + get { return XplatUI.PowerStatus; } + } + + public static Size PrimaryMonitorMaximizedWindowSize { + get { + var workingArea = Screen.PrimaryScreen.WorkingArea; + return new Size (workingArea.Width, workingArea.Height); + } + } + + public static Size PrimaryMonitorSize { + get { + var bounds = Screen.PrimaryScreen.Bounds; + return new Size (bounds.Width, bounds.Height); + } + } + + public static bool RightAlignedMenus { + get { + return ThemeEngine.Current.RightAlignedMenus; + } + } + + public static ScreenOrientation ScreenOrientation { + get { return ScreenOrientation.Angle0; } + } + + public static bool Secure { + get { + return true; + } + } + + public static bool ShowSounds { + get { + return false; + } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int SizingBorderWidth { + get { return XplatUI.SizingBorderWidth; } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static Size SmallCaptionButtonSize { + get { return XplatUI.SmallCaptionButtonSize; } + } + + public static Size SmallIconSize { + get { + return XplatUI.SmallIconSize; + } + } + + public static bool TerminalServerSession { + get { + return false; + } + } + + public static Size ToolWindowCaptionButtonSize { + get { + return ThemeEngine.Current.ToolWindowCaptionButtonSize; + } + } + + public static int ToolWindowCaptionHeight { + get { + return ThemeEngine.Current.ToolWindowCaptionHeight; + } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static bool UIEffectsEnabled { + get { return XplatUI.UIEffectsEnabled; } + } + + public static string UserDomainName { + get { + return Environment.UserDomainName; + } + } + + public static bool UserInteractive { + get { + return Environment.UserInteractive; + } + } + + public static string UserName { + get { + return Environment.UserName; + } + } + + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int VerticalFocusThickness { get { return ThemeEngine.Current.VerticalFocusThickness; } } + [MonoInternalNote ("Determine if we need an X11 implementation or if defaults are good.")] + public static int VerticalResizeBorderThickness { get { return XplatUI.VerticalResizeBorderThickness; } } + + public static int VerticalScrollBarArrowHeight { + get { + return ThemeEngine.Current.VerticalScrollBarArrowHeight; + } + } + + public static int VerticalScrollBarThumbHeight { + get { + return ThemeEngine.Current.VerticalScrollBarThumbHeight; + } + } + + public static int VerticalScrollBarWidth { + get { + return ThemeEngine.Current.VerticalScrollBarWidth; + } + } + + public static Rectangle VirtualScreen { + get { + var rect = new Rectangle (); + foreach (var screen in Screen.AllScreens) + rect = Rectangle.Union (rect, screen.Bounds); + return rect; + } + } + + public static Rectangle WorkingArea { + get { + return Screen.PrimaryScreen.WorkingArea; + } + } + } +} diff --git a/source/ShiftUI/Internal/SystemParameter.cs b/source/ShiftUI/Internal/SystemParameter.cs new file mode 100644 index 0000000..fd4f7c1 --- /dev/null +++ b/source/ShiftUI/Internal/SystemParameter.cs @@ -0,0 +1,49 @@ +// +// SystemParameter.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + + +using System.Runtime.InteropServices; + +namespace ShiftUI +{ + [ComVisible(true)] + public enum SystemParameter + { + DropShadow = 0, + FlatMenu = 1, + FontSmoothingContrastMetric = 2, + FontSmoothingTypeMetric = 3, + MenuFadeEnabled = 4, + SelectionFade = 5, + ToolTipAnimationMetric = 6, + UIEffects = 7, + CaretWidthMetric = 8, + VerticalFocusThicknessMetric = 9, + HorizontalFocusThicknessMetric = 10 + } +} diff --git a/source/ShiftUI/Internal/TableLayout.cs b/source/ShiftUI/Internal/TableLayout.cs new file mode 100644 index 0000000..f32ca96 --- /dev/null +++ b/source/ShiftUI/Internal/TableLayout.cs @@ -0,0 +1,603 @@ +// +// TableLayout.cs +// +// 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) 2006 Jonathan Pobst +// +// Authors: +// Jonathan Pobst ([email protected]) +// + + +#undef TABLE_DEBUG + +using System; +using System.Drawing; + +namespace ShiftUI.Layout +{ + internal class TableLayout : LayoutEngine + { + private static Widget dummy_Widget = new Widget ("Dummy"); // Used as a placeholder for row/col spans + + public TableLayout () : base () + { + } + + public override void InitLayout (object child, BoundsSpecified specified) + { + base.InitLayout (child, specified); + } + + // There are 3 steps to doing a table layout: + // 1) Figure out which row/column each Widget goes into + // 2) Figure out the sizes of each row/column + // 3) Size and position each Widget + public override bool Layout (object container, LayoutEventArgs args) + { + TableLayoutPanel panel = container as TableLayoutPanel; + TableLayoutSettings settings = panel.LayoutSettings; + +#if TABLE_DEBUG + Console.WriteLine ("Beginning layout on panel: {0}, Widget count: {1}, col/row count: {2}x{3}", panel.Name, panel.Widgets.Count, settings.ColumnCount, settings.RowCount); +#endif + + // STEP 1: + // - Figure out which row/column each Widget goes into + // - Store data in the TableLayoutPanel.actual_positions + panel.actual_positions = CalculateWidgetPositions (panel, Math.Max (settings.ColumnCount, 1), Math.Max (settings.RowCount, 1)); + + // STEP 2: + // - Figure out the sizes of each row/column + // - Store data in the TableLayoutPanel.widths/heights + CalculateColumnRowSizes (panel, panel.actual_positions.GetLength (0), panel.actual_positions.GetLength (1)); + + // STEP 3: + // - Size and position each Widget + LayoutWidgets(panel); + +#if TABLE_DEBUG + Console.WriteLine ("-- CalculatedPositions:"); + OutputWidgetGrid (panel.actual_positions, panel); + + Console.WriteLine ("Finished layout on panel: {0}", panel.Name); + Console.WriteLine (); +#endif + + return false; + } + + internal Widget[,] CalculateWidgetPositions (TableLayoutPanel panel, int columns, int rows) + { + Widget[,] grid = new Widget[columns, rows]; + + TableLayoutSettings settings = panel.LayoutSettings; + + // First place all Widgets that have an explicit col/row + foreach (Widget c in panel.Widgets) { + int col = settings.GetColumn (c); + int row = settings.GetRow (c); + if (col >= 0 && row >= 0) { + if (col >= columns) + return CalculateWidgetPositions (panel, col + 1, rows); + if (row >= rows) + return CalculateWidgetPositions (panel, columns, row + 1); + + if (grid[col, row] == null) { + int col_span = Math.Min (settings.GetColumnSpan (c), columns); + int row_span = Math.Min (settings.GetRowSpan (c), rows); + + if (col + col_span > columns) { + if (row + 1 < rows) { + grid[col, row] = dummy_Widget; + row++; + col = 0; + } + else if (settings.GrowStyle == TableLayoutPanelGrowStyle.AddColumns) + return CalculateWidgetPositions (panel, columns + 1, rows); + else + throw new ArgumentException (); + } + + if (row + row_span > rows) { + if (settings.GrowStyle == TableLayoutPanelGrowStyle.AddRows) + return CalculateWidgetPositions (panel, columns, rows + 1); + else + throw new ArgumentException (); + } + + grid[col, row] = c; + + // Fill in the rest of this Widget's row/column extent with dummy + // Widgets, so that other Widgets don't get put there. + for (int i = 0; i < col_span; i++) + for (int j = 0; j < row_span; j++) + if (i != 0 || j != 0) + grid[col + i, row + j] = dummy_Widget; + } + } + } + + int x_pointer = 0; + int y_pointer = 0; + + // Fill in gaps with Widgets that do not have an explicit col/row + foreach (Widget c in panel.Widgets) { + int col = settings.GetColumn (c); + int row = settings.GetRow (c); + + if ((col >= 0 && col < columns) && (row >= 0 && row < rows) && (grid[col, row] == c || grid[col, row] == dummy_Widget)) + continue; + + for (int y = y_pointer; y < rows; y++) { + y_pointer = y; + x_pointer = 0; + + for (int x = x_pointer; x < columns; x++) { + x_pointer = x; + + if (grid[x, y] == null) { + int col_span = Math.Min (settings.GetColumnSpan (c), columns); + int row_span = Math.Min (settings.GetRowSpan (c), rows); + + if (x + col_span > columns) { + if (y + 1 < rows) + break; + else if (settings.GrowStyle == TableLayoutPanelGrowStyle.AddColumns) + return CalculateWidgetPositions (panel, columns + 1, rows); + else + throw new ArgumentException (); + } + + if (y + row_span > rows) { + if (x + 1 < columns) + break; + else if (settings.GrowStyle == TableLayoutPanelGrowStyle.AddRows) + return CalculateWidgetPositions (panel, columns, rows + 1); + else + throw new ArgumentException (); + } + + grid[x, y] = c; + + // Fill in the rest of this Widget's row/column extent with dummy + // Widgets, so that other Widgets don't get put there. + for (int i = 0; i < col_span; i++) + for (int j = 0; j < row_span; j++) + if (i != 0 || j != 0) + grid[x + i, y + j] = dummy_Widget; + + // I know someone will kill me for using a goto, but + // sometimes they really are the easiest way... + goto Found; + } else { + // MS adds the Widgets only to the first row if + // GrowStyle is AddColumns and RowCount is 0, + // so interrupt the search for a free horizontal cell + // beyond the first one in the given vertical + if (settings.GrowStyle == TableLayoutPanelGrowStyle.AddColumns && + settings.RowCount == 0) + break; + } + } + } + + // MS adds rows instead of columns even when GrowStyle is AddColumns, + // but RowCount is 0. + TableLayoutPanelGrowStyle adjustedGrowStyle = settings.GrowStyle; + if (settings.GrowStyle == TableLayoutPanelGrowStyle.AddColumns) { + if (settings.RowCount == 0) + adjustedGrowStyle = TableLayoutPanelGrowStyle.AddRows; + } + + switch (adjustedGrowStyle) { + case TableLayoutPanelGrowStyle.AddColumns: + return CalculateWidgetPositions (panel, columns + 1, rows); + case TableLayoutPanelGrowStyle.AddRows: + default: + return CalculateWidgetPositions (panel, columns, rows + 1); + case TableLayoutPanelGrowStyle.FixedSize: + throw new ArgumentException (); + } + + Found: ; + } + + return grid; + } + + private void CalculateColumnRowSizes (TableLayoutPanel panel, int columns, int rows) + { + TableLayoutSettings settings = panel.LayoutSettings; + + panel.column_widths = new int[panel.actual_positions.GetLength (0)]; + panel.row_heights = new int[panel.actual_positions.GetLength (1)]; + + int border_width = TableLayoutPanel.GetCellBorderWidth (panel.CellBorderStyle); + + Rectangle parentDisplayRectangle = panel.DisplayRectangle; + + TableLayoutColumnStyleCollection col_styles = new TableLayoutColumnStyleCollection (panel); + + foreach (ColumnStyle cs in settings.ColumnStyles) + col_styles.Add( new ColumnStyle(cs.SizeType, cs.Width)); + + TableLayoutRowStyleCollection row_styles = new TableLayoutRowStyleCollection (panel); + + foreach (RowStyle rs in settings.RowStyles) + row_styles.Add (new RowStyle (rs.SizeType, rs.Height)); + + // If we have more columns than columnstyles, temporarily add enough columnstyles + if (columns > col_styles.Count) + { + for (int i = col_styles.Count; i < columns; i++) + col_styles.Add(new ColumnStyle()); + } + + // Same for rows.. + if (rows > row_styles.Count) + { + for (int i = row_styles.Count; i < rows; i++) + row_styles.Add (new RowStyle ()); + } + + while (row_styles.Count > rows) + row_styles.RemoveAt (row_styles.Count - 1); + while (col_styles.Count > columns) + col_styles.RemoveAt (col_styles.Count - 1); + + // Find the largest column-span/row-span values. + int max_colspan = 0, max_rowspan = 0; + foreach (Widget c in panel.Widgets) { + max_colspan = Math.Max (max_colspan, settings.GetColumnSpan (c)); + max_rowspan = Math.Max (max_rowspan, settings.GetRowSpan (c)); + } + + // Figure up all the column widths + int total_width = parentDisplayRectangle.Width - (border_width * (columns + 1)); + int index = 0; + + // First assign all the Absolute sized columns.. + foreach (ColumnStyle cs in col_styles) { + if (cs.SizeType == SizeType.Absolute) { + panel.column_widths[index] = (int)cs.Width; + total_width -= (int)cs.Width; + } + + index++; + } + + // Next, assign all the AutoSize columns to the width of their widest + // Widget. If the table-layout is auto-sized, then make sure that + // no column with Percent styling clips its contents. + // (per http://msdn.microsoft.com/en-us/library/ms171690.aspx) + for (int colspan = 0; colspan < max_colspan; ++colspan) + { + for (index = colspan; index < col_styles.Count - colspan; ++index) + { + ColumnStyle cs = col_styles[index]; + if (cs.SizeType == SizeType.AutoSize + || (panel.AutoSize && cs.SizeType == SizeType.Percent)) + { + int max_width = panel.column_widths[index]; + + // Find the widest Widget in the column + for (int i = 0; i < rows; i ++) + { + Widget c = panel.actual_positions[index - colspan, i]; + + if (c != null && c != dummy_Widget && c.VisibleInternal) + { + // Skip any Widgets not being sized in this pass. + if (settings.GetColumnSpan (c) != colspan + 1) + continue; + + // Calculate the maximum Widget width. + if (c.AutoSize) + max_width = Math.Max (max_width, c.PreferredSize.Width + c.Margin.Horizontal); + else + max_width = Math.Max (max_width, c.ExplicitBounds.Width + c.Margin.Horizontal); + max_width = Math.Max (max_width, c.Width + c.Margin.Left + c.Margin.Right); + } + } + + // Subtract the width of prior columns, if any. + for (int i = Math.Max (index - colspan, 0); i < index; ++i) + max_width -= panel.column_widths[i]; + + // If necessary, increase this column's width. + if (max_width > panel.column_widths[index]) + { + max_width -= panel.column_widths[index]; + panel.column_widths[index] += max_width; + total_width -= max_width; + } + } + } + } + + index = 0; + float total_percent = 0; + + // Finally, assign the remaining space to Percent columns, if any. + if (total_width > 0) + { + int percent_width = total_width; + + // Find the total percent (not always 100%) + foreach (ColumnStyle cs in col_styles) + { + if (cs.SizeType == SizeType.Percent) + total_percent += cs.Width; + } + + // Divvy up the space.. + foreach (ColumnStyle cs in col_styles) + { + if (cs.SizeType == SizeType.Percent) + { + int width_change = (int)(((cs.Width / total_percent) * percent_width) + - panel.column_widths[index]); + if (width_change > 0) + { + panel.column_widths[index] += width_change; + total_width -= width_change; + } + } + + index++; + } + } + + if (total_width > 0) + { + // Find the last column that isn't an Absolute SizeType, and give it + // all this free space. (Absolute sized columns need to retain their + // absolute width if at all possible!) + int col = col_styles.Count - 1; + for (; col >= 0; --col) + { + if (col_styles[col].SizeType != SizeType.Absolute) + break; + } + if (col < 0) + col = col_styles.Count - 1; + panel.column_widths[col] += total_width; + } + + // Figure up all the row heights + int total_height = parentDisplayRectangle.Height - (border_width * (rows + 1)); + index = 0; + + // First assign all the Absolute sized rows.. + foreach (RowStyle rs in row_styles) { + if (rs.SizeType == SizeType.Absolute) { + panel.row_heights[index] = (int)rs.Height; + total_height -= (int)rs.Height; + } + + index++; + } + + index = 0; + + // Next, assign all the AutoSize rows to the height of their tallest + // Widget. If the table-layout is auto-sized, then make sure that + // no row with Percent styling clips its contents. + // (per http://msdn.microsoft.com/en-us/library/ms171690.aspx) + for (int rowspan = 0; rowspan < max_rowspan; ++rowspan) + { + for (index = rowspan; index < row_styles.Count - rowspan; ++index) + { + RowStyle rs = row_styles[index]; + if (rs.SizeType == SizeType.AutoSize + || (panel.AutoSize && rs.SizeType == SizeType.Percent)) + { + int max_height = panel.row_heights[index]; + + // Find the tallest Widget in the row + for (int i = 0; i < columns; i++) { + Widget c = panel.actual_positions[i, index - rowspan]; + + if (c != null && c != dummy_Widget && c.VisibleInternal) + { + // Skip any Widgets not being sized in this pass. + if (settings.GetRowSpan (c) != rowspan + 1) + continue; + + // Calculate the maximum Widget height. + if (c.AutoSize) + max_height = Math.Max (max_height, c.PreferredSize.Height + c.Margin.Vertical); + else + max_height = Math.Max (max_height, c.ExplicitBounds.Height + c.Margin.Vertical); + max_height = Math.Max (max_height, c.Height + c.Margin.Top + c.Margin.Bottom); + } + } + + // Subtract the height of prior rows, if any. + for (int i = Math.Max (index - rowspan, 0); i < index; ++i) + max_height -= panel.row_heights[i]; + + // If necessary, increase this row's height. + if (max_height > panel.row_heights[index]) + { + max_height -= panel.row_heights[index]; + panel.row_heights[index] += max_height; + total_height -= max_height; + } + } + } + } + + index = 0; + total_percent = 0; + + // Finally, assign the remaining space to Percent rows, if any. + if (total_height > 0) { + int percent_height = total_height; + + // Find the total percent (not always 100%) + foreach (RowStyle rs in row_styles) { + if (rs.SizeType == SizeType.Percent) + total_percent += rs.Height; + } + + // Divvy up the space.. + foreach (RowStyle rs in row_styles) { + if (rs.SizeType == SizeType.Percent) { + int height_change = (int)(((rs.Height / total_percent) * percent_height) + - panel.row_heights[index]); + if (height_change > 0) + { + panel.row_heights[index] += height_change; + total_height -= height_change; + } + } + + index++; + } + } + + if (total_height > 0) + { + // Find the last row that isn't an Absolute SizeType, and give it + // all this free space. (Absolute sized rows need to retain their + // absolute height if at all possible!) + int row = row_styles.Count - 1; + for (; row >= 0; --row) + { + if (row_styles[row].SizeType != SizeType.Absolute) + break; + } + if (row < 0) + row = row_styles.Count - 1; + panel.row_heights[row] += total_height; + } + } + + private void LayoutWidgets (TableLayoutPanel panel) + { + TableLayoutSettings settings = panel.LayoutSettings; + + int border_width = TableLayoutPanel.GetCellBorderWidth (panel.CellBorderStyle); + + int columns = panel.actual_positions.GetLength(0); + int rows = panel.actual_positions.GetLength(1); + + Point current_pos = new Point (panel.DisplayRectangle.Left + border_width, panel.DisplayRectangle.Top + border_width); + + for (int y = 0; y < rows; y++) + { + for (int x = 0; x < columns; x++) + { + Widget c = panel.actual_positions[x,y]; + + if(c != null && c != dummy_Widget) { + Size preferred; + + if (c.AutoSize) + preferred = c.PreferredSize; + else + preferred = c.ExplicitBounds.Size; + + int new_x = 0; + int new_y = 0; + int new_width = 0; + int new_height = 0; + + // Figure out the width of the Widget + int column_width = panel.column_widths[x]; + + for (int i = 1; i < Math.Min (settings.GetColumnSpan(c), panel.column_widths.Length); i++) + column_width += panel.column_widths[x + i]; + + if (c.Dock == DockStyle.Fill || c.Dock == DockStyle.Top || c.Dock == DockStyle.Bottom || ((c.Anchor & AnchorStyles.Left) == AnchorStyles.Left && (c.Anchor & AnchorStyles.Right) == AnchorStyles.Right)) + new_width = column_width - c.Margin.Left - c.Margin.Right; + else + new_width = Math.Min (preferred.Width, column_width - c.Margin.Left - c.Margin.Right); + + // Figure out the height of the Widget + int column_height = panel.row_heights[y]; + + for (int i = 1; i < Math.Min (settings.GetRowSpan (c), panel.row_heights.Length); i++) + column_height += panel.row_heights[y + i]; + + if (c.Dock == DockStyle.Fill || c.Dock == DockStyle.Left || c.Dock == DockStyle.Right || ((c.Anchor & AnchorStyles.Top) == AnchorStyles.Top && (c.Anchor & AnchorStyles.Bottom) == AnchorStyles.Bottom)) + new_height = column_height - c.Margin.Top - c.Margin.Bottom; + else + new_height = Math.Min (preferred.Height, column_height - c.Margin.Top - c.Margin.Bottom); + + // Figure out the left location of the Widget + if (c.Dock == DockStyle.Left || c.Dock == DockStyle.Fill || (c.Anchor & AnchorStyles.Left) == AnchorStyles.Left) + new_x = current_pos.X + c.Margin.Left; + else if (c.Dock == DockStyle.Right || (c.Anchor & AnchorStyles.Right) == AnchorStyles.Right) + new_x = (current_pos.X + column_width) - new_width - c.Margin.Right; + else // (center Widget) + new_x = (current_pos.X + (column_width - c.Margin.Left - c.Margin.Right) / 2) + c.Margin.Left - (new_width / 2); + + // Figure out the top location of the Widget + if (c.Dock == DockStyle.Top || c.Dock == DockStyle.Fill || (c.Anchor & AnchorStyles.Top) == AnchorStyles.Top) + new_y = current_pos.Y + c.Margin.Top; + else if (c.Dock == DockStyle.Bottom || (c.Anchor & AnchorStyles.Bottom) == AnchorStyles.Bottom) + new_y = (current_pos.Y + column_height) - new_height - c.Margin.Bottom; + else // (center Widget) + new_y = (current_pos.Y + (column_height - c.Margin.Top - c.Margin.Bottom) / 2) + c.Margin.Top - (new_height / 2); + + c.SetBoundsInternal (new_x, new_y, new_width, new_height, BoundsSpecified.None); + } + + current_pos.Offset (panel.column_widths[x] + border_width, 0); + } + + current_pos.Offset ((-1 * current_pos.X) + border_width + panel.DisplayRectangle.Left, panel.row_heights[y] + border_width); + } + } + +#if TABLE_DEBUG + private void OutputWidgetGrid (Widget[,] grid, TableLayoutPanel panel) + { + Console.WriteLine (" Size: {0}x{1}", grid.GetLength (0), grid.GetLength (1)); + + Console.Write (" "); + + foreach (int i in panel.column_widths) + Console.Write (" {0}px ", i.ToString ().PadLeft (3)); + + Console.WriteLine (); + + for (int y = 0; y < grid.GetLength (1); y++) { + Console.Write (" {0}px |", panel.row_heights[y].ToString ().PadLeft (3)); + + for (int x = 0; x < grid.GetLength (0); x++) { + if (grid[x, y] == null) + Console.Write (" --- |"); + else if (string.IsNullOrEmpty (grid[x, y].Name)) + Console.Write (" ??? |"); + else + Console.Write (" {0} |", grid[x, y].Name.PadRight (5).Substring (0, 5)); + } + + Console.WriteLine (); + } + } +#endif + } +} diff --git a/source/ShiftUI/Internal/TableLayoutSettings.cs b/source/ShiftUI/Internal/TableLayoutSettings.cs new file mode 100644 index 0000000..786a98b --- /dev/null +++ b/source/ShiftUI/Internal/TableLayoutSettings.cs @@ -0,0 +1,362 @@ +// +// TableLayoutSettings.cs +// +// 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) 2006 Jonathan Pobst +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +using System; +using System.ComponentModel; +using System.Collections.Generic; +using ShiftUI.Layout; +using System.Runtime.Serialization; + +namespace ShiftUI +{ + [Serializable] + [TypeConverter (typeof (TableLayoutSettingsTypeConverter))] + public sealed class TableLayoutSettings : LayoutSettings, ISerializable + { + private TableLayoutColumnStyleCollection column_styles; + private TableLayoutRowStyleCollection row_styles; + private TableLayoutPanelGrowStyle grow_style; + private int column_count; + private int row_count; + private Dictionary<Object, int> columns; + private Dictionary<Object, int> column_spans; + private Dictionary<Object, int> rows; + private Dictionary<Object, int> row_spans; + internal TableLayoutPanel panel; + internal bool isSerialized; + + #region Internal Constructor + internal TableLayoutSettings (TableLayoutPanel panel) + { + this.column_styles = new TableLayoutColumnStyleCollection (panel); + this.row_styles = new TableLayoutRowStyleCollection (panel); + this.grow_style = TableLayoutPanelGrowStyle.AddRows; + this.column_count = 0; + this.row_count = 0; + this.columns = new Dictionary<object, int> (); + this.column_spans = new Dictionary<object, int> (); + this.rows = new Dictionary<object, int> (); + this.row_spans = new Dictionary<object, int> (); + this.panel = panel; + } + + private TableLayoutSettings (SerializationInfo serializationInfo, StreamingContext context) + { + TypeConverter converter = TypeDescriptor.GetConverter (this); + string text = serializationInfo.GetString ("SerializedString"); + if (!string.IsNullOrEmpty (text) && (converter != null)) { + TableLayoutSettings settings = converter.ConvertFromInvariantString (text) as TableLayoutSettings; + this.column_styles = settings.column_styles; + this.row_styles = settings.row_styles; + this.grow_style = settings.grow_style; + this.column_count = settings.column_count; + this.row_count = settings.row_count; + this.columns = settings.columns; + this.column_spans = settings.column_spans; + this.rows = settings.rows; + this.row_spans = settings.row_spans; + this.panel = settings.panel; + this.isSerialized = true; + } + } + #endregion + + #region Public Properties + [DefaultValue (0)] + public int ColumnCount { + get { return this.column_count; } + set { + if (value < 0) + throw new ArgumentOutOfRangeException(); + + if (column_count != value) { + column_count = value; + if (panel != null) + panel.PerformLayout (panel, "ColumnCount"); + } + } + } + + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)] + public TableLayoutColumnStyleCollection ColumnStyles { + get { return this.column_styles; } + } + + [DefaultValue (TableLayoutPanelGrowStyle.AddRows)] + public TableLayoutPanelGrowStyle GrowStyle { + get { return this.grow_style; } + set { + if (!Enum.IsDefined (typeof(TableLayoutPanelGrowStyle), value)) + throw new ArgumentException(); + + if (grow_style != value) { + grow_style = value; + if (panel != null) + panel.PerformLayout (panel, "GrowStyle"); + } + } + } + + public override LayoutEngine LayoutEngine { + get { + if (panel != null) + return panel.LayoutEngine; + return base.LayoutEngine; + } + } + + [DefaultValue (0)] + public int RowCount { + get { return this.row_count; } + set { + if (value < 0) + throw new ArgumentOutOfRangeException (); + + if (row_count != value) { + row_count = value; + + if (panel != null) + panel.PerformLayout (); + } + } + } + + //[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)] + public TableLayoutRowStyleCollection RowStyles { + get { return row_styles; } + } + #endregion + + #region Public Methods + [DefaultValue (-1)] + public TableLayoutPanelCellPosition GetCellPosition (Object control) + { + if (control == null) + throw new ArgumentNullException (); + + int column; + int row; + + if (!columns.TryGetValue (control, out column)) + { + if (!(control is Widget) || !columns.TryGetValue ((control as Widget).Name, out column)) + column = -1; + } + if (!rows.TryGetValue (control, out row)) + { + if (!(control is Widget) || !rows.TryGetValue ((control as Widget), out row)) + row = -1; + } + + return new TableLayoutPanelCellPosition (column, row); + } + + [DefaultValue (-1)] + public int GetColumn (Object control) + { + if (control == null) + throw new ArgumentNullException (); + + int retval; + + if (columns.TryGetValue (control, out retval)) + return retval; + if ((control is Widget) && columns.TryGetValue ((control as Widget).Name, out retval)) + return retval; + + return -1; + } + + public int GetColumnSpan (Object control) + { + if (control == null) + throw new ArgumentNullException (); + + int retval; + + if (column_spans.TryGetValue (control, out retval)) + return retval; + if ((control is Widget) && column_spans.TryGetValue ((control as Widget).Name, out retval)) + return retval; + + return 1; + } + + [DefaultValue (-1)] + public int GetRow (Object control) + { + if (control == null) + throw new ArgumentNullException (); + + int retval; + + if (rows.TryGetValue (control, out retval)) + return retval; + if ((control is Widget) && rows.TryGetValue ((control as Widget).Name, out retval)) + return retval; + + return -1; + } + + public int GetRowSpan (Object control) + { + if (control == null) + throw new ArgumentNullException (); + + int retval; + + if (row_spans.TryGetValue (control, out retval)) + return retval; + if ((control is Widget) && row_spans.TryGetValue ((control as Widget).Name, out retval)) + return retval; + + return 1; + } + + [DefaultValue (-1)] + public void SetCellPosition (Object control, TableLayoutPanelCellPosition cellPosition) + { + if (control == null) + throw new ArgumentNullException (); + + columns[control] = cellPosition.Column; + rows[control] = cellPosition.Row; + + if (panel != null) + panel.PerformLayout (); + } + + public void SetColumn (Object control, int column) + { + if (control == null) + throw new ArgumentNullException (); + if (column < -1) + throw new ArgumentException (); + + columns[control] = column; + + if (panel != null) + panel.PerformLayout (); + } + + public void SetColumnSpan (Object control, int value) + { + if (control == null) + throw new ArgumentNullException (); + if (value < -1) + throw new ArgumentException (); + + column_spans[control] = value; + + if (panel != null) + panel.PerformLayout (); + } + + public void SetRow (Object control, int row) + { + if (control == null) + throw new ArgumentNullException (); + if (row < -1) + throw new ArgumentException (); + + rows[control] = row; + + if (panel != null) + panel.PerformLayout (); + } + + public void SetRowSpan (Object control, int value) + { + if (control == null) + throw new ArgumentNullException (); + if (value < -1) + throw new ArgumentException (); + + row_spans[control] = value; + + if (panel != null) + panel.PerformLayout (); + } + #endregion + + #region Internal Methods + internal List<WidgetInfo> GetWidgets () + { + List<WidgetInfo> list = new List<WidgetInfo>(); + foreach (KeyValuePair <object, int> control in columns) { + WidgetInfo info = new WidgetInfo(); + info.Widget = control.Key; + info.Col = GetColumn(control.Key); + info.ColSpan = GetColumnSpan (control.Key); + info.Row = GetRow (control.Key); + info.RowSpan = GetRowSpan (control.Key); + list.Add (info); + } + return list; + } + + #endregion + + #region ISerializable Members + void ISerializable.GetObjectData (SerializationInfo si, StreamingContext context) + { + TableLayoutSettingsTypeConverter conv = new TableLayoutSettingsTypeConverter (); + string text = conv.ConvertToInvariantString (this); + si.AddValue ("SerializedString", text); + } + #endregion + + internal class StyleConverter : TypeConverter + { + public override object ConvertFrom (ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) + { + if ((value == null) || !(value is String)) + return base.ConvertFrom (context, culture, value); + + return Enum.Parse (typeof (StyleConverter), (string)value, true); + } + + public override object ConvertTo (ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) + { + if ((value == null) || !(value is StyleConverter) || (destinationType != typeof (string))) + return base.ConvertTo (context, culture, value, destinationType); + + return ((StyleConverter)value).ToString (); + } + } + } + + internal struct WidgetInfo + { + public object Widget; + public int Row; + public int RowSpan; + public int Col; + public int ColSpan; + } +} diff --git a/source/ShiftUI/Internal/TableLayoutSettingsTypeConverter.cs b/source/ShiftUI/Internal/TableLayoutSettingsTypeConverter.cs new file mode 100644 index 0000000..d9396b9 --- /dev/null +++ b/source/ShiftUI/Internal/TableLayoutSettingsTypeConverter.cs @@ -0,0 +1,233 @@ +// 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) 2006 Novell, Inc. +// + + +using System; +using System.ComponentModel; +using System.Drawing; +using System.Globalization; +using System.Xml; +using System.IO; +using System.Collections.Generic; + +namespace ShiftUI.Layout +{ + public class TableLayoutSettingsTypeConverter : TypeConverter + { + public override bool CanConvertTo (ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof (string)) + return true; + + return base.CanConvertTo (context, destinationType); + } + + public override bool CanConvertFrom (ITypeDescriptorContext context, Type sourceType) + { + if (sourceType == typeof(string)) + return true; + + return base.CanConvertFrom (context, sourceType); + } + + + + public override object ConvertTo (ITypeDescriptorContext context, + CultureInfo culture, + object value, + Type destinationType) + { + if (!(value is TableLayoutSettings) || destinationType != typeof (string)) + return base.ConvertTo (context, culture, value, destinationType); + + TableLayoutSettings settings = value as TableLayoutSettings; + StringWriter sw = new StringWriter (); + XmlTextWriter xw = new XmlTextWriter (sw); + xw.WriteStartDocument (); + List<WidgetInfo> list = settings.GetWidgets (); + xw.WriteStartElement ("TableLayoutSettings"); + xw.WriteStartElement ("Widgets"); + + foreach (WidgetInfo info in list) { + xw.WriteStartElement ("Widget"); + xw.WriteAttributeString ("Name", info.Widget.ToString ()); + xw.WriteAttributeString ("Row", info.Row.ToString ()); + xw.WriteAttributeString ("RowSpan", info.RowSpan.ToString ()); + xw.WriteAttributeString ("Column", info.Col.ToString ()); + xw.WriteAttributeString ("ColumnSpan", info.ColSpan.ToString ()); + xw.WriteEndElement (); + } + xw.WriteEndElement (); + + + List<string> styles = new List<string> (); + + foreach (ColumnStyle style in settings.ColumnStyles) { + styles.Add (style.SizeType.ToString ()); + styles.Add (style.Width.ToString (CultureInfo.InvariantCulture)); + } + + + xw.WriteStartElement ("Columns"); + xw.WriteAttributeString ("Styles", String.Join (",", styles.ToArray ())); + xw.WriteEndElement (); + + styles.Clear(); + foreach (RowStyle style in settings.RowStyles) { + styles.Add (style.SizeType.ToString ()); + styles.Add (style.Height.ToString (CultureInfo.InvariantCulture)); + } + + xw.WriteStartElement ("Rows"); + xw.WriteAttributeString ("Styles", String.Join (",", styles.ToArray ())); + xw.WriteEndElement (); + + xw.WriteEndElement (); + xw.WriteEndDocument (); + xw.Close (); + + return sw.ToString (); + + } + + public override object ConvertFrom (ITypeDescriptorContext context, + CultureInfo culture, + object value) + { + if (!(value is string)) + return base.ConvertFrom(context, culture, value); + + XmlDocument xmldoc = new XmlDocument(); + xmldoc.LoadXml (value as string); + TableLayoutSettings settings = new TableLayoutSettings(new TableLayoutPanel()); + int count = ParseWidget (xmldoc, settings); + ParseColumnStyle (xmldoc, settings); + ParseRowStyle (xmldoc, settings); + settings.RowCount = count; + + + return settings; + } + + + private int ParseWidget (XmlDocument xmldoc, TableLayoutSettings settings) + { + int count = 0; + foreach (XmlNode node in xmldoc.GetElementsByTagName ("Widget")) { + if (node.Attributes["Name"] == null || string.IsNullOrEmpty(node.Attributes["Name"].Value)) + continue; + if (node.Attributes["Row"] != null) { + settings.SetRow (node.Attributes["Name"].Value, GetValue (node.Attributes["Row"].Value)); + count++; + } + if (node.Attributes["RowSpan"] != null) { + settings.SetRowSpan (node.Attributes["Name"].Value, GetValue (node.Attributes["RowSpan"].Value)); + } + if (node.Attributes["Column"] != null) + settings.SetColumn (node.Attributes["Name"].Value, GetValue (node.Attributes["Column"].Value)); + if (node.Attributes["ColumnSpan"] != null) + settings.SetColumnSpan (node.Attributes["Name"].Value, GetValue (node.Attributes["ColumnSpan"].Value)); + } + return count; + } + + private void ParseColumnStyle (XmlDocument xmldoc, TableLayoutSettings settings) + { + foreach (XmlNode node in xmldoc.GetElementsByTagName ("Columns")) { + if (node.Attributes["Styles"] == null) + continue; + string styles = node.Attributes["Styles"].Value; + if (string.IsNullOrEmpty (styles)) + continue; + string[] list = BuggySplit (styles); + for (int i = 0; i < list.Length; i+=2) { + float width = 0f; + SizeType type = (SizeType) Enum.Parse (typeof (SizeType), list[i]); + float.TryParse (list[i+1], NumberStyles.Float, CultureInfo.InvariantCulture, out width); + settings.ColumnStyles.Add (new ColumnStyle (type, width)); + } + } + } + + private void ParseRowStyle (XmlDocument xmldoc, TableLayoutSettings settings) + { + foreach (XmlNode node in xmldoc.GetElementsByTagName ("Rows")) { + if (node.Attributes["Styles"] == null) + continue; + string styles = node.Attributes["Styles"].Value; + if (string.IsNullOrEmpty(styles)) + continue; + string[] list = BuggySplit (styles); + for (int i = 0; i < list.Length; i += 2) { + float height = 0f; + SizeType type = (SizeType) Enum.Parse (typeof (SizeType), list[i]); + float.TryParse (list[i + 1], NumberStyles.Float, CultureInfo.InvariantCulture, out height); + settings.RowStyles.Add (new RowStyle (type, height)); + } + } + } + + private int GetValue (string attValue) + { + int val = -1; + if (!string.IsNullOrEmpty (attValue)) { + int.TryParse (attValue, out val); + } + return val; + } + + // .Net accidently uses the local culture separator, so + // Percent,50.0,Percent,50.0 can be + // Percent,50,0,Percent,50,0 + // Make sure we can handle this + private string[] BuggySplit (string s) + { + List<string> l = new List<string> (); + + string[] split = s.Split (','); + + for (int i = 0; i < split.Length; i++) { + switch (split[i].ToLowerInvariant ()) { + case "autosize": + case "absolute": + case "percent": + l.Add (split[i]); + break; + default: + if (i + 1 < split.Length) { + float test; + + if (float.TryParse (split[i + 1], out test)) { + l.Add (string.Format ("{0}.{1}", split[i], split[i + 1])); + i++; + } else + l.Add (split[i]); + } else + l.Add (split[i]); + break; + } + } + + return l.ToArray (); + } + } +} diff --git a/source/ShiftUI/Internal/TextBoxTextRenderer.cs b/source/ShiftUI/Internal/TextBoxTextRenderer.cs new file mode 100644 index 0000000..3e908f3 --- /dev/null +++ b/source/ShiftUI/Internal/TextBoxTextRenderer.cs @@ -0,0 +1,131 @@ +// 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) 2007 Novell, Inc. (http://www.novell.com) +// +// Authors: +// Jonathan Pobst [email protected] +// +// + +using System; +using System.Drawing; +using System.Drawing.Text; +using System.Text; +using System.Collections; + +namespace ShiftUI +{ + internal class TextBoxTextRenderer + { + private static Size max_size; + private static bool use_textrenderer; + private static StringFormat sf_nonprinting; + private static StringFormat sf_printing; + private static Hashtable measure_cache; + + static TextBoxTextRenderer () + { + // On Windows, we want to use TextRenderer (GDI) + // On Linux, we want to use DrawString (GDI+) + // TextRenderer provides translation from TextRenderer to + // DrawString, but I doubt it's exact enough. + // Another option would be to put Pango here for Linux. + int platform = (int)Environment.OSVersion.Platform; + + if (platform == 4 || platform == 128 || platform == 6) + use_textrenderer = false; + else + use_textrenderer = true; + + // windows 2000 doesn't draw with gdi if bounds are In32.MaxValue + max_size = new Size (Int16.MaxValue, Int16.MaxValue); + + sf_nonprinting = new StringFormat (StringFormat.GenericTypographic); + sf_nonprinting.Trimming = StringTrimming.None; + sf_nonprinting.FormatFlags = StringFormatFlags.DisplayFormatControl; + sf_nonprinting.HotkeyPrefix = HotkeyPrefix.None; + + sf_printing = StringFormat.GenericTypographic; + sf_printing.HotkeyPrefix = HotkeyPrefix.None; + + measure_cache = new Hashtable (); + } + + public static void DrawText (Graphics g, string text, Font font, Color color, float x, float y, bool showNonPrint) + { + if (!use_textrenderer) { + if (showNonPrint) + g.DrawString (text, font, ThemeEngine.Current.ResPool.GetSolidBrush (color), x, y, sf_nonprinting); + else + g.DrawString (text, font, ThemeEngine.Current.ResPool.GetSolidBrush (color), x, y, sf_printing); + } else { + if (showNonPrint) + TextRenderer.DrawTextInternal (g, text, font, new Rectangle (new Point ((int)x, (int)y), max_size), color, TextFormatFlags.NoPadding | TextFormatFlags.NoPrefix, false); + else + TextRenderer.DrawTextInternal (g, text, font, new Rectangle (new Point ((int)x, (int)y), max_size), color, TextFormatFlags.NoPadding | TextFormatFlags.NoPrefix, false); + } + } + + public static SizeF MeasureText (Graphics g, string text, Font font) + { + // Due to the way the TextBox currently works, it measures each + // character one at a time. And it does this alot. So here we + // are implementing a cache for each font/character combination + // measurement. Since the number of fonts and number of characters + // used tends to be small, this is a good performance gain for + // not too much memory. + if (text.Length == 1) { + // If g.VisibleClipBounds is {X=0, Y=0, Width=1, Height=1}, then some characters + // (in some fonts for some point sizes) return a different width then when the + // VisibleClipBounds has a different (usually but not always more reasonable) value. + // This state of the Graphics object can occur during initialization of text boxes + // with preset Text values. See https://bugzilla.xamarin.com/show_bug.cgi?id=26258 + // for more details. + string sep; + var bounds = g.VisibleClipBounds; + if (bounds.Width == 1 && bounds.Height == 1 && bounds.X == 0 && bounds.Y == 0) + sep = "-1x1|"; + else + sep = "|"; + string key = font.GetHashCode ().ToString () + sep + text; + + if (measure_cache.ContainsKey (key)) { + return (SizeF)measure_cache[key]; + } else { + SizeF size; + + if (!use_textrenderer) + size = g.MeasureString (text, font, 10000, sf_nonprinting); + else + size = TextRenderer.MeasureTextInternal (g, text, font, Size.Empty, TextFormatFlags.NoPadding | TextFormatFlags.NoPrefix, false); + + measure_cache[key] = size; + + return size; + } + } + + if (!use_textrenderer) + return g.MeasureString (text, font, 10000, sf_nonprinting); + else + return TextRenderer.MeasureTextInternal (g, text, font, Size.Empty, TextFormatFlags.NoPadding | TextFormatFlags.NoPrefix, false); + } + } +} diff --git a/source/ShiftUI/Internal/TextControl.cs b/source/ShiftUI/Internal/TextControl.cs new file mode 100644 index 0000000..65dd5c6 --- /dev/null +++ b/source/ShiftUI/Internal/TextControl.cs @@ -0,0 +1,4613 @@ +// 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) 2004-2006 Novell, Inc. (http://www.novell.com) +// +// Authors: +// Peter Bartok [email protected] +// +// + +// NOT COMPLETE + +// There's still plenty of things missing, I've got most of it planned, just hadn't had +// the time to write it all yet. +// Stuff missing (in no particular order): +// - Align text after RecalculateLine +// - Implement tag types for hotlinks, etc. +// - Implement CaretPgUp/PgDown + +// NOTE: +// selection_start.pos and selection_end.pos are 0-based +// selection_start.pos = first selected char +// selection_end.pos = first NOT-selected char +// +// FormatText methods are 1-based (as are all tags, LineTag.Start is 1 for +// the first character on a line; the reason is that 0 is the position +// *before* the first character on a line + + +#undef Debug + +using System; +using System.Collections; +using System.Drawing; +using System.Drawing.Text; +using System.Text; +using RTF=ShiftUI.RTF; + +namespace ShiftUI { + internal enum LineColor { + Red = 0, + Black = 1 + } + + internal enum CaretSelection { + Position, // Selection=Caret + Word, // Selection=Word under caret + Line // Selection=Line under caret + } + + [Flags] + internal enum FormatSpecified { + None, + + BackColor = 2, + Font = 4, + Color = 8, + } + + internal enum CaretDirection { + CharForward, // Move a char to the right + CharBack, // Move a char to the left + LineUp, // Move a line up + LineDown, // Move a line down + Home, // Move to the beginning of the line + End, // Move to the end of the line + PgUp, // Move one page up + PgDn, // Move one page down + CtrlPgUp, // Move caret to the first visible char in the viewport + CtrlPgDn, // Move caret to the last visible char in the viewport + CtrlHome, // Move to the beginning of the document + CtrlEnd, // Move to the end of the document + WordBack, // Move to the beginning of the previous word (or beginning of line) + WordForward, // Move to the beginning of the next word (or end of line) + SelectionStart, // Move to the beginning of the current selection + SelectionEnd, // Move to the end of the current selection + CharForwardNoWrap, // Move a char forward, but don't wrap onto the next line + CharBackNoWrap // Move a char backward, but don't wrap onto the previous line + } + + internal enum LineEnding { + Wrap = 1, // line wraps to the next line + Limp = 2, // \r + Hard = 4, // \r\n + Soft = 8, // \r\r\n + Rich = 16, // \n + + None = 0 + } + + internal class Document : ICloneable, IEnumerable { + #region Structures + // FIXME - go through code and check for places where + // we do explicit comparisons instead of using the compare overloads + internal struct Marker { + internal Line line; + internal LineTag tag; + internal int pos; + internal int height; + + public static bool operator<(Marker lhs, Marker rhs) { + if (lhs.line.line_no < rhs.line.line_no) { + return true; + } + + if (lhs.line.line_no == rhs.line.line_no) { + if (lhs.pos < rhs.pos) { + return true; + } + } + return false; + } + + public static bool operator>(Marker lhs, Marker rhs) { + if (lhs.line.line_no > rhs.line.line_no) { + return true; + } + + if (lhs.line.line_no == rhs.line.line_no) { + if (lhs.pos > rhs.pos) { + return true; + } + } + return false; + } + + public static bool operator==(Marker lhs, Marker rhs) { + if ((lhs.line.line_no == rhs.line.line_no) && (lhs.pos == rhs.pos)) { + return true; + } + return false; + } + + public static bool operator!=(Marker lhs, Marker rhs) { + if ((lhs.line.line_no != rhs.line.line_no) || (lhs.pos != rhs.pos)) { + return true; + } + return false; + } + + public void Combine(Line move_to_line, int move_to_line_length) { + line = move_to_line; + pos += move_to_line_length; + tag = LineTag.FindTag(line, pos); + } + + // This is for future use, right now Document.Split does it by hand, with some added shortcut logic + public void Split(Line move_to_line, int split_at) { + line = move_to_line; + pos -= split_at; + tag = LineTag.FindTag(line, pos); + } + + public override bool Equals(object obj) { + return this==(Marker)obj; + } + + public override int GetHashCode() { + return base.GetHashCode (); + } + + public override string ToString() { + return "Marker Line " + line + ", Position " + pos; + } + + } + #endregion Structures + + #region Local Variables + private Line document; + private int lines; + private Line sentinel; + private int document_id; + private Random random = new Random(); + internal string password_char; + private StringBuilder password_cache; + private bool calc_pass; + private int char_count; + private bool enable_links; + + // For calculating widths/heights + public static readonly StringFormat string_format = new StringFormat (StringFormat.GenericTypographic); + + private int recalc_suspended; + private bool recalc_pending; + private int recalc_start = 1; // This starts at one, since lines are 1 based + private int recalc_end; + private bool recalc_optimize; + + private int update_suspended; + private bool update_pending; + private int update_start = 1; + + internal bool multiline; + internal HorizontalAlignment alignment; + internal bool wrap; + + internal UndoManager undo; + + internal Marker caret; + internal Marker selection_start; + internal Marker selection_end; + internal bool selection_visible; + internal Marker selection_anchor; + internal Marker selection_prev; + internal bool selection_end_anchor; + + internal int viewport_x; + internal int viewport_y; // The visible area of the document + internal int offset_x; + internal int offset_y; + internal int viewport_width; + internal int viewport_height; + + internal int document_x; // Width of the document + internal int document_y; // Height of the document + + internal int crlf_size; // 1 or 2, depending on whether we use \r\n or just \n + + internal TextBoxBase owner; // Who's owning us? + static internal int caret_width = 1; + static internal int caret_shift = 1; + + internal int left_margin = 2; // A left margin for all lines + internal int top_margin = 2; + internal int right_margin = 2; + #endregion // Local Variables + + #region Constructors + internal Document (TextBoxBase owner) + { + lines = 0; + + this.owner = owner; + + multiline = true; + password_char = ""; + calc_pass = false; + recalc_pending = false; + + // Tree related stuff + sentinel = new Line (this, LineEnding.None); + sentinel.color = LineColor.Black; + + document = sentinel; + + // We always have a blank line + owner.HandleCreated += new EventHandler(owner_HandleCreated); + owner.VisibleChanged += new EventHandler(owner_VisibleChanged); + + Add (1, String.Empty, owner.Font, owner.ForeColor, LineEnding.None); + + undo = new UndoManager (this); + + selection_visible = false; + selection_start.line = this.document; + selection_start.pos = 0; + selection_start.tag = selection_start.line.tags; + selection_end.line = this.document; + selection_end.pos = 0; + selection_end.tag = selection_end.line.tags; + selection_anchor.line = this.document; + selection_anchor.pos = 0; + selection_anchor.tag = selection_anchor.line.tags; + caret.line = this.document; + caret.pos = 0; + caret.tag = caret.line.tags; + + viewport_x = 0; + viewport_y = 0; + + offset_x = 0; + offset_y = 0; + + crlf_size = 2; + + // Default selection is empty + + document_id = random.Next(); + + string_format.Trimming = StringTrimming.None; + string_format.FormatFlags = StringFormatFlags.DisplayFormatControl; + + UpdateMargins (); + } + #endregion + + #region Internal Properties + internal Line Root { + get { + return document; + } + + set { + document = value; + } + } + + // UIA: Method used via reflection in TextRangeProvider + internal int Lines { + get { + return lines; + } + } + + internal Line CaretLine { + get { + return caret.line; + } + } + + internal int CaretPosition { + get { + return caret.pos; + } + } + + internal Point Caret { + get { + return new Point((int)caret.tag.Line.widths[caret.pos] + caret.line.X, caret.line.Y); + } + } + + internal LineTag CaretTag { + get { + return caret.tag; + } + + set { + caret.tag = value; + } + } + + internal int CRLFSize { + get { + return crlf_size; + } + + set { + crlf_size = value; + } + } + + /// <summary> + /// Whether text is scanned for links + /// </summary> + internal bool EnableLinks { + get { return enable_links; } + set { enable_links = value; } + } + + internal string PasswordChar { + get { + return password_char; + } + + set { + password_char = value; + PasswordCache.Length = 0; + if ((password_char.Length != 0) && (password_char[0] != '\0')) { + calc_pass = true; + } else { + calc_pass = false; + } + } + } + + private StringBuilder PasswordCache { + get { + if (password_cache == null) + password_cache = new StringBuilder(); + return password_cache; + } + } + + internal int ViewPortX { + get { + return viewport_x; + } + + set { + viewport_x = value; + } + } + + internal int Length { + get { + return char_count + lines - 1; // Add \n for each line but the last + } + } + + private int CharCount { + get { + return char_count; + } + + set { + char_count = value; + + if (LengthChanged != null) { + LengthChanged(this, EventArgs.Empty); + } + } + } + + internal int ViewPortY { + get { + return viewport_y; + } + + set { + viewport_y = value; + } + } + + internal int OffsetX + { + get + { + return offset_x; + } + + set + { + offset_x = value; + } + } + + internal int OffsetY + { + get + { + return offset_y; + } + + set + { + offset_y = value; + } + } + + internal int ViewPortWidth { + get { + return viewport_width; + } + + set { + viewport_width = value; + } + } + + internal int ViewPortHeight { + get { + return viewport_height; + } + + set { + viewport_height = value; + } + } + + + internal int Width { + get { + return this.document_x; + } + } + + internal int Height { + get { + return this.document_y; + } + } + + internal bool SelectionVisible { + get { + return selection_visible; + } + } + + internal bool Wrap { + get { + return wrap; + } + + set { + wrap = value; + } + } + + #endregion // Internal Properties + + #region Private Methods + + internal void UpdateMargins () + { + switch (owner.actual_border_style) { + case BorderStyle.None: + left_margin = 0; + top_margin = 0; + right_margin = 1; + break; + case BorderStyle.FixedSingle: + left_margin = 2; + top_margin = 2; + right_margin = 3; + break; + case BorderStyle.Fixed3D: + left_margin = 1; + top_margin = 1; + right_margin = 2; + break; + } + } + + internal void SuspendRecalc () + { + if (recalc_suspended == 0) { + recalc_start = int.MaxValue; + recalc_end = int.MinValue; + } + + recalc_suspended++; + } + + internal void ResumeRecalc (bool immediate_update) + { + if (recalc_suspended > 0) + recalc_suspended--; + + if (recalc_suspended == 0 && (immediate_update || recalc_pending) && !(recalc_start == int.MaxValue && recalc_end == int.MinValue)) { + RecalculateDocument (owner.CreateGraphicsInternal (), recalc_start, recalc_end, recalc_optimize); + recalc_pending = false; + } + } + + internal void SuspendUpdate () + { + update_suspended++; + } + + internal void ResumeUpdate (bool immediate_update) + { + if (update_suspended > 0) + update_suspended--; + + if (immediate_update && update_suspended == 0 && update_pending) { + UpdateView (GetLine (update_start), 0); + update_pending = false; + } + } + + // For debugging + internal int DumpTree(Line line, bool with_tags) { + int total; + + total = 1; + + Console.Write("Line {0} [# {1}], Y: {2}, ending style: {3}, Text: '{4}'", + line.line_no, line.GetHashCode(), line.Y, line.ending, + line.text != null ? line.text.ToString() : "undefined"); + + if (line.left == sentinel) { + Console.Write(", left = sentinel"); + } else if (line.left == null) { + Console.Write(", left = NULL"); + } + + if (line.right == sentinel) { + Console.Write(", right = sentinel"); + } else if (line.right == null) { + Console.Write(", right = NULL"); + } + + Console.WriteLine(""); + + if (with_tags) { + LineTag tag; + int count; + int length; + + tag = line.tags; + count = 1; + length = 0; + Console.Write(" Tags: "); + while (tag != null) { + Console.Write("{0} <{1}>-<{2}>", count++, tag.Start, tag.End + /*line.text.ToString (tag.start - 1, tag.length)*/); + length += tag.Length; + + if (tag.Line != line) { + Console.Write("BAD line link"); + throw new Exception("Bad line link in tree"); + } + tag = tag.Next; + if (tag != null) { + Console.Write(", "); + } + } + if (length > line.text.Length) { + throw new Exception(String.Format("Length of tags more than length of text on line (expected {0} calculated {1})", line.text.Length, length)); + } else if (length < line.text.Length) { + throw new Exception(String.Format("Length of tags less than length of text on line (expected {0} calculated {1})", line.text.Length, length)); + } + Console.WriteLine(""); + } + if (line.left != null) { + if (line.left != sentinel) { + total += DumpTree(line.left, with_tags); + } + } else { + if (line != sentinel) { + throw new Exception("Left should not be NULL"); + } + } + + if (line.right != null) { + if (line.right != sentinel) { + total += DumpTree(line.right, with_tags); + } + } else { + if (line != sentinel) { + throw new Exception("Right should not be NULL"); + } + } + + for (int i = 1; i <= this.lines; i++) { + if (GetLine(i) == null) { + throw new Exception(String.Format("Hole in line order, missing {0}", i)); + } + } + + if (line == this.Root) { + if (total < this.lines) { + throw new Exception(String.Format("Not enough nodes in tree, found {0}, expected {1}", total, this.lines)); + } else if (total > this.lines) { + throw new Exception(String.Format("Too many nodes in tree, found {0}, expected {1}", total, this.lines)); + } + } + + return total; + } + + private void SetSelectionVisible (bool value) + { + bool old_selection_visible = selection_visible; + selection_visible = value; + + // cursor and selection are enemies, we can't have both in the same room at the same time + if (owner.IsHandleCreated && !owner.show_caret_w_selection) + XplatUI.CaretVisible (owner.Handle, !selection_visible); + if (UIASelectionChanged != null && (selection_visible || old_selection_visible)) + UIASelectionChanged (this, EventArgs.Empty); + } + + private void DecrementLines(int line_no) { + int current; + + current = line_no; + while (current <= lines) { + GetLine(current).line_no--; + current++; + } + return; + } + + private void IncrementLines(int line_no) { + int current; + + current = this.lines; + while (current >= line_no) { + GetLine(current).line_no++; + current--; + } + return; + } + + private void RebalanceAfterAdd(Line line1) { + Line line2; + + while ((line1 != document) && (line1.parent.color == LineColor.Red)) { + if (line1.parent == line1.parent.parent.left) { + line2 = line1.parent.parent.right; + + if ((line2 != null) && (line2.color == LineColor.Red)) { + line1.parent.color = LineColor.Black; + line2.color = LineColor.Black; + line1.parent.parent.color = LineColor.Red; + line1 = line1.parent.parent; + } else { + if (line1 == line1.parent.right) { + line1 = line1.parent; + RotateLeft(line1); + } + + line1.parent.color = LineColor.Black; + line1.parent.parent.color = LineColor.Red; + + RotateRight(line1.parent.parent); + } + } else { + line2 = line1.parent.parent.left; + + if ((line2 != null) && (line2.color == LineColor.Red)) { + line1.parent.color = LineColor.Black; + line2.color = LineColor.Black; + line1.parent.parent.color = LineColor.Red; + line1 = line1.parent.parent; + } else { + if (line1 == line1.parent.left) { + line1 = line1.parent; + RotateRight(line1); + } + + line1.parent.color = LineColor.Black; + line1.parent.parent.color = LineColor.Red; + RotateLeft(line1.parent.parent); + } + } + } + document.color = LineColor.Black; + } + + private void RebalanceAfterDelete(Line line1) { + Line line2; + + while ((line1 != document) && (line1.color == LineColor.Black)) { + if (line1 == line1.parent.left) { + line2 = line1.parent.right; + if (line2.color == LineColor.Red) { + line2.color = LineColor.Black; + line1.parent.color = LineColor.Red; + RotateLeft(line1.parent); + line2 = line1.parent.right; + } + if ((line2.left.color == LineColor.Black) && (line2.right.color == LineColor.Black)) { + line2.color = LineColor.Red; + line1 = line1.parent; + } else { + if (line2.right.color == LineColor.Black) { + line2.left.color = LineColor.Black; + line2.color = LineColor.Red; + RotateRight(line2); + line2 = line1.parent.right; + } + line2.color = line1.parent.color; + line1.parent.color = LineColor.Black; + line2.right.color = LineColor.Black; + RotateLeft(line1.parent); + line1 = document; + } + } else { + line2 = line1.parent.left; + if (line2.color == LineColor.Red) { + line2.color = LineColor.Black; + line1.parent.color = LineColor.Red; + RotateRight(line1.parent); + line2 = line1.parent.left; + } + if ((line2.right.color == LineColor.Black) && (line2.left.color == LineColor.Black)) { + line2.color = LineColor.Red; + line1 = line1.parent; + } else { + if (line2.left.color == LineColor.Black) { + line2.right.color = LineColor.Black; + line2.color = LineColor.Red; + RotateLeft(line2); + line2 = line1.parent.left; + } + line2.color = line1.parent.color; + line1.parent.color = LineColor.Black; + line2.left.color = LineColor.Black; + RotateRight(line1.parent); + line1 = document; + } + } + } + line1.color = LineColor.Black; + } + + private void RotateLeft(Line line1) { + Line line2 = line1.right; + + line1.right = line2.left; + + if (line2.left != sentinel) { + line2.left.parent = line1; + } + + if (line2 != sentinel) { + line2.parent = line1.parent; + } + + if (line1.parent != null) { + if (line1 == line1.parent.left) { + line1.parent.left = line2; + } else { + line1.parent.right = line2; + } + } else { + document = line2; + } + + line2.left = line1; + if (line1 != sentinel) { + line1.parent = line2; + } + } + + private void RotateRight(Line line1) { + Line line2 = line1.left; + + line1.left = line2.right; + + if (line2.right != sentinel) { + line2.right.parent = line1; + } + + if (line2 != sentinel) { + line2.parent = line1.parent; + } + + if (line1.parent != null) { + if (line1 == line1.parent.right) { + line1.parent.right = line2; + } else { + line1.parent.left = line2; + } + } else { + document = line2; + } + + line2.right = line1; + if (line1 != sentinel) { + line1.parent = line2; + } + } + + + internal void UpdateView(Line line, int pos) { + if (!owner.IsHandleCreated) { + return; + } + + if (update_suspended > 0) { + update_start = Math.Min (update_start, line.line_no); + // update_end = Math.Max (update_end, line.line_no); + // recalc_optimize = true; + update_pending = true; + return; + } + + // Optimize invalidation based on Line alignment + if (RecalculateDocument(owner.CreateGraphicsInternal(), line.line_no, line.line_no, true)) { + // Lineheight changed, invalidate the rest of the document + if ((line.Y - viewport_y) >=0 ) { + // We formatted something that's in view, only draw parts of the screen + owner.Invalidate(new Rectangle( + offset_x, + line.Y - viewport_y + offset_y, + viewport_width, + owner.Height - (line.Y - viewport_y))); + } else { + // The tag was above the visible area, draw everything + owner.Invalidate(); + } + } else { + switch(line.alignment) { + case HorizontalAlignment.Left: { + owner.Invalidate(new Rectangle( + line.X + ((int)line.widths[pos] - viewport_x - 1) + offset_x, + line.Y - viewport_y + offset_y, + viewport_width, + line.height + 1)); + break; + } + + case HorizontalAlignment.Center: { + owner.Invalidate(new Rectangle( + line.X + offset_x, + line.Y - viewport_y + offset_y, + viewport_width, + line.height + 1)); + break; + } + + case HorizontalAlignment.Right: { + owner.Invalidate(new Rectangle( + line.X + offset_x, + line.Y - viewport_y + offset_y, + (int)line.widths[pos + 1] - viewport_x + line.X, + line.height + 1)); + break; + } + } + } + } + + + // Update display from line, down line_count lines; pos is unused, but required for the signature + internal void UpdateView(Line line, int line_count, int pos) { + if (!owner.IsHandleCreated) { + return; + } + + if (recalc_suspended > 0) { + recalc_start = Math.Min (recalc_start, line.line_no); + recalc_end = Math.Max (recalc_end, line.line_no + line_count); + recalc_optimize = true; + recalc_pending = true; + return; + } + + int start_line_top = line.Y; + + Line end_line = GetLine (line.line_no + line_count); + if (end_line == null) + end_line = GetLine (lines); + + if (end_line == null) + return; + + int end_line_bottom = end_line.Y + end_line.height; + + if (RecalculateDocument(owner.CreateGraphicsInternal(), line.line_no, line.line_no + line_count, true)) { + // Lineheight changed, invalidate the rest of the document + if ((line.Y - viewport_y) >=0 ) { + // We formatted something that's in view, only draw parts of the screen + owner.Invalidate(new Rectangle( + offset_x, + line.Y - viewport_y + offset_y, + viewport_width, + owner.Height - (line.Y - viewport_y))); + } else { + // The tag was above the visible area, draw everything + owner.Invalidate(); + } + } else { + int x = 0 - viewport_x + offset_x; + int w = viewport_width; + int y = Math.Min (start_line_top - viewport_y, line.Y - viewport_y) + offset_y; + int h = Math.Max (end_line_bottom - y, end_line.Y + end_line.height - y); + + owner.Invalidate (new Rectangle (x, y, w, h)); + } + } + + /// <summary> + /// Scans the next paragraph for http:/ ftp:/ www. https:/ etc and marks the tags + /// as links. + /// </summary> + /// <param name="start_line">The line to start on</param> + /// <param name="link_changed">marks as true if something is changed</param> + private void ScanForLinks (Line start_line, ref bool link_changed) + { + Line current_line = start_line; + StringBuilder line_no_breaks = new StringBuilder (); + StringBuilder line_link_record = new StringBuilder (); + ArrayList cumulative_length_list = new ArrayList (); + bool update_caret_tag = false; + + cumulative_length_list.Add (0); + + while (current_line != null) { + line_no_breaks.Append (current_line.text); + + if (link_changed == false) + current_line.LinkRecord (line_link_record); + + current_line.ClearLinks (); + + cumulative_length_list.Add (line_no_breaks.Length); + + if (current_line.ending == LineEnding.Wrap) + current_line = GetLine (current_line.LineNo + 1); + else + break; + } + + // search for protocols.. make sure www. is first! + string [] search_terms = new string [] { "www.", "http:/", "ftp:/", "https:/" }; + int search_found = 0; + int index_found = 0; + string line_no_breaks_string = line_no_breaks.ToString (); + int line_no_breaks_index = 0; + int link_end = 0; + + while (true) { + if (line_no_breaks_index >= line_no_breaks_string.Length) + break; + + index_found = FirstIndexOfAny (line_no_breaks_string, search_terms, line_no_breaks_index, out search_found); + + //no links found on this line + if (index_found == -1) + break; + + if (search_found == 0) { + // if we are at the end of the line to analyse and the end of the line + // is "www." then there are no links here + if (line_no_breaks_string.Length == index_found + search_terms [0].Length) + break; + + // if after www. we don't have a letter a digit or a @ or - or / + // then it is not a web address, we should continue searching + if (char.IsLetterOrDigit (line_no_breaks_string [index_found + search_terms [0].Length]) == false && + "@/~".IndexOf (line_no_breaks_string [index_found + search_terms [0].Length].ToString ()) == -1) { + line_no_breaks_index = index_found + search_terms [0].Length; + continue; + } + } + + link_end = line_no_breaks_string.Length - 1; + line_no_breaks_index = line_no_breaks_string.Length; + + // we've found a link, we just need to find where it ends now + for (int i = index_found + search_terms [search_found].Length; i < line_no_breaks_string.Length; i++) { + if (line_no_breaks_string [i - 1] == '.') { + if (char.IsLetterOrDigit (line_no_breaks_string [i]) == false && + "@/~".IndexOf (line_no_breaks_string [i].ToString ()) == -1) { + link_end = i - 1; + line_no_breaks_index = i; + break; + } + } else { + if (char.IsLetterOrDigit (line_no_breaks_string [i]) == false && + "@-/:~.?=_&".IndexOf (line_no_breaks_string [i].ToString ()) == -1) { + link_end = i - 1; + line_no_breaks_index = i; + break; + } + } + } + + string link_text = line_no_breaks_string.Substring (index_found, link_end - index_found + 1); + int current_cumulative = 0; + + // we've found a link - index_found -> link_end + // now we just make all the tags as containing link and + // point them to the text for the whole link + + current_line = start_line; + + //find the line we start on + for (current_cumulative = 1; current_cumulative < cumulative_length_list.Count; current_cumulative++) + if ((int)cumulative_length_list [current_cumulative] > index_found) + break; + + current_line = GetLine (start_line.LineNo + current_cumulative - 1); + + // find the tag we start on + LineTag current_tag = current_line.FindTag (index_found - (int)cumulative_length_list [current_cumulative - 1] + 1); + + if (current_tag.Start != (index_found - (int)cumulative_length_list [current_cumulative - 1]) + 1) { + if (current_tag == CaretTag) + update_caret_tag = true; + + current_tag = current_tag.Break ((index_found - (int)cumulative_length_list [current_cumulative - 1]) + 1); + } + + // set the tag + current_tag.IsLink = true; + current_tag.LinkText = link_text; + + //go through each character + // find the tag we are in + // skip the number of characters in the tag + for (int i = 1; i < link_text.Length; i++) { + // on to a new word-wrapped line + if ((int)cumulative_length_list [current_cumulative] <= index_found + i) { + + current_line = GetLine (start_line.LineNo + current_cumulative++); + current_tag = current_line.FindTag (index_found + i - (int)cumulative_length_list [current_cumulative - 1] + 1); + + current_tag.IsLink = true; + current_tag.LinkText = link_text; + + continue; + } + + if (current_tag.End < index_found + 1 + i - (int)cumulative_length_list [current_cumulative - 1]) { + // skip empty tags in the middle of the URL + do { + current_tag = current_tag.Next; + } while (current_tag.Length == 0); + + current_tag.IsLink = true; + current_tag.LinkText = link_text; + } + } + + //if there are characters left in the tag after the link + // split the tag + // make the second part a non link + if (current_tag.End > (index_found + link_text.Length + 1) - (int)cumulative_length_list [current_cumulative - 1]) { + if (current_tag == CaretTag) + update_caret_tag = true; + + current_tag.Break ((index_found + link_text.Length + 1) - (int)cumulative_length_list [current_cumulative - 1]); + } + } + + if (update_caret_tag) { + CaretTag = LineTag.FindTag (CaretLine, CaretPosition); + link_changed = true; + } else { + if (link_changed == false) { + current_line = start_line; + StringBuilder new_link_record = new StringBuilder (); + + while (current_line != null) { + current_line.LinkRecord (new_link_record); + + if (current_line.ending == LineEnding.Wrap) + current_line = GetLine (current_line.LineNo + 1); + else + break; + } + + if (new_link_record.Equals (line_link_record) == false) + link_changed = true; + } + } + } + + private int FirstIndexOfAny (string haystack, string [] needles, int start_index, out int term_found) + { + term_found = -1; + int best_index = -1; + + for (int i = 0; i < needles.Length; i++) { + int index = haystack.IndexOf (needles [i], start_index, StringComparison.InvariantCultureIgnoreCase); + + if (index > -1) { + if (term_found > -1) { + if (index < best_index) { + best_index = index; + term_found = i; + } + } else { + best_index = index; + term_found = i; + } + } + } + + return best_index; + } + + + + private void InvalidateLinks (Rectangle clip) + { + for (int i = (owner.list_links.Count - 1); i >= 0; i--) { + TextBoxBase.LinkRectangle link = (TextBoxBase.LinkRectangle) owner.list_links [i]; + + if (clip.IntersectsWith (link.LinkAreaRectangle)) + owner.list_links.RemoveAt (i); + } + } + #endregion // Private Methods + + #region Internal Methods + + internal void ScanForLinks (int start, int end, ref bool link_changed) + { + Line line = null; + LineEnding lastending = LineEnding.Rich; + + // make sure we start scanning at the real begining of the line + while (true) { + if (start != 1 && GetLine (start - 1).ending == LineEnding.Wrap) + start--; + else + break; + } + + for (int i = start; i <= end && i <= lines; i++) { + line = GetLine (i); + + if (lastending != LineEnding.Wrap) + ScanForLinks (line, ref link_changed); + + lastending = line.ending; + + if (lastending == LineEnding.Wrap && (i + 1) <= end) + end++; + } + } + + // Clear the document and reset state + internal void Empty() { + + document = sentinel; + lines = 0; + + // We always have a blank line + Add (1, String.Empty, owner.Font, owner.ForeColor, LineEnding.None); + + this.RecalculateDocument(owner.CreateGraphicsInternal()); + PositionCaret(0, 0); + + SetSelectionVisible (false); + + selection_start.line = this.document; + selection_start.pos = 0; + selection_start.tag = selection_start.line.tags; + selection_end.line = this.document; + selection_end.pos = 0; + selection_end.tag = selection_end.line.tags; + char_count = 0; + + viewport_x = 0; + viewport_y = 0; + + document_x = 0; + document_y = 0; + + if (owner.IsHandleCreated) + owner.Invalidate (); + } + + internal void PositionCaret(Line line, int pos) { + caret.tag = line.FindTag (pos); + + MoveCaretToTextTag (); + + caret.line = line; + caret.pos = pos; + + if (owner.IsHandleCreated) { + if (owner.Focused) { + if (caret.height != caret.tag.Height) + XplatUI.CreateCaret (owner.Handle, caret_width, caret.height); + XplatUI.SetCaretPos(owner.Handle, + offset_x + (int)caret.tag.Line.widths[caret.pos] + caret.line.X - viewport_x, + offset_y + caret.line.Y + caret.tag.Shift - viewport_y + caret_shift); + } + + if (CaretMoved != null) CaretMoved(this, EventArgs.Empty); + } + + // We set this at the end because we use the heights to determine whether or + // not we need to recreate the caret + caret.height = caret.tag.Height; + + } + + internal void PositionCaret(int x, int y) { + if (!owner.IsHandleCreated) { + return; + } + + caret.tag = FindCursor(x, y, out caret.pos); + + MoveCaretToTextTag (); + + caret.line = caret.tag.Line; + caret.height = caret.tag.Height; + + if (owner.ShowSelection && (!selection_visible || owner.show_caret_w_selection)) { + XplatUI.CreateCaret (owner.Handle, caret_width, caret.height); + XplatUI.SetCaretPos(owner.Handle, + (int)caret.tag.Line.widths[caret.pos] + caret.line.X - viewport_x + offset_x, + offset_y + caret.line.Y + caret.tag.Shift - viewport_y + caret_shift); + } + + if (CaretMoved != null) CaretMoved(this, EventArgs.Empty); + } + + internal void CaretHasFocus() { + if ((caret.tag != null) && owner.IsHandleCreated) { + XplatUI.CreateCaret(owner.Handle, caret_width, caret.height); + XplatUI.SetCaretPos(owner.Handle, + offset_x + (int)caret.tag.Line.widths[caret.pos] + caret.line.X - viewport_x, + offset_y + caret.line.Y + caret.tag.Shift - viewport_y + caret_shift); + + DisplayCaret (); + } + + if (owner.IsHandleCreated && SelectionLength () > 0) { + InvalidateSelectionArea (); + } + } + + internal void CaretLostFocus() { + if (!owner.IsHandleCreated) { + return; + } + XplatUI.DestroyCaret(owner.Handle); + } + + internal void AlignCaret () + { + AlignCaret (true); + } + + internal void AlignCaret(bool changeCaretTag) { + if (!owner.IsHandleCreated) { + return; + } + + if (changeCaretTag) { + caret.tag = LineTag.FindTag (caret.line, caret.pos); + + MoveCaretToTextTag (); + } + + // if the caret has had SelectionFont changed to a + // different height, we reflect changes unless the new + // font is larger than the line (line recalculations + // ignore empty tags) in which case we make it equal + // the line height and then when text is entered + if (caret.tag.Height > caret.tag.Line.Height) { + caret.height = caret.line.height; + } else { + caret.height = caret.tag.Height; + } + + if (owner.Focused) { + XplatUI.CreateCaret(owner.Handle, caret_width, caret.height); + XplatUI.SetCaretPos (owner.Handle, + offset_x + (int) caret.tag.Line.widths [caret.pos] + caret.line.X - viewport_x, + offset_y + caret.line.Y + viewport_y + caret_shift); + DisplayCaret (); + } + + if (CaretMoved != null) CaretMoved(this, EventArgs.Empty); + } + + internal void UpdateCaret() { + if (!owner.IsHandleCreated || caret.tag == null) { + return; + } + + MoveCaretToTextTag (); + + if (caret.tag.Height != caret.height) { + caret.height = caret.tag.Height; + if (owner.Focused) { + XplatUI.CreateCaret(owner.Handle, caret_width, caret.height); + } + } + + if (owner.Focused) { + XplatUI.SetCaretPos(owner.Handle, + offset_x + (int)caret.tag.Line.widths[caret.pos] + caret.line.X - viewport_x, + offset_y + caret.line.Y + caret.tag.Shift - viewport_y + caret_shift); + DisplayCaret (); + } + + if (CaretMoved != null) CaretMoved(this, EventArgs.Empty); + } + + internal void DisplayCaret() { + if (!owner.IsHandleCreated) { + return; + } + + if (owner.ShowSelection && (!selection_visible || owner.show_caret_w_selection)) { + XplatUI.CaretVisible(owner.Handle, true); + } + } + + internal void HideCaret() { + if (!owner.IsHandleCreated) { + return; + } + + if (owner.Focused) { + XplatUI.CaretVisible(owner.Handle, false); + } + } + + + internal void MoveCaretToTextTag () + { + if (caret.tag == null || caret.tag.IsTextTag) + return; + + + + if (caret.pos < caret.tag.Start) { + caret.tag = caret.tag.Previous; + } else { + caret.tag = caret.tag.Next; + } + } + + internal void MoveCaret(CaretDirection direction) { + // FIXME should we use IsWordSeparator to detect whitespace, instead + // of looking for actual spaces in the Word move cases? + + bool nowrap = false; + switch(direction) { + case CaretDirection.CharForwardNoWrap: + nowrap = true; + goto case CaretDirection.CharForward; + case CaretDirection.CharForward: { + caret.pos++; + if (caret.pos > caret.line.TextLengthWithoutEnding ()) { + if (!nowrap) { + // Go into next line + if (caret.line.line_no < this.lines) { + caret.line = GetLine(caret.line.line_no+1); + caret.pos = 0; + caret.tag = caret.line.tags; + } else { + caret.pos--; + } + } else { + // Single line; we stay where we are + caret.pos--; + } + } else { + if ((caret.tag.Start - 1 + caret.tag.Length) < caret.pos) { + caret.tag = caret.tag.Next; + } + } + UpdateCaret(); + return; + } + + case CaretDirection.CharBackNoWrap: + nowrap = true; + goto case CaretDirection.CharBack; + case CaretDirection.CharBack: { + if (caret.pos > 0) { + // caret.pos--; // folded into the if below + + if (--caret.pos > 0) { + if (caret.tag.Start > caret.pos) { + caret.tag = caret.tag.Previous; + } + } + } else { + if (caret.line.line_no > 1 && !nowrap) { + caret.line = GetLine(caret.line.line_no - 1); + caret.pos = caret.line.TextLengthWithoutEnding (); + caret.tag = LineTag.FindTag(caret.line, caret.pos); + } + } + UpdateCaret(); + return; + } + + case CaretDirection.WordForward: { + int len; + + len = caret.line.text.Length; + if (caret.pos < len) { + while ((caret.pos < len) && (caret.line.text[caret.pos] != ' ')) { + caret.pos++; + } + if (caret.pos < len) { + // Skip any whitespace + while ((caret.pos < len) && (caret.line.text[caret.pos] == ' ')) { + caret.pos++; + } + } + caret.tag = LineTag.FindTag(caret.line, caret.pos); + } else { + if (caret.line.line_no < this.lines) { + caret.line = GetLine(caret.line.line_no + 1); + caret.pos = 0; + caret.tag = caret.line.tags; + } + } + UpdateCaret(); + return; + } + + case CaretDirection.WordBack: { + if (caret.pos > 0) { + caret.pos--; + + while ((caret.pos > 0) && (caret.line.text[caret.pos] == ' ')) { + caret.pos--; + } + + while ((caret.pos > 0) && (caret.line.text[caret.pos] != ' ')) { + caret.pos--; + } + + if (caret.line.text.ToString(caret.pos, 1) == " ") { + if (caret.pos != 0) { + caret.pos++; + } else { + caret.line = GetLine(caret.line.line_no - 1); + caret.pos = caret.line.text.Length; + } + } + caret.tag = LineTag.FindTag(caret.line, caret.pos); + } else { + if (caret.line.line_no > 1) { + caret.line = GetLine(caret.line.line_no - 1); + caret.pos = caret.line.text.Length; + caret.tag = LineTag.FindTag(caret.line, caret.pos); + } + } + UpdateCaret(); + return; + } + + case CaretDirection.LineUp: { + if (caret.line.line_no > 1) { + int pixel; + + pixel = (int)caret.line.widths[caret.pos]; + PositionCaret(pixel, GetLine(caret.line.line_no - 1).Y); + + DisplayCaret (); + } + return; + } + + case CaretDirection.LineDown: { + if (caret.line.line_no < lines) { + int pixel; + + pixel = (int)caret.line.widths[caret.pos]; + PositionCaret(pixel, GetLine(caret.line.line_no + 1).Y); + + DisplayCaret (); + } + return; + } + + case CaretDirection.Home: { + if (caret.pos > 0) { + caret.pos = 0; + caret.tag = caret.line.tags; + UpdateCaret(); + } + return; + } + + case CaretDirection.End: { + if (caret.pos < caret.line.TextLengthWithoutEnding ()) { + caret.pos = caret.line.TextLengthWithoutEnding (); + caret.tag = LineTag.FindTag(caret.line, caret.pos); + UpdateCaret(); + } + return; + } + + case CaretDirection.PgUp: { + + if (caret.line.line_no == 1 && owner.richtext) { + owner.vscroll.Value = 0; + Line line = GetLine (1); + PositionCaret (line, 0); + } + + int y_offset = caret.line.Y + caret.line.height - 1 - viewport_y; + int index; + LineTag top = FindCursor ((int) caret.line.widths [caret.pos], + viewport_y - viewport_height, out index); + + owner.vscroll.Value = Math.Min (top.Line.Y, owner.vscroll.Maximum - viewport_height); + PositionCaret ((int) caret.line.widths [caret.pos], y_offset + viewport_y); + + return; + } + + case CaretDirection.PgDn: { + + if (caret.line.line_no == lines && owner.richtext) { + owner.vscroll.Value = owner.vscroll.Maximum - viewport_height + 1; + Line line = GetLine (lines); + PositionCaret (line, line.TextLengthWithoutEnding()); + } + + int y_offset = caret.line.Y - viewport_y; + int index; + LineTag top = FindCursor ((int) caret.line.widths [caret.pos], + viewport_y + viewport_height, out index); + + owner.vscroll.Value = Math.Min (top.Line.Y, owner.vscroll.Maximum - viewport_height); + PositionCaret ((int) caret.line.widths [caret.pos], y_offset + viewport_y); + + return; + } + + case CaretDirection.CtrlPgUp: { + PositionCaret(0, viewport_y); + DisplayCaret (); + return; + } + + case CaretDirection.CtrlPgDn: { + Line line; + LineTag tag; + int index; + + tag = FindCursor (0, viewport_y + viewport_height, out index); + if (tag.Line.line_no > 1) { + line = GetLine(tag.Line.line_no - 1); + } else { + line = tag.Line; + } + PositionCaret(line, line.Text.Length); + DisplayCaret (); + return; + } + + case CaretDirection.CtrlHome: { + caret.line = GetLine(1); + caret.pos = 0; + caret.tag = caret.line.tags; + + UpdateCaret(); + return; + } + + case CaretDirection.CtrlEnd: { + caret.line = GetLine(lines); + caret.pos = caret.line.TextLengthWithoutEnding (); + caret.tag = LineTag.FindTag(caret.line, caret.pos); + + UpdateCaret(); + return; + } + + case CaretDirection.SelectionStart: { + caret.line = selection_start.line; + caret.pos = selection_start.pos; + caret.tag = selection_start.tag; + + UpdateCaret(); + return; + } + + case CaretDirection.SelectionEnd: { + caret.line = selection_end.line; + caret.pos = selection_end.pos; + caret.tag = selection_end.tag; + + UpdateCaret(); + return; + } + } + } + + internal void DumpDoc () + { + Console.WriteLine ("<doc lines='{0}'>", lines); + for (int i = 1; i <= lines ; i++) { + Line line = GetLine (i); + Console.WriteLine ("<line no='{0}' ending='{1}'>", line.line_no, line.ending); + + LineTag tag = line.tags; + while (tag != null) { + Console.Write ("\t<tag type='{0}' span='{1}->{2}' font='{3}' color='{4}'>", + tag.GetType (), tag.Start, tag.Length, tag.Font, tag.Color); + Console.Write (tag.Text ()); + Console.WriteLine ("</tag>"); + tag = tag.Next; + } + Console.WriteLine ("</line>"); + } + Console.WriteLine ("</doc>"); + } + + // UIA: Used via reflection by TextProviderBehavior + internal void GetVisibleLineIndexes (Rectangle clip, out int start, out int end) + { + if (multiline) { + /* Expand the region slightly to be sure to + * paint the full extent of the line of text. + * See bug 464464. + */ + start = GetLineByPixel(clip.Top + viewport_y - offset_y - 1, false).line_no; + end = GetLineByPixel(clip.Bottom + viewport_y - offset_y + 1, false).line_no; + } else { + start = GetLineByPixel(clip.Left + viewport_x - offset_x, false).line_no; + end = GetLineByPixel(clip.Right + viewport_x - offset_x, false).line_no; + } + } + + internal void Draw (Graphics g, Rectangle clip) + { + Line line; // Current line being drawn + LineTag tag; // Current tag being drawn + int start; // First line to draw + int end; // Last line to draw + StringBuilder text; // String representing the current line + int line_no; + Color tag_color; + Color current_color; + + // First, figure out from what line to what line we need to draw + GetVisibleLineIndexes (clip, out start, out end); + + // remove links in the list (used for mouse down events) that are within the clip area. + InvalidateLinks (clip); + + /// + /// We draw the single border ourself + /// + if (owner.actual_border_style == BorderStyle.FixedSingle) { + WidgetPaint.DrawBorder (g, owner.ClientRectangle, Color.Black, ButtonBorderStyle.Solid); + } + + /// Make sure that we aren't drawing one more line then we need to + line = GetLine (end - 1); + if (line != null && clip.Bottom == offset_y + line.Y + line.height - viewport_y) + end--; + + line_no = start; + + #if Debug + DateTime n = DateTime.Now; + Console.WriteLine ("Started drawing: {0}s {1}ms", n.Second, n.Millisecond); + Console.WriteLine ("CLIP: {0}", clip); + Console.WriteLine ("S: {0}", GetLine (start).text); + Console.WriteLine ("E: {0}", GetLine (end).text); + #endif + + // Non multiline selection can be handled outside of the loop + if (!multiline && selection_visible && owner.ShowSelection) { + g.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (ThemeEngine.Current.ColorHighlight), + offset_x + selection_start.line.widths [selection_start.pos] + + selection_start.line.X - viewport_x, + offset_y + selection_start.line.Y, + (selection_end.line.X + selection_end.line.widths [selection_end.pos]) - + (selection_start.line.X + selection_start.line.widths [selection_start.pos]), + selection_start.line.height); + } + + while (line_no <= end) { + line = GetLine (line_no); + float line_y = line.Y - viewport_y + offset_y; + + tag = line.tags; + if (!calc_pass) { + text = line.text; + } else { + if (PasswordCache.Length < line.text.Length) + PasswordCache.Append(Char.Parse(password_char), line.text.Length - PasswordCache.Length); + else if (PasswordCache.Length > line.text.Length) + PasswordCache.Remove(line.text.Length, PasswordCache.Length - line.text.Length); + text = PasswordCache; + } + + int line_selection_start = text.Length + 1; + int line_selection_end = text.Length + 1; + if (selection_visible && owner.ShowSelection && + (line_no >= selection_start.line.line_no) && + (line_no <= selection_end.line.line_no)) { + + if (line_no == selection_start.line.line_no) + line_selection_start = selection_start.pos + 1; + else + line_selection_start = 1; + + if (line_no == selection_end.line.line_no) + line_selection_end = selection_end.pos + 1; + else + line_selection_end = text.Length + 1; + + if (line_selection_end == line_selection_start) { + // There isn't really selection + line_selection_start = text.Length + 1; + line_selection_end = line_selection_start; + } else if (multiline) { + // lets draw some selection baby!! (non multiline selection is drawn outside the loop) + g.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (ThemeEngine.Current.ColorHighlight), + offset_x + line.widths [line_selection_start - 1] + line.X - viewport_x, + line_y, line.widths [line_selection_end - 1] - line.widths [line_selection_start - 1], + line.height); + } + } + + current_color = line.tags.ColorToDisplay; + while (tag != null) { + + // Skip empty tags + if (tag.Length == 0) { + tag = tag.Next; + continue; + } + + if (((tag.X + tag.Width) < (clip.Left - viewport_x - offset_x)) && + (tag.X > (clip.Right - viewport_x - offset_x))) { + tag = tag.Next; + continue; + } + + if (tag.BackColor != Color.Empty) { + g.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (tag.BackColor), + offset_x + tag.X + line.X - viewport_x, + line_y + tag.Shift, tag.Width, line.height); + } + + tag_color = tag.ColorToDisplay; + current_color = tag_color; + + if (!owner.Enabled) { + Color a = tag.Color; + Color b = ThemeEngine.Current.ColorWindowText; + + if ((a.R == b.R) && (a.G == b.G) && (a.B == b.B)) + tag_color = ThemeEngine.Current.ColorGrayText; + + } + + int tag_pos = tag.Start; + current_color = tag_color; + while (tag_pos < tag.Start + tag.Length) { + int old_tag_pos = tag_pos; + + if (tag_pos >= line_selection_start && tag_pos < line_selection_end) { + current_color = ThemeEngine.Current.ColorHighlightText; + tag_pos = Math.Min (tag.End, line_selection_end); + } else if (tag_pos < line_selection_start) { + current_color = tag_color; + tag_pos = Math.Min (tag.End, line_selection_start); + } else { + current_color = tag_color; + tag_pos = tag.End; + } + + Rectangle text_size; + + tag.Draw (g, current_color, + offset_x + line.X - viewport_x, + line_y + tag.Shift, + old_tag_pos - 1, Math.Min (tag.Start + tag.Length, tag_pos) - 1, + text.ToString (), out text_size, tag.IsLink); + + if (tag.IsLink) { + TextBoxBase.LinkRectangle link = new TextBoxBase.LinkRectangle (text_size); + link.LinkTag = tag; + owner.list_links.Add (link); + } + } + tag = tag.Next; + } + + line.DrawEnding (g, line_y); + line_no++; + } + } + + private int GetLineEnding (string line, int start, out LineEnding ending) + { + int res; + int rich_index; + + if (start >= line.Length) { + ending = LineEnding.Wrap; + return -1; + } + + res = line.IndexOf ('\r', start); + rich_index = line.IndexOf ('\n', start); + + // Handle the case where we find both of them, and the \n is before the \r + if (res != -1 && rich_index != -1) + if (rich_index < res) { + ending = LineEnding.Rich; + return rich_index; + } + + if (res != -1) { + if (res + 2 < line.Length && line [res + 1] == '\r' && line [res + 2] == '\n') { + ending = LineEnding.Soft; + return res; + } + if (res + 1 < line.Length && line [res + 1] == '\n') { + ending = LineEnding.Hard; + return res; + } + ending = LineEnding.Limp; + return res; + } + + if (rich_index != -1) { + ending = LineEnding.Rich; + return rich_index; + } + + ending = LineEnding.Wrap; + return line.Length; + } + + // Get the line ending, but only of the types specified + private int GetLineEnding (string line, int start, out LineEnding ending, LineEnding type) + { + int index = start; + int last_length = 0; + + do { + index = GetLineEnding (line, index + last_length, out ending); + last_length = LineEndingLength (ending); + } while + ((ending & type) != ending && index != -1); + + return index == -1 ? line.Length : index; + } + + internal int LineEndingLength (LineEnding ending) + { + switch (ending) { + case LineEnding.Limp: + case LineEnding.Rich: + return 1; + case LineEnding.Hard: + return 2; + case LineEnding.Soft: + return 3; + } + + return 0; + } + + internal string LineEndingToString (LineEnding ending) + { + switch (ending) { + case LineEnding.Limp: + return "\r"; + case LineEnding.Hard: + return "\r\n"; + case LineEnding.Soft: + return "\r\r\n"; + case LineEnding.Rich: + return "\n"; + } + + return string.Empty; + } + + internal LineEnding StringToLineEnding (string ending) + { + switch (ending) { + case "\r": + return LineEnding.Limp; + case "\r\n": + return LineEnding.Hard; + case "\r\r\n": + return LineEnding.Soft; + case "\n": + return LineEnding.Rich; + default: + return LineEnding.None; + } + } + + internal void Insert (Line line, int pos, bool update_caret, string s) + { + Insert (line, pos, update_caret, s, line.FindTag (pos)); + } + + // Insert text at the given position; use formatting at insertion point for inserted text + internal void Insert (Line line, int pos, bool update_caret, string s, LineTag tag) + { + int break_index; + int base_line; + int old_line_count; + int count = 1; + LineEnding ending; + Line split_line; + + // Don't recalculate while we mess around + SuspendRecalc (); + + base_line = line.line_no; + old_line_count = lines; + + // Discard chars after any possible -unlikely- end of file + int eof_index = s.IndexOf ('\0'); + if (eof_index != -1) + s = s.Substring (0, eof_index); + + break_index = GetLineEnding (s, 0, out ending, LineEnding.Hard | LineEnding.Rich); + + // There are no line feeds in our text to be pasted + if (break_index == s.Length) { + line.InsertString (pos, s, tag); + } else { + // Add up to the first line feed to our current position + line.InsertString (pos, s.Substring (0, break_index + LineEndingLength (ending)), tag); + + // Split the rest of the original line to a new line + Split (line, pos + (break_index + LineEndingLength (ending))); + line.ending = ending; + break_index += LineEndingLength (ending); + split_line = GetLine (line.line_no + 1); + + // Insert brand new lines for any more line feeds in the inserted string + while (true) { + int next_break = GetLineEnding (s, break_index, out ending, LineEnding.Hard | LineEnding.Rich); + + if (next_break == s.Length) + break; + + string line_text = s.Substring (break_index, next_break - break_index + + LineEndingLength (ending)); + + Add (base_line + count, line_text, line.alignment, tag.Font, tag.Color, ending); + + Line last = GetLine (base_line + count); + last.ending = ending; + + count++; + break_index = next_break + LineEndingLength (ending); + } + + // Add the remainder of the insert text to the split + // part of the original line + split_line.InsertString (0, s.Substring (break_index)); + } + + // Allow the document to recalculate things + ResumeRecalc (false); + + // Update our character count + CharCount += s.Length; + + UpdateView (line, lines - old_line_count + 1, pos); + + // Move the caret to the end of the inserted text if requested + if (update_caret) { + Line l = GetLine (line.line_no + lines - old_line_count); + PositionCaret (l, l.text.Length); + DisplayCaret (); + } + } + + // Inserts a string at the given position + internal void InsertString (Line line, int pos, string s) + { + // Update our character count + CharCount += s.Length; + + // Insert the text into the Line + line.InsertString (pos, s); + } + + // Inserts a character at the current caret position + internal void InsertCharAtCaret (char ch, bool move_caret) + { + caret.line.InsertString (caret.pos, ch.ToString(), caret.tag); + + // Update our character count + CharCount++; + + undo.RecordTyping (caret.line, caret.pos, ch); + + UpdateView (caret.line, caret.pos); + + if (move_caret) { + caret.pos++; + UpdateCaret (); + SetSelectionToCaret (true); + } + } + + internal void InsertPicture (Line line, int pos, RTF.Picture picture) + { + //LineTag next_tag; + LineTag tag; + int len; + + len = 1; + + // Just a place holder basically + line.text.Insert (pos, "I"); + + PictureTag picture_tag = new PictureTag (line, pos + 1, picture); + + tag = LineTag.FindTag (line, pos); + picture_tag.CopyFormattingFrom (tag); + /*next_tag = */tag.Break (pos + 1); + picture_tag.Previous = tag; + picture_tag.Next = tag.Next; + tag.Next = picture_tag; + + // + // Picture tags need to be surrounded by text tags + // + if (picture_tag.Next == null) { + picture_tag.Next = new LineTag (line, pos + 1); + picture_tag.Next.CopyFormattingFrom (tag); + picture_tag.Next.Previous = picture_tag; + } + + tag = picture_tag.Next; + while (tag != null) { + tag.Start += len; + tag = tag.Next; + } + + line.Grow (len); + line.recalc = true; + + UpdateView (line, pos); + } + + internal void DeleteMultiline (Line start_line, int pos, int length) + { + Marker start = new Marker (); + Marker end = new Marker (); + int start_index = LineTagToCharIndex (start_line, pos); + + start.line = start_line; + start.pos = pos; + start.tag = LineTag.FindTag (start_line, pos); + + CharIndexToLineTag (start_index + length, out end.line, + out end.tag, out end.pos); + + SuspendUpdate (); + + if (start.line == end.line) { + DeleteChars (start.line, pos, end.pos - pos); + } else { + + // Delete first and last lines + DeleteChars (start.line, start.pos, start.line.text.Length - start.pos); + DeleteChars (end.line, 0, end.pos); + + int current = start.line.line_no + 1; + if (current < end.line.line_no) { + for (int i = end.line.line_no - 1; i >= current; i--) { + Delete (i); + } + } + + // BIG FAT WARNING - selection_end.line might be stale due + // to the above Delete() call. DONT USE IT before hitting the end of this method! + + // Join start and end + Combine (start.line.line_no, current); + } + + ResumeUpdate (true); + } + + + // Deletes n characters at the given position; it will not delete past line limits + // pos is 0-based + public void DeleteChars (Line line, int pos, int count) + { + // Reduce our character count + CharCount -= count; + + line.DeleteCharacters (pos, count); + + if (pos >= line.TextLengthWithoutEnding ()) { + LineEnding ending = line.ending; + GetLineEnding (line.text.ToString (), 0, out ending); + + if (ending != line.ending) { + line.ending = ending; + + if (!multiline) { + UpdateView (line, lines, pos); + owner.Invalidate (); + return; + } + } + } + if (!multiline) { + UpdateView (line, lines, pos); + owner.Invalidate (); + } else + UpdateView (line, pos); + } + + // Deletes a character at or after the given position (depending on forward); it will not delete past line limits + public void DeleteChar (Line line, int pos, bool forward) + { + if ((pos == 0 && forward == false) || (pos == line.text.Length && forward == true)) + return; + + undo.BeginUserAction ("Delete"); + + if (forward) { + undo.RecordDeleteString (line, pos, line, pos + 1); + DeleteChars (line, pos, 1); + } else { + undo.RecordDeleteString (line, pos - 1, line, pos); + DeleteChars (line, pos - 1, 1); + } + + undo.EndUserAction (); + } + + // Combine two lines + internal void Combine(int FirstLine, int SecondLine) { + Combine(GetLine(FirstLine), GetLine(SecondLine)); + } + + internal void Combine(Line first, Line second) { + LineTag last; + int shift; + + // strip the ending off of the first lines text + first.text.Length = first.text.Length - LineEndingLength (first.ending); + + // Combine the two tag chains into one + last = first.tags; + + // Maintain the line ending style + first.ending = second.ending; + + while (last.Next != null) { + last = last.Next; + } + + // need to get the shift before setting the next tag since that effects length + shift = last.Start + last.Length - 1; + last.Next = second.tags; + last.Next.Previous = last; + + // Fix up references within the chain + last = last.Next; + while (last != null) { + last.Line = first; + last.Start += shift; + last = last.Next; + } + + // Combine both lines' strings + first.text.Insert(first.text.Length, second.text.ToString()); + first.Grow(first.text.Length); + + // Remove the reference to our (now combined) tags from the doomed line + second.tags = null; + + // Renumber lines + DecrementLines(first.line_no + 2); // first.line_no + 1 will be deleted, so we need to start renumbering one later + + // Mop up + first.recalc = true; + first.height = 0; // This forces RecalcDocument/UpdateView to redraw from this line on + first.Streamline(lines); + + // Update Caret, Selection, etc + if (caret.line == second) { + caret.Combine(first, shift); + } + if (selection_anchor.line == second) { + selection_anchor.Combine(first, shift); + } + if (selection_start.line == second) { + selection_start.Combine(first, shift); + } + if (selection_end.line == second) { + selection_end.Combine(first, shift); + } + + #if Debug + Line check_first; + Line check_second; + + check_first = GetLine(first.line_no); + check_second = GetLine(check_first.line_no + 1); + + Console.WriteLine("Pre-delete: Y of first line: {0}, second line: {1}", check_first.Y, check_second.Y); + #endif + + this.Delete(second); + + #if Debug + check_first = GetLine(first.line_no); + check_second = GetLine(check_first.line_no + 1); + + Console.WriteLine("Post-delete Y of first line: {0}, second line: {1}", check_first.Y, check_second.Y); + #endif + } + + // Split the line at the position into two + internal void Split(int LineNo, int pos) { + Line line; + LineTag tag; + + line = GetLine(LineNo); + tag = LineTag.FindTag(line, pos); + Split(line, tag, pos); + } + + internal void Split(Line line, int pos) { + LineTag tag; + + tag = LineTag.FindTag(line, pos); + Split(line, tag, pos); + } + + ///<summary>Split line at given tag and position into two lines</summary> + ///if more space becomes available on previous line + internal void Split(Line line, LineTag tag, int pos) { + LineTag new_tag; + Line new_line; + bool move_caret; + bool move_sel_start; + bool move_sel_end; + + move_caret = false; + move_sel_start = false; + move_sel_end = false; + +#if DEBUG + SanityCheck(); + + if (tag.End < pos) + throw new Exception ("Split called with the wrong tag"); +#endif + + // Adjust selection and cursors + if (caret.line == line && caret.pos >= pos) { + move_caret = true; + } + if (selection_start.line == line && selection_start.pos > pos) { + move_sel_start = true; + } + + if (selection_end.line == line && selection_end.pos > pos) { + move_sel_end = true; + } + + // cover the easy case first + if (pos == line.text.Length) { + Add (line.line_no + 1, String.Empty, line.alignment, tag.Font, tag.Color, line.ending); + + new_line = GetLine (line.line_no + 1); + + if (move_caret) { + caret.line = new_line; + caret.tag = new_line.tags; + caret.pos = 0; + + if (selection_visible == false) { + SetSelectionToCaret (true); + } + } + + if (move_sel_start) { + selection_start.line = new_line; + selection_start.pos = 0; + selection_start.tag = new_line.tags; + } + + if (move_sel_end) { + selection_end.line = new_line; + selection_end.pos = 0; + selection_end.tag = new_line.tags; + } + +#if DEBUG + SanityCheck (); +#endif + return; + } + + // We need to move the rest of the text into the new line + Add (line.line_no + 1, line.text.ToString (pos, line.text.Length - pos), line.alignment, tag.Font, tag.Color, line.ending); + + // Now transfer our tags from this line to the next + new_line = GetLine(line.line_no + 1); + + line.recalc = true; + new_line.recalc = true; + + //make sure that if we are at the end of a tag, we start on the begining + //of a new one, if one exists... Stops us creating an empty tag and + //make the operation easier. + if (tag.Next != null && (tag.Next.Start - 1) == pos) + tag = tag.Next; + + if ((tag.Start - 1) == pos) { + int shift; + + // We can simply break the chain and move the tag into the next line + + // if the tag we are moving is the first, create an empty tag + // for the line we are leaving behind + if (tag == line.tags) { + new_tag = new LineTag(line, 1); + new_tag.CopyFormattingFrom (tag); + line.tags = new_tag; + } + + if (tag.Previous != null) { + tag.Previous.Next = null; + } + new_line.tags = tag; + tag.Previous = null; + tag.Line = new_line; + + // Walk the list and correct the start location of the tags we just bumped into the next line + shift = tag.Start - 1; + + new_tag = tag; + while (new_tag != null) { + new_tag.Start -= shift; + new_tag.Line = new_line; + new_tag = new_tag.Next; + } + } else { + int shift; + + new_tag = new LineTag (new_line, 1); + new_tag.Next = tag.Next; + new_tag.CopyFormattingFrom (tag); + new_line.tags = new_tag; + if (new_tag.Next != null) { + new_tag.Next.Previous = new_tag; + } + tag.Next = null; + + shift = pos; + new_tag = new_tag.Next; + while (new_tag != null) { + new_tag.Start -= shift; + new_tag.Line = new_line; + new_tag = new_tag.Next; + + } + } + + if (move_caret) { + caret.line = new_line; + caret.pos = caret.pos - pos; + caret.tag = caret.line.FindTag(caret.pos); + + if (selection_visible == false) { + SetSelectionToCaret (true); + move_sel_start = false; + move_sel_end = false; + } + } + + if (move_sel_start) { + selection_start.line = new_line; + selection_start.pos = selection_start.pos - pos; + if (selection_start.Equals(selection_end)) + selection_start.tag = new_line.FindTag(selection_start.pos); + else + selection_start.tag = new_line.FindTag (selection_start.pos + 1); + } + + if (move_sel_end) { + selection_end.line = new_line; + selection_end.pos = selection_end.pos - pos; + selection_end.tag = new_line.FindTag(selection_end.pos); + } + + CharCount -= line.text.Length - pos; + line.text.Remove(pos, line.text.Length - pos); +#if DEBUG + SanityCheck (); +#endif + } + +#if DEBUG + private void SanityCheck () { + for (int i = 1; i < lines; i++) { + LineTag tag = GetLine (i).tags; + + if (tag.Start != 1) + throw new Exception ("Line doesn't start at the begining"); + + int start = 1; + tag = tag.Next; + + while (tag != null) { + if (tag.Start == start) + throw new Exception ("Empty tag!"); + + if (tag.Start < start) + throw new Exception ("Insane!!"); + + start = tag.Start; + tag = tag.Next; + } + } + } +#endif + + // Adds a line of text, with given font. + // Bumps any line at that line number that already exists down + internal void Add (int LineNo, string Text, Font font, Color color, LineEnding ending) + { + Add (LineNo, Text, alignment, font, color, ending); + } + + internal void Add (int LineNo, string Text, HorizontalAlignment align, Font font, Color color, LineEnding ending) + { + Line add; + Line line; + int line_no; + + CharCount += Text.Length; + + if (LineNo<1 || Text == null) { + if (LineNo<1) { + throw new ArgumentNullException("LineNo", "Line numbers must be positive"); + } else { + throw new ArgumentNullException("Text", "Cannot insert NULL line"); + } + } + + add = new Line (this, LineNo, Text, align, font, color, ending); + + line = document; + while (line != sentinel) { + add.parent = line; + line_no = line.line_no; + + if (LineNo > line_no) { + line = line.right; + } else if (LineNo < line_no) { + line = line.left; + } else { + // Bump existing line numbers; walk all nodes to the right of this one and increment line_no + IncrementLines(line.line_no); + line = line.left; + } + } + + add.left = sentinel; + add.right = sentinel; + + if (add.parent != null) { + if (LineNo > add.parent.line_no) { + add.parent.right = add; + } else { + add.parent.left = add; + } + } else { + // Root node + document = add; + } + + RebalanceAfterAdd(add); + + lines++; + } + + internal virtual void Clear() { + lines = 0; + CharCount = 0; + document = sentinel; + } + + public virtual object Clone() { + Document clone; + + clone = new Document(null); + + clone.lines = this.lines; + clone.document = (Line)document.Clone(); + + return clone; + } + + private void Delete (int LineNo) + { + Line line; + + if (LineNo > lines) + return; + + line = GetLine (LineNo); + + CharCount -= line.text.Length; + + DecrementLines (LineNo + 1); + Delete (line); + } + + private void Delete(Line line1) { + Line line2;// = new Line(); + Line line3; + + if ((line1.left == sentinel) || (line1.right == sentinel)) { + line3 = line1; + } else { + line3 = line1.right; + while (line3.left != sentinel) { + line3 = line3.left; + } + } + + if (line3.left != sentinel) { + line2 = line3.left; + } else { + line2 = line3.right; + } + + line2.parent = line3.parent; + if (line3.parent != null) { + if(line3 == line3.parent.left) { + line3.parent.left = line2; + } else { + line3.parent.right = line2; + } + } else { + document = line2; + } + + if (line3 != line1) { + LineTag tag; + + if (selection_start.line == line3) { + selection_start.line = line1; + } + + if (selection_end.line == line3) { + selection_end.line = line1; + } + + if (selection_anchor.line == line3) { + selection_anchor.line = line1; + } + + if (caret.line == line3) { + caret.line = line1; + } + + + line1.alignment = line3.alignment; + line1.ascent = line3.ascent; + line1.hanging_indent = line3.hanging_indent; + line1.height = line3.height; + line1.indent = line3.indent; + line1.line_no = line3.line_no; + line1.recalc = line3.recalc; + line1.right_indent = line3.right_indent; + line1.ending = line3.ending; + line1.space = line3.space; + line1.tags = line3.tags; + line1.text = line3.text; + line1.widths = line3.widths; + line1.offset = line3.offset; + + tag = line1.tags; + while (tag != null) { + tag.Line = line1; + tag = tag.Next; + } + } + + if (line3.color == LineColor.Black) + RebalanceAfterDelete(line2); + + this.lines--; + } + + // Invalidates the start line until the end of the viewstate + internal void InvalidateLinesAfter (Line start) { + owner.Invalidate (new Rectangle (0, start.Y - viewport_y, viewport_width, viewport_height - start.Y)); + } + + // Invalidate a section of the document to trigger redraw + internal void Invalidate(Line start, int start_pos, Line end, int end_pos) { + Line l1; + Line l2; + int p1; + int p2; + + if ((start == end) && (start_pos == end_pos)) { + return; + } + + if (end_pos == -1) { + end_pos = end.text.Length; + } + + // figure out what's before what so the logic below is straightforward + if (start.line_no < end.line_no) { + l1 = start; + p1 = start_pos; + + l2 = end; + p2 = end_pos; + } else if (start.line_no > end.line_no) { + l1 = end; + p1 = end_pos; + + l2 = start; + p2 = start_pos; + } else { + if (start_pos < end_pos) { + l1 = start; + p1 = start_pos; + + l2 = end; + p2 = end_pos; + } else { + l1 = end; + p1 = end_pos; + + l2 = start; + p2 = start_pos; + } + + int endpoint = (int) l1.widths [p2]; + if (p2 == l1.text.Length + 1) { + endpoint = (int) viewport_width; + } + + #if Debug + Console.WriteLine("Invaliding backwards from {0}:{1} to {2}:{3} {4}", + l1.line_no, p1, l2.line_no, p2, + new Rectangle( + (int)l1.widths[p1] + l1.X - viewport_x, + l1.Y - viewport_y, + (int)l1.widths[p2], + l1.height + ) + ); + #endif + + owner.Invalidate(new Rectangle ( + offset_x + (int)l1.widths[p1] + l1.X - viewport_x, + offset_y + l1.Y - viewport_y, + endpoint - (int) l1.widths [p1] + 1, + l1.height)); + return; + } + + #if Debug + Console.WriteLine("Invaliding from {0}:{1} to {2}:{3} Start => x={4}, y={5}, {6}x{7}", l1.line_no, p1, l2.line_no, p2, (int)l1.widths[p1] + l1.X - viewport_x, l1.Y - viewport_y, viewport_width, l1.height); + Console.WriteLine ("invalidate start line: {0} position: {1}", l1.text, p1); + #endif + + // Three invalidates: + // First line from start + owner.Invalidate(new Rectangle( + offset_x + (int)l1.widths[p1] + l1.X - viewport_x, + offset_y + l1.Y - viewport_y, + viewport_width, + l1.height)); + + + // lines inbetween + if ((l1.line_no + 1) < l2.line_no) { + int y; + + y = GetLine(l1.line_no + 1).Y; + owner.Invalidate(new Rectangle( + offset_x, + offset_y + y - viewport_y, + viewport_width, + l2.Y - y)); + + #if Debug + Console.WriteLine("Invaliding from {0}:{1} to {2}:{3} Middle => x={4}, y={5}, {6}x{7}", l1.line_no, p1, l2.line_no, p2, 0, y - viewport_y, viewport_width, l2.Y - y); + #endif + } + + + // Last line to end + owner.Invalidate(new Rectangle( + offset_x + (int)l2.widths[0] + l2.X - viewport_x, + offset_y + l2.Y - viewport_y, + (int)l2.widths[p2] + 1, + l2.height)); + + #if Debug + Console.WriteLine("Invaliding from {0}:{1} to {2}:{3} End => x={4}, y={5}, {6}x{7}", l1.line_no, p1, l2.line_no, p2, (int)l2.widths[0] + l2.X - viewport_x, l2.Y - viewport_y, (int)l2.widths[p2] + 1, l2.height); + #endif + } + + /// <summary>Select text around caret</summary> + internal void ExpandSelection(CaretSelection mode, bool to_caret) { + if (to_caret) { + // We're expanding the selection to the caret position + switch(mode) { + case CaretSelection.Line: { + // Invalidate the selection delta + if (caret > selection_prev) { + Invalidate(selection_prev.line, 0, caret.line, caret.line.text.Length); + } else { + Invalidate(selection_prev.line, selection_prev.line.text.Length, caret.line, 0); + } + + if (caret.line.line_no <= selection_anchor.line.line_no) { + selection_start.line = caret.line; + selection_start.tag = caret.line.tags; + selection_start.pos = 0; + + selection_end.line = selection_anchor.line; + selection_end.tag = selection_anchor.tag; + selection_end.pos = selection_anchor.pos; + + selection_end_anchor = true; + } else { + selection_start.line = selection_anchor.line; + selection_start.pos = selection_anchor.height; + selection_start.tag = selection_anchor.line.FindTag(selection_anchor.height + 1); + + selection_end.line = caret.line; + selection_end.tag = caret.line.tags; + selection_end.pos = caret.line.text.Length; + + selection_end_anchor = false; + } + selection_prev.line = caret.line; + selection_prev.tag = caret.tag; + selection_prev.pos = caret.pos; + + break; + } + + case CaretSelection.Word: { + int start_pos; + int end_pos; + + start_pos = FindWordSeparator(caret.line, caret.pos, false); + end_pos = FindWordSeparator(caret.line, caret.pos, true); + + + // Invalidate the selection delta + if (caret > selection_prev) { + Invalidate(selection_prev.line, selection_prev.pos, caret.line, end_pos); + } else { + Invalidate(selection_prev.line, selection_prev.pos, caret.line, start_pos); + } + if (caret < selection_anchor) { + selection_start.line = caret.line; + selection_start.tag = caret.line.FindTag(start_pos + 1); + selection_start.pos = start_pos; + + selection_end.line = selection_anchor.line; + selection_end.tag = selection_anchor.tag; + selection_end.pos = selection_anchor.pos; + + selection_prev.line = caret.line; + selection_prev.tag = caret.tag; + selection_prev.pos = start_pos; + + selection_end_anchor = true; + } else { + selection_start.line = selection_anchor.line; + selection_start.pos = selection_anchor.height; + selection_start.tag = selection_anchor.line.FindTag(selection_anchor.height + 1); + + selection_end.line = caret.line; + selection_end.tag = caret.line.FindTag(end_pos); + selection_end.pos = end_pos; + + selection_prev.line = caret.line; + selection_prev.tag = caret.tag; + selection_prev.pos = end_pos; + + selection_end_anchor = false; + } + break; + } + + case CaretSelection.Position: { + SetSelectionToCaret(false); + return; + } + } + } else { + // We're setting the selection 'around' the caret position + switch(mode) { + case CaretSelection.Line: { + this.Invalidate(caret.line, 0, caret.line, caret.line.text.Length); + + selection_start.line = caret.line; + selection_start.tag = caret.line.tags; + selection_start.pos = 0; + + selection_end.line = caret.line; + selection_end.pos = caret.line.text.Length; + selection_end.tag = caret.line.FindTag(selection_end.pos); + + selection_anchor.line = selection_end.line; + selection_anchor.tag = selection_end.tag; + selection_anchor.pos = selection_end.pos; + selection_anchor.height = 0; + + selection_prev.line = caret.line; + selection_prev.tag = caret.tag; + selection_prev.pos = caret.pos; + + this.selection_end_anchor = true; + + break; + } + + case CaretSelection.Word: { + int start_pos; + int end_pos; + + start_pos = FindWordSeparator(caret.line, caret.pos, false); + end_pos = FindWordSeparator(caret.line, caret.pos, true); + + this.Invalidate(selection_start.line, start_pos, caret.line, end_pos); + + selection_start.line = caret.line; + selection_start.tag = caret.line.FindTag(start_pos + 1); + selection_start.pos = start_pos; + + selection_end.line = caret.line; + selection_end.tag = caret.line.FindTag(end_pos); + selection_end.pos = end_pos; + + selection_anchor.line = selection_end.line; + selection_anchor.tag = selection_end.tag; + selection_anchor.pos = selection_end.pos; + selection_anchor.height = start_pos; + + selection_prev.line = caret.line; + selection_prev.tag = caret.tag; + selection_prev.pos = caret.pos; + + this.selection_end_anchor = true; + + break; + } + } + } + + SetSelectionVisible (!(selection_start == selection_end)); + } + + internal void SetSelectionToCaret(bool start) { + if (start) { + // Invalidate old selection; selection is being reset to empty + this.Invalidate(selection_start.line, selection_start.pos, selection_end.line, selection_end.pos); + + selection_start.line = caret.line; + selection_start.tag = caret.tag; + selection_start.pos = caret.pos; + + // start always also selects end + selection_end.line = caret.line; + selection_end.tag = caret.tag; + selection_end.pos = caret.pos; + + selection_anchor.line = caret.line; + selection_anchor.tag = caret.tag; + selection_anchor.pos = caret.pos; + } else { + // Invalidate from previous end to caret (aka new end) + if (selection_end_anchor) { + if (selection_start != caret) { + this.Invalidate(selection_start.line, selection_start.pos, caret.line, caret.pos); + } + } else { + if (selection_end != caret) { + this.Invalidate(selection_end.line, selection_end.pos, caret.line, caret.pos); + } + } + + if (caret < selection_anchor) { + selection_start.line = caret.line; + selection_start.tag = caret.tag; + selection_start.pos = caret.pos; + + selection_end.line = selection_anchor.line; + selection_end.tag = selection_anchor.tag; + selection_end.pos = selection_anchor.pos; + + selection_end_anchor = true; + } else { + selection_start.line = selection_anchor.line; + selection_start.tag = selection_anchor.tag; + selection_start.pos = selection_anchor.pos; + + selection_end.line = caret.line; + selection_end.tag = caret.tag; + selection_end.pos = caret.pos; + + selection_end_anchor = false; + } + } + + SetSelectionVisible (!(selection_start == selection_end)); + } + + internal void SetSelection(Line start, int start_pos, Line end, int end_pos) { + if (selection_visible) { + Invalidate(selection_start.line, selection_start.pos, selection_end.line, selection_end.pos); + } + + if ((end.line_no < start.line_no) || ((end == start) && (end_pos <= start_pos))) { + selection_start.line = end; + selection_start.tag = LineTag.FindTag(end, end_pos); + selection_start.pos = end_pos; + + selection_end.line = start; + selection_end.tag = LineTag.FindTag(start, start_pos); + selection_end.pos = start_pos; + + selection_end_anchor = true; + } else { + selection_start.line = start; + selection_start.tag = LineTag.FindTag(start, start_pos); + selection_start.pos = start_pos; + + selection_end.line = end; + selection_end.tag = LineTag.FindTag(end, end_pos); + selection_end.pos = end_pos; + + selection_end_anchor = false; + } + + selection_anchor.line = start; + selection_anchor.tag = selection_start.tag; + selection_anchor.pos = start_pos; + + if (((start == end) && (start_pos == end_pos)) || start == null || end == null) { + SetSelectionVisible (false); + } else { + SetSelectionVisible (true); + Invalidate(selection_start.line, selection_start.pos, selection_end.line, selection_end.pos); + } + } + + internal void SetSelectionStart(Line start, int start_pos, bool invalidate) { + // Invalidate from the previous to the new start pos + if (invalidate) + Invalidate(selection_start.line, selection_start.pos, start, start_pos); + + selection_start.line = start; + selection_start.pos = start_pos; + selection_start.tag = LineTag.FindTag(start, start_pos); + + selection_anchor.line = start; + selection_anchor.pos = start_pos; + selection_anchor.tag = selection_start.tag; + + selection_end_anchor = false; + + + if ((selection_end.line != selection_start.line) || (selection_end.pos != selection_start.pos)) { + SetSelectionVisible (true); + } else { + SetSelectionVisible (false); + } + + if (invalidate) + Invalidate(selection_start.line, selection_start.pos, selection_end.line, selection_end.pos); + } + + internal void SetSelectionStart(int character_index, bool invalidate) { + Line line; + LineTag tag; + int pos; + + if (character_index < 0) { + return; + } + + CharIndexToLineTag(character_index, out line, out tag, out pos); + SetSelectionStart(line, pos, invalidate); + } + + internal void SetSelectionEnd(Line end, int end_pos, bool invalidate) { + + if (end == selection_end.line && end_pos == selection_start.pos) { + selection_anchor.line = selection_start.line; + selection_anchor.tag = selection_start.tag; + selection_anchor.pos = selection_start.pos; + + selection_end.line = selection_start.line; + selection_end.tag = selection_start.tag; + selection_end.pos = selection_start.pos; + + selection_end_anchor = false; + } else if ((end.line_no < selection_anchor.line.line_no) || ((end == selection_anchor.line) && (end_pos <= selection_anchor.pos))) { + selection_start.line = end; + selection_start.tag = LineTag.FindTag(end, end_pos); + selection_start.pos = end_pos; + + selection_end.line = selection_anchor.line; + selection_end.tag = selection_anchor.tag; + selection_end.pos = selection_anchor.pos; + + selection_end_anchor = true; + } else { + selection_start.line = selection_anchor.line; + selection_start.tag = selection_anchor.tag; + selection_start.pos = selection_anchor.pos; + + selection_end.line = end; + selection_end.tag = LineTag.FindTag(end, end_pos); + selection_end.pos = end_pos; + + selection_end_anchor = false; + } + + if ((selection_end.line != selection_start.line) || (selection_end.pos != selection_start.pos)) { + SetSelectionVisible (true); + if (invalidate) + Invalidate(selection_start.line, selection_start.pos, selection_end.line, selection_end.pos); + } else { + SetSelectionVisible (false); + // ?? Do I need to invalidate here, tests seem to work without it, but I don't think they should :-s + } + } + + internal void SetSelectionEnd(int character_index, bool invalidate) { + Line line; + LineTag tag; + int pos; + + if (character_index < 0) { + return; + } + + CharIndexToLineTag(character_index, out line, out tag, out pos); + SetSelectionEnd(line, pos, invalidate); + } + + internal void SetSelection(Line start, int start_pos) { + if (selection_visible) { + Invalidate(selection_start.line, selection_start.pos, selection_end.line, selection_end.pos); + } + + selection_start.line = start; + selection_start.pos = start_pos; + selection_start.tag = LineTag.FindTag(start, start_pos); + + selection_end.line = start; + selection_end.tag = selection_start.tag; + selection_end.pos = start_pos; + + selection_anchor.line = start; + selection_anchor.tag = selection_start.tag; + selection_anchor.pos = start_pos; + + selection_end_anchor = false; + SetSelectionVisible (false); + } + + internal void InvalidateSelectionArea() { + Invalidate (selection_start.line, selection_start.pos, selection_end.line, selection_end.pos); + } + + // Return the current selection, as string + internal string GetSelection() { + // We return String.Empty if there is no selection + if ((selection_start.pos == selection_end.pos) && (selection_start.line == selection_end.line)) { + return string.Empty; + } + + if (selection_start.line == selection_end.line) { + return selection_start.line.text.ToString (selection_start.pos, selection_end.pos - selection_start.pos); + } else { + StringBuilder sb; + int i; + int start; + int end; + + sb = new StringBuilder(); + start = selection_start.line.line_no; + end = selection_end.line.line_no; + + sb.Append(selection_start.line.text.ToString(selection_start.pos, selection_start.line.text.Length - selection_start.pos)); + + if ((start + 1) < end) { + for (i = start + 1; i < end; i++) { + sb.Append(GetLine(i).text.ToString()); + } + } + + sb.Append(selection_end.line.text.ToString(0, selection_end.pos)); + + return sb.ToString(); + } + } + + internal void ReplaceSelection(string s, bool select_new) { + int i; + + int selection_start_pos = LineTagToCharIndex (selection_start.line, selection_start.pos); + SuspendRecalc (); + + // First, delete any selected text + if ((selection_start.pos != selection_end.pos) || (selection_start.line != selection_end.line)) { + if (selection_start.line == selection_end.line) { + undo.RecordDeleteString (selection_start.line, selection_start.pos, selection_end.line, selection_end.pos); + + DeleteChars (selection_start.line, selection_start.pos, selection_end.pos - selection_start.pos); + + // The tag might have been removed, we need to recalc it + selection_start.tag = selection_start.line.FindTag(selection_start.pos + 1); + } else { + int start; + int end; + + start = selection_start.line.line_no; + end = selection_end.line.line_no; + + undo.RecordDeleteString (selection_start.line, selection_start.pos, selection_end.line, selection_end.pos); + + InvalidateLinesAfter(selection_start.line); + + // Delete first line + DeleteChars (selection_start.line, selection_start.pos, selection_start.line.text.Length - selection_start.pos); + selection_start.line.recalc = true; + + // Delete last line + DeleteChars(selection_end.line, 0, selection_end.pos); + + start++; + if (start < end) { + for (i = end - 1; i >= start; i--) { + Delete(i); + } + } + + // BIG FAT WARNING - selection_end.line might be stale due + // to the above Delete() call. DONT USE IT before hitting the end of this method! + + // Join start and end + Combine(selection_start.line.line_no, start); + } + } + + + Insert(selection_start.line, selection_start.pos, false, s); + undo.RecordInsertString (selection_start.line, selection_start.pos, s); + ResumeRecalc (false); + + Line begin_update_line = selection_start.line; + int begin_update_pos = selection_start.pos; + + if (!select_new) { + CharIndexToLineTag(selection_start_pos + s.Length, out selection_start.line, + out selection_start.tag, out selection_start.pos); + + selection_end.line = selection_start.line; + selection_end.pos = selection_start.pos; + selection_end.tag = selection_start.tag; + selection_anchor.line = selection_start.line; + selection_anchor.pos = selection_start.pos; + selection_anchor.tag = selection_start.tag; + + SetSelectionVisible (false); + } else { + CharIndexToLineTag(selection_start_pos, out selection_start.line, + out selection_start.tag, out selection_start.pos); + + CharIndexToLineTag(selection_start_pos + s.Length, out selection_end.line, + out selection_end.tag, out selection_end.pos); + + selection_anchor.line = selection_start.line; + selection_anchor.pos = selection_start.pos; + selection_anchor.tag = selection_start.tag; + + SetSelectionVisible (true); + } + + PositionCaret (selection_start.line, selection_start.pos); + UpdateView (begin_update_line, selection_end.line.line_no - begin_update_line.line_no, begin_update_pos); + } + + internal void CharIndexToLineTag(int index, out Line line_out, out LineTag tag_out, out int pos) { + Line line; + LineTag tag; + int i; + int chars; + int start; + + chars = 0; + + for (i = 1; i <= lines; i++) { + line = GetLine(i); + + start = chars; + chars += line.text.Length; + + if (index <= chars) { + // we found the line + tag = line.tags; + + while (tag != null) { + if (index < (start + tag.Start + tag.Length - 1)) { + line_out = line; + tag_out = LineTag.GetFinalTag (tag); + pos = index - start; + return; + } + if (tag.Next == null) { + Line next_line; + + next_line = GetLine(line.line_no + 1); + + if (next_line != null) { + line_out = next_line; + tag_out = LineTag.GetFinalTag (next_line.tags); + pos = 0; + return; + } else { + line_out = line; + tag_out = LineTag.GetFinalTag (tag); + pos = line_out.text.Length; + return; + } + } + tag = tag.Next; + } + } + } + + line_out = GetLine(lines); + tag = line_out.tags; + while (tag.Next != null) { + tag = tag.Next; + } + tag_out = tag; + pos = line_out.text.Length; + } + + internal int LineTagToCharIndex(Line line, int pos) { + int i; + int length; + + // Count first and last line + length = 0; + + // Count the lines in the middle + + for (i = 1; i < line.line_no; i++) { + length += GetLine(i).text.Length; + } + + length += pos; + + return length; + } + + internal int SelectionLength() { + if ((selection_start.pos == selection_end.pos) && (selection_start.line == selection_end.line)) { + return 0; + } + + if (selection_start.line == selection_end.line) { + return selection_end.pos - selection_start.pos; + } else { + int i; + int start; + int end; + int length; + + // Count first and last line + length = selection_start.line.text.Length - selection_start.pos + selection_end.pos + crlf_size; + + // Count the lines in the middle + start = selection_start.line.line_no + 1; + end = selection_end.line.line_no; + + if (start < end) { + for (i = start; i < end; i++) { + Line line = GetLine (i); + length += line.text.Length + LineEndingLength (line.ending); + } + } + + return length; + } + + + } + + + // UIA: Method used via reflection in TextRangeProvider + + /// <summary>Give it a Line number and it returns the Line object at with that line number</summary> + internal Line GetLine(int LineNo) { + Line line = document; + + while (line != sentinel) { + if (LineNo == line.line_no) { + return line; + } else if (LineNo < line.line_no) { + line = line.left; + } else { + line = line.right; + } + } + + return null; + } + + /// <summary>Retrieve the previous tag; walks line boundaries</summary> + internal LineTag PreviousTag(LineTag tag) { + Line l; + + if (tag.Previous != null) { + return tag.Previous; + } + + // Next line + if (tag.Line.line_no == 1) { + return null; + } + + l = GetLine(tag.Line.line_no - 1); + if (l != null) { + LineTag t; + + t = l.tags; + while (t.Next != null) { + t = t.Next; + } + return t; + } + + return null; + } + + /// <summary>Retrieve the next tag; walks line boundaries</summary> + internal LineTag NextTag(LineTag tag) { + Line l; + + if (tag.Next != null) { + return tag.Next; + } + + // Next line + l = GetLine(tag.Line.line_no + 1); + if (l != null) { + return l.tags; + } + + return null; + } + + internal Line ParagraphStart(Line line) { + Line lastline = line; + do { + if (line.line_no <= 1) + break; + + line = lastline; + lastline = GetLine (line.line_no - 1); + } while (lastline.ending == LineEnding.Wrap); + + return line; + } + + internal Line ParagraphEnd(Line line) { + Line l; + + while (line.ending == LineEnding.Wrap) { + l = GetLine(line.line_no + 1); + if ((l == null) || (l.ending != LineEnding.Wrap)) { + break; + } + line = l; + } + return line; + } + + /// <summary>Give it a pixel offset coordinate and it returns the Line covering that are (offset + /// is either X or Y depending on if we are multiline + /// </summary> + internal Line GetLineByPixel (int offset, bool exact) + { + Line line = document; + Line last = null; + + if (multiline) { + while (line != sentinel) { + last = line; + if ((offset >= line.Y) && (offset < (line.Y+line.height))) { + return line; + } else if (offset < line.Y) { + line = line.left; + } else { + line = line.right; + } + } + } else { + while (line != sentinel) { + last = line; + if ((offset >= line.X) && (offset < (line.X + line.Width))) + return line; + else if (offset < line.X) + line = line.left; + else + line = line.right; + } + } + + if (exact) { + return null; + } + return last; + } + + // UIA: Method used via reflection in TextProviderBehavior + + // Give it x/y pixel coordinates and it returns the Tag at that position + internal LineTag FindCursor (int x, int y, out int index) + { + Line line; + + x -= offset_x; + y -= offset_y; + + line = GetLineByPixel (multiline ? y : x, false); + + LineTag tag = line.GetTag (x); + + if (tag.Length == 0 && tag.Start == 1) + index = 0; + else + index = tag.GetCharIndex (x - line.align_shift); + + return tag; + } + + /// <summary>Format area of document in specified font and color</summary> + /// <param name="start_pos">1-based start position on start_line</param> + /// <param name="end_pos">1-based end position on end_line </param> + internal void FormatText (Line start_line, int start_pos, Line end_line, int end_pos, Font font, + Color color, Color back_color, FormatSpecified specified) + { + Line l; + + // First, format the first line + if (start_line != end_line) { + // First line + LineTag.FormatText(start_line, start_pos, start_line.text.Length - start_pos + 1, font, color, back_color, specified); + + // Format last line + LineTag.FormatText(end_line, 1, end_pos, font, color, back_color, specified); + + // Now all the lines inbetween + for (int i = start_line.line_no + 1; i < end_line.line_no; i++) { + l = GetLine(i); + LineTag.FormatText(l, 1, l.text.Length, font, color, back_color, specified); + } + } else { + // Special case, single line + LineTag.FormatText(start_line, start_pos, end_pos - start_pos, font, color, back_color, specified); + + if ((end_pos - start_pos) == 0 && CaretTag.Length != 0) + CaretTag = CaretTag.Next; + } + } + + internal void RecalculateAlignments () + { + Line line; + int line_no; + + line_no = 1; + + + + while (line_no <= lines) { + line = GetLine(line_no); + + if (line != null) { + switch (line.alignment) { + case HorizontalAlignment.Left: + line.align_shift = 0; + break; + case HorizontalAlignment.Center: + line.align_shift = (viewport_width - (int)line.widths[line.text.Length]) / 2; + break; + case HorizontalAlignment.Right: + line.align_shift = viewport_width - (int)line.widths[line.text.Length] - right_margin; + break; + } + } + + line_no++; + } + return; + } + + /// <summary>Calculate formatting for the whole document</summary> + internal bool RecalculateDocument(Graphics g) { + return RecalculateDocument(g, 1, this.lines, false); + } + + /// <summary>Calculate formatting starting at a certain line</summary> + internal bool RecalculateDocument(Graphics g, int start) { + return RecalculateDocument(g, start, this.lines, false); + } + + /// <summary>Calculate formatting within two given line numbers</summary> + internal bool RecalculateDocument(Graphics g, int start, int end) { + return RecalculateDocument(g, start, end, false); + } + + /// <summary>With optimize on, returns true if line heights changed</summary> + internal bool RecalculateDocument(Graphics g, int start, int end, bool optimize) { + Line line; + int line_no; + int offset; + int new_width; + bool changed; + int shift; + + if (recalc_suspended > 0) { + recalc_pending = true; + recalc_start = Math.Min (recalc_start, start); + recalc_end = Math.Max (recalc_end, end); + recalc_optimize = optimize; + return false; + } + + // Fixup the positions, they can go kinda nuts + // (this is suspend and resume recalc - they set them to 1 and max) + start = Math.Max (start, 1); + end = Math.Min (end, lines); + + offset = GetLine(start).offset; + line_no = start; + new_width = 0; + shift = this.lines; + if (!optimize) { + changed = true; // We always return true if we run non-optimized + } else { + changed = false; + } + + while (line_no <= (end + this.lines - shift)) { + line = GetLine(line_no++); + line.offset = offset; + + // if we are not calculating a password + if (!calc_pass) { + if (!optimize) { + line.RecalculateLine(g, this); + } else { + if (line.recalc && line.RecalculateLine(g, this)) { + changed = true; + // If the height changed, all subsequent lines change + end = this.lines; + shift = this.lines; + } + } + } else { + if (!optimize) { + line.RecalculatePasswordLine(g, this); + } else { + if (line.recalc && line.RecalculatePasswordLine(g, this)) { + changed = true; + // If the height changed, all subsequent lines change + end = this.lines; + shift = this.lines; + } + } + } + + if (line.widths[line.text.Length] > new_width) { + new_width = (int)line.widths[line.text.Length]; + } + + // Calculate alignment + if (line.alignment != HorizontalAlignment.Left) { + if (line.alignment == HorizontalAlignment.Center) { + line.align_shift = (viewport_width - (int)line.widths[line.text.Length]) / 2; + } else { + line.align_shift = viewport_width - (int)line.widths[line.text.Length] - 1; + } + } + + if (multiline) + offset += line.height; + else + offset += (int) line.widths [line.text.Length]; + + if (line_no > lines) { + break; + } + } + + if (document_x != new_width) { + document_x = new_width; + if (WidthChanged != null) { + WidthChanged(this, null); + } + } + + RecalculateAlignments(); + + line = GetLine(lines); + + if (document_y != line.Y + line.height) { + document_y = line.Y + line.height; + if (HeightChanged != null) { + HeightChanged(this, null); + } + } + + // scan for links and tell us if its all + // changed, so we can update everything + if (EnableLinks) + ScanForLinks (start, end, ref changed); + + UpdateCaret(); + return changed; + } + + internal int Size() { + return lines; + } + + private void owner_HandleCreated(object sender, EventArgs e) { + RecalculateDocument(owner.CreateGraphicsInternal()); + AlignCaret(); + } + + private void owner_VisibleChanged(object sender, EventArgs e) { + if (owner.Visible) { + RecalculateDocument(owner.CreateGraphicsInternal()); + } + } + + internal static bool IsWordSeparator (char ch) + { + switch (ch) { + case ' ': + case '\t': + case '(': + case ')': + case '\r': + case '\n': + return true; + default: + return false; + } + } + + internal int FindWordSeparator(Line line, int pos, bool forward) { + int len; + + len = line.text.Length; + + if (forward) { + for (int i = pos + 1; i < len; i++) { + if (IsWordSeparator(line.Text[i])) { + return i + 1; + } + } + return len; + } else { + for (int i = pos - 1; i > 0; i--) { + if (IsWordSeparator(line.Text[i - 1])) { + return i; + } + } + return 0; + } + } + + /* Search document for text */ + internal bool FindChars(char[] chars, Marker start, Marker end, out Marker result) { + Line line; + int line_no; + int pos; + int line_len; + + // Search for occurence of any char in the chars array + result = new Marker(); + + line = start.line; + line_no = start.line.line_no; + pos = start.pos; + while (line_no <= end.line.line_no) { + line_len = line.text.Length; + while (pos < line_len) { + for (int i = 0; i < chars.Length; i++) { + if (line.text[pos] == chars[i]) { + // Special case + if ((line.line_no == end.line.line_no) && (pos >= end.pos)) { + return false; + } + + result.line = line; + result.pos = pos; + return true; + } + } + pos++; + } + + pos = 0; + line_no++; + line = GetLine(line_no); + } + + return false; + } + + // This version does not build one big string for searching, instead it handles + // line-boundaries, which is faster and less memory intensive + // FIXME - Depending on culture stuff we might have to create a big string and use culturespecific + // search stuff and change it to accept and return positions instead of Markers (which would match + // RichTextBox behaviour better but would be inconsistent with the rest of TextControl) + internal bool Find(string search, Marker start, Marker end, out Marker result, RichTextBoxFinds options) { + Marker last; + string search_string; + Line line; + int line_no; + int pos; + int line_len; + int current; + bool word; + bool word_option; + bool ignore_case; + bool reverse; + char c; + + result = new Marker(); + word_option = ((options & RichTextBoxFinds.WholeWord) != 0); + ignore_case = ((options & RichTextBoxFinds.MatchCase) == 0); + reverse = ((options & RichTextBoxFinds.Reverse) != 0); + + line = start.line; + line_no = start.line.line_no; + pos = start.pos; + current = 0; + + // Prep our search string, lowercasing it if we do case-independent matching + if (ignore_case) { + StringBuilder sb; + sb = new StringBuilder(search); + for (int i = 0; i < sb.Length; i++) { + sb[i] = Char.ToLower(sb[i]); + } + search_string = sb.ToString(); + } else { + search_string = search; + } + + // We need to check if the character before our start position is a wordbreak + if (word_option) { + if (line_no == 1) { + if ((pos == 0) || (IsWordSeparator(line.text[pos - 1]))) { + word = true; + } else { + word = false; + } + } else { + if (pos > 0) { + if (IsWordSeparator(line.text[pos - 1])) { + word = true; + } else { + word = false; + } + } else { + // Need to check the end of the previous line + Line prev_line; + + prev_line = GetLine(line_no - 1); + if (prev_line.ending == LineEnding.Wrap) { + if (IsWordSeparator(prev_line.text[prev_line.text.Length - 1])) { + word = true; + } else { + word = false; + } + } else { + word = true; + } + } + } + } else { + word = false; + } + + // To avoid duplication of this loop with reverse logic, we search + // through the document, remembering the last match and when returning + // report that last remembered match + + last = new Marker(); + last.height = -1; // Abused - we use it to track change + + while (line_no <= end.line.line_no) { + if (line_no != end.line.line_no) { + line_len = line.text.Length; + } else { + line_len = end.pos; + } + + while (pos < line_len) { + + if (word_option && (current == search_string.Length)) { + if (IsWordSeparator(line.text[pos])) { + if (!reverse) { + goto FindFound; + } else { + last = result; + current = 0; + } + } else { + current = 0; + } + } + + if (ignore_case) { + c = Char.ToLower(line.text[pos]); + } else { + c = line.text[pos]; + } + + if (c == search_string[current]) { + + if (current == 0) { + result.line = line; + result.pos = pos; + } + if (!word_option || (word_option && (word || (current > 0)))) { + current++; + } + + if (!word_option && (current == search_string.Length)) { + if (!reverse) { + goto FindFound; + } else { + last = result; + current = 0; + } + } + } else { + current = 0; + } + pos++; + + if (!word_option) { + continue; + } + + if (IsWordSeparator(c)) { + word = true; + } else { + word = false; + } + } + + if (word_option) { + // Mark that we just saw a word boundary + if (line.ending != LineEnding.Wrap || line.line_no == lines - 1) { + word = true; + } + + if (current == search_string.Length) { + if (word) { + if (!reverse) { + goto FindFound; + } else { + last = result; + current = 0; + } + } else { + current = 0; + } + } + } + + pos = 0; + line_no++; + line = GetLine(line_no); + } + + if (reverse) { + if (last.height != -1) { + result = last; + return true; + } + } + + return false; + + FindFound: + if (!reverse) { +// if ((line.line_no == end.line.line_no) && (pos >= end.pos)) { +// return false; +// } + return true; + } + + result = last; + return true; + + } + + /* Marker stuff */ + internal void GetMarker(out Marker mark, bool start) { + mark = new Marker(); + + if (start) { + mark.line = GetLine(1); + mark.tag = mark.line.tags; + mark.pos = 0; + } else { + mark.line = GetLine(lines); + mark.tag = mark.line.tags; + while (mark.tag.Next != null) { + mark.tag = mark.tag.Next; + } + mark.pos = mark.line.text.Length; + } + } + #endregion // Internal Methods + + #region Events + internal event EventHandler CaretMoved; + internal event EventHandler WidthChanged; + internal event EventHandler HeightChanged; + internal event EventHandler LengthChanged; + internal event EventHandler UIASelectionChanged; + #endregion // Events + + #region Administrative + public IEnumerator GetEnumerator() { + // FIXME + return null; + } + + public override bool Equals(object obj) { + if (obj == null) { + return false; + } + + if (!(obj is Document)) { + return false; + } + + if (obj == this) { + return true; + } + + if (ToString().Equals(((Document)obj).ToString())) { + return true; + } + + return false; + } + + public override int GetHashCode() { + return document_id; + } + + public override string ToString() { + return "document " + this.document_id; + } + #endregion // Administrative + } + + internal class PictureTag : LineTag { + + internal RTF.Picture picture; + + internal PictureTag (Line line, int start, RTF.Picture picture) : base (line, start) + { + this.picture = picture; + } + + public override bool IsTextTag { + get { return false; } + } + + public override SizeF SizeOfPosition (Graphics dc, int pos) + { + return picture.Size; + } + + internal override int MaxHeight () + { + return (int) (picture.Height + 0.5F); + } + + public override void Draw (Graphics dc, Color color, float xoff, float y, int start, int end) + { + picture.DrawImage (dc, xoff + Line.widths [start], y, false); + } + + public override void Draw (Graphics dc, Color color, float xoff, float y, int start, int end, string text) + { + picture.DrawImage (dc, xoff + + Line.widths [start], y, false); + } + + public override string Text () + { + return "I"; + } + } + + internal class UndoManager { + + internal enum ActionType { + + Typing, + + // This is basically just cut & paste + InsertString, + DeleteString, + + UserActionBegin, + UserActionEnd + } + + internal class Action { + internal ActionType type; + internal int line_no; + internal int pos; + internal object data; + } + + #region Local Variables + private Document document; + private Stack undo_actions; + private Stack redo_actions; + + //private int caret_line; + //private int caret_pos; + + // When performing an action, we lock the queue, so that the action can't be undone + private bool locked; + #endregion // Local Variables + + #region Constructors + internal UndoManager (Document document) + { + this.document = document; + undo_actions = new Stack (50); + redo_actions = new Stack (50); + } + #endregion // Constructors + + #region Properties + internal bool CanUndo { + get { return undo_actions.Count > 0; } + } + + internal bool CanRedo { + get { return redo_actions.Count > 0; } + } + + internal string UndoActionName { + get { + foreach (Action action in undo_actions) { + if (action.type == ActionType.UserActionBegin) + return (string) action.data; + if (action.type == ActionType.Typing) + return String.Format ("Typing"); + } + return String.Empty; + } + } + + internal string RedoActionName { + get { + foreach (Action action in redo_actions) { + if (action.type == ActionType.UserActionBegin) + return (string) action.data; + if (action.type == ActionType.Typing) + return String.Format ("Typing"); + } + return String.Empty; + } + } + #endregion // Properties + + #region Internal Methods + internal void Clear () + { + undo_actions.Clear(); + redo_actions.Clear(); + } + + internal bool Undo () + { + Action action; + bool user_action_finished = false; + + if (undo_actions.Count == 0) + return false; + + locked = true; + do { + Line start; + action = (Action) undo_actions.Pop (); + + // Put onto redo stack + redo_actions.Push(action); + + // Do the thing + switch(action.type) { + + case ActionType.UserActionBegin: + user_action_finished = true; + break; + + case ActionType.UserActionEnd: + // noop + break; + + case ActionType.InsertString: + start = document.GetLine (action.line_no); + document.SuspendUpdate (); + document.DeleteMultiline (start, action.pos, ((string) action.data).Length + 1); + document.PositionCaret (start, action.pos); + document.SetSelectionToCaret (true); + document.ResumeUpdate (true); + break; + + case ActionType.Typing: + start = document.GetLine (action.line_no); + document.SuspendUpdate (); + document.DeleteMultiline (start, action.pos, ((StringBuilder) action.data).Length); + document.PositionCaret (start, action.pos); + document.SetSelectionToCaret (true); + document.ResumeUpdate (true); + + // This is an open ended operation, so only a single typing operation can be undone at once + user_action_finished = true; + break; + + case ActionType.DeleteString: + start = document.GetLine (action.line_no); + document.SuspendUpdate (); + Insert (start, action.pos, (Line) action.data, true); + document.ResumeUpdate (true); + break; + } + } while (!user_action_finished && undo_actions.Count > 0); + + locked = false; + + return true; + } + + internal bool Redo () + { + Action action; + bool user_action_finished = false; + + if (redo_actions.Count == 0) + return false; + + locked = true; + do { + Line start; + int start_index; + + action = (Action) redo_actions.Pop (); + undo_actions.Push (action); + + switch (action.type) { + + case ActionType.UserActionBegin: + // Noop + break; + + case ActionType.UserActionEnd: + user_action_finished = true; + break; + + case ActionType.InsertString: + start = document.GetLine (action.line_no); + document.SuspendUpdate (); + start_index = document.LineTagToCharIndex (start, action.pos); + document.InsertString (start, action.pos, (string) action.data); + document.CharIndexToLineTag (start_index + ((string) action.data).Length, + out document.caret.line, out document.caret.tag, + out document.caret.pos); + document.UpdateCaret (); + document.SetSelectionToCaret (true); + document.ResumeUpdate (true); + break; + + case ActionType.Typing: + start = document.GetLine (action.line_no); + document.SuspendUpdate (); + start_index = document.LineTagToCharIndex (start, action.pos); + document.InsertString (start, action.pos, ((StringBuilder) action.data).ToString ()); + document.CharIndexToLineTag (start_index + ((StringBuilder) action.data).Length, + out document.caret.line, out document.caret.tag, + out document.caret.pos); + document.UpdateCaret (); + document.SetSelectionToCaret (true); + document.ResumeUpdate (true); + + // This is an open ended operation, so only a single typing operation can be undone at once + user_action_finished = true; + break; + + case ActionType.DeleteString: + start = document.GetLine (action.line_no); + document.SuspendUpdate (); + document.DeleteMultiline (start, action.pos, ((Line) action.data).text.Length); + document.PositionCaret (start, action.pos); + document.SetSelectionToCaret (true); + document.ResumeUpdate (true); + + break; + } + } while (!user_action_finished && redo_actions.Count > 0); + + locked = false; + + return true; + } + #endregion // Internal Methods + + #region Private Methods + + public void BeginUserAction (string name) + { + if (locked) + return; + + // Nuke the redo queue + redo_actions.Clear (); + + Action ua = new Action (); + ua.type = ActionType.UserActionBegin; + ua.data = name; + + undo_actions.Push (ua); + } + + public void EndUserAction () + { + if (locked) + return; + + Action ua = new Action (); + ua.type = ActionType.UserActionEnd; + + undo_actions.Push (ua); + } + + // start_pos, end_pos = 1 based + public void RecordDeleteString (Line start_line, int start_pos, Line end_line, int end_pos) + { + if (locked) + return; + + // Nuke the redo queue + redo_actions.Clear (); + + Action a = new Action (); + + // We cant simply store the string, because then formatting would be lost + a.type = ActionType.DeleteString; + a.line_no = start_line.line_no; + a.pos = start_pos; + a.data = Duplicate (start_line, start_pos, end_line, end_pos); + + undo_actions.Push(a); + } + + public void RecordInsertString (Line line, int pos, string str) + { + if (locked || str.Length == 0) + return; + + // Nuke the redo queue + redo_actions.Clear (); + + Action a = new Action (); + + a.type = ActionType.InsertString; + a.data = str; + a.line_no = line.line_no; + a.pos = pos; + + undo_actions.Push (a); + } + + public void RecordTyping (Line line, int pos, char ch) + { + if (locked) + return; + + // Nuke the redo queue + redo_actions.Clear (); + + Action a = null; + + if (undo_actions.Count > 0) + a = (Action) undo_actions.Peek (); + + if (a == null || a.type != ActionType.Typing) { + a = new Action (); + a.type = ActionType.Typing; + a.data = new StringBuilder (); + a.line_no = line.line_no; + a.pos = pos; + + undo_actions.Push (a); + } + + StringBuilder data = (StringBuilder) a.data; + data.Append (ch); + } + + // start_pos = 1-based + // end_pos = 1-based + public Line Duplicate(Line start_line, int start_pos, Line end_line, int end_pos) + { + Line ret; + Line line; + Line current; + LineTag tag; + LineTag current_tag; + int start; + int end; + int tag_start; + + line = new Line (start_line.document, start_line.ending); + ret = line; + + for (int i = start_line.line_no; i <= end_line.line_no; i++) { + current = document.GetLine(i); + + if (start_line.line_no == i) { + start = start_pos; + } else { + start = 0; + } + + if (end_line.line_no == i) { + end = end_pos; + } else { + end = current.text.Length; + } + + if (end_pos == 0) + continue; + + // Text for the tag + line.text = new StringBuilder (current.text.ToString (start, end - start)); + + // Copy tags from start to start+length onto new line + current_tag = current.FindTag (start + 1); + while ((current_tag != null) && (current_tag.Start <= end)) { + if ((current_tag.Start <= start) && (start < (current_tag.Start + current_tag.Length))) { + // start tag is within this tag + tag_start = start; + } else { + tag_start = current_tag.Start; + } + + tag = new LineTag(line, tag_start - start + 1); + tag.CopyFormattingFrom (current_tag); + + current_tag = current_tag.Next; + + // Add the new tag to the line + if (line.tags == null) { + line.tags = tag; + } else { + LineTag tail; + tail = line.tags; + + while (tail.Next != null) { + tail = tail.Next; + } + tail.Next = tag; + tag.Previous = tail; + } + } + + if ((i + 1) <= end_line.line_no) { + line.ending = current.ending; + + // Chain them (we use right/left as next/previous) + line.right = new Line (start_line.document, start_line.ending); + line.right.left = line; + line = line.right; + } + } + + return ret; + } + + // Insert multi-line text at the given position; use formatting at insertion point for inserted text + internal void Insert(Line line, int pos, Line insert, bool select) + { + Line current; + LineTag tag; + int offset; + int lines; + Line first; + + // Handle special case first + if (insert.right == null) { + + // Single line insert + document.Split(line, pos); + + if (insert.tags == null) { + return; // Blank line + } + + //Insert our tags at the end + tag = line.tags; + + while (tag.Next != null) { + tag = tag.Next; + } + + offset = tag.Start + tag.Length - 1; + + tag.Next = insert.tags; + line.text.Insert(offset, insert.text.ToString()); + + // Adjust start locations + tag = tag.Next; + while (tag != null) { + tag.Start += offset; + tag.Line = line; + tag = tag.Next; + } + // Put it back together + document.Combine(line.line_no, line.line_no + 1); + + if (select) { + document.SetSelectionStart (line, pos, false); + document.SetSelectionEnd (line, pos + insert.text.Length, false); + } + + document.UpdateView(line, pos); + return; + } + + first = line; + lines = 1; + current = insert; + + while (current != null) { + + if (current == insert) { + // Inserting the first line we split the line (and make space) + document.Split(line.line_no, pos); + //Insert our tags at the end of the line + tag = line.tags; + + + if (tag != null && tag.Length != 0) { + while (tag.Next != null) { + tag = tag.Next; + } + offset = tag.Start + tag.Length - 1; + tag.Next = current.tags; + tag.Next.Previous = tag; + + tag = tag.Next; + + } else { + offset = 0; + line.tags = current.tags; + line.tags.Previous = null; + tag = line.tags; + } + + line.ending = current.ending; + } else { + document.Split(line.line_no, 0); + offset = 0; + line.tags = current.tags; + line.tags.Previous = null; + line.ending = current.ending; + tag = line.tags; + } + + // Adjust start locations and line pointers + while (tag != null) { + tag.Start += offset - 1; + tag.Line = line; + tag = tag.Next; + } + + line.text.Insert(offset, current.text.ToString()); + line.Grow(line.text.Length); + + line.recalc = true; + line = document.GetLine(line.line_no + 1); + + // FIXME? Test undo of line-boundaries + if ((current.right == null) && (current.tags.Length != 0)) { + document.Combine(line.line_no - 1, line.line_no); + } + current = current.right; + lines++; + + } + + // Recalculate our document + document.UpdateView(first, lines, pos); + return; + } + #endregion // Private Methods + } +} diff --git a/source/ShiftUI/Internal/TextFormatFlags.cs b/source/ShiftUI/Internal/TextFormatFlags.cs new file mode 100644 index 0000000..6e2c798 --- /dev/null +++ b/source/ShiftUI/Internal/TextFormatFlags.cs @@ -0,0 +1,62 @@ +// 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) +// +// Author: +// Pedro MartÃnez Juliá <[email protected]> +// +using System; + + + +namespace ShiftUI { + + [FlagsAttribute()] + public enum TextFormatFlags { + Left = 0, + Top = 0, + Default = 0, + GlyphOverhangPadding = 0, + HorizontalCenter = 1, + Right = 2, + VerticalCenter = 4, + Bottom = 8, + WordBreak = 16, + SingleLine = 32, + ExpandTabs = 64, + NoClipping = 256, + ExternalLeading = 512, + NoPrefix = 2048, + Internal = 4096, + TextBoxControl = 8192, + PathEllipsis = 16384, + EndEllipsis = 32768, + ModifyString = 65536, + RightToLeft = 131072, + WordEllipsis = 262144, + NoFullWidthCharacterBreak = 524288, + HidePrefix = 1048576, + PrefixOnly = 2097152, + PreserveGraphicsClipping = 16777216, + PreserveGraphicsTranslateTransform = 33554432, + NoPadding = 268435456, + LeftAndRightPadding = 536870912 + } +}
\ No newline at end of file diff --git a/source/ShiftUI/Internal/TextRenderer.cs b/source/ShiftUI/Internal/TextRenderer.cs new file mode 100644 index 0000000..89b3dfa --- /dev/null +++ b/source/ShiftUI/Internal/TextRenderer.cs @@ -0,0 +1,527 @@ +// +// TextRenderer.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + +// This has become a monster class for all things text measuring and drawing. +// +// The public API is MeasureText/DrawText, which uses GDI on Win32, and +// GDI+ on other platforms. +// +// There is an internal API MeasureTextInternal/DrawTextInternal, which allows +// you to pass a flag of whether to use GDI or GDI+. This is used mainly for +// Widgets that have the UseCompatibleTextRendering flag. +// +// There are also thread-safe versions of MeasureString/MeasureCharacterRanges +// for things that want to measure strings without having a Graphics object. + +using System.Drawing; +using System.Runtime.InteropServices; +using System.Text; +using System.Drawing.Text; +using System; + +namespace ShiftUI +{ + public sealed class TextRenderer + { + private TextRenderer () + { + } + + #region Public Methods + public static void DrawText (IDeviceContext dc, string text, Font font, Point pt, Color foreColor) + { + DrawTextInternal (dc, text, font, pt, foreColor, Color.Transparent, TextFormatFlags.Default, false); + } + + public static void DrawText (IDeviceContext dc, string text, Font font, Rectangle bounds, Color foreColor) + { + DrawTextInternal (dc, text, font, bounds, foreColor, Color.Transparent, TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter, false); + } + + public static void DrawText (IDeviceContext dc, string text, Font font, Point pt, Color foreColor, Color backColor) + { + DrawTextInternal (dc, text, font, pt, foreColor, backColor, TextFormatFlags.Default, false); + } + + public static void DrawText (IDeviceContext dc, string text, Font font, Point pt, Color foreColor, TextFormatFlags flags) + { + DrawTextInternal (dc, text, font, pt, foreColor, Color.Transparent, flags, false); + } + + public static void DrawText (IDeviceContext dc, string text, Font font, Rectangle bounds, Color foreColor, Color backColor) + { + DrawTextInternal (dc, text, font, bounds, foreColor, backColor, TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter, false); + } + + public static void DrawText (IDeviceContext dc, string text, Font font, Rectangle bounds, Color foreColor, TextFormatFlags flags) + { + DrawTextInternal (dc, text, font, bounds, foreColor, Color.Transparent, flags, false); + } + + public static void DrawText (IDeviceContext dc, string text, Font font, Point pt, Color foreColor, Color backColor, TextFormatFlags flags) + { + DrawTextInternal (dc, text, font, pt, foreColor, backColor, flags, false); + } + + public static void DrawText (IDeviceContext dc, string text, Font font, Rectangle bounds, Color foreColor, Color backColor, TextFormatFlags flags) + { + DrawTextInternal (dc, text, font, bounds, foreColor, backColor, flags, false); + } + + public static Size MeasureText (string text, Font font) + { + return MeasureTextInternal (Hwnd.GraphicsContext, text, font, Size.Empty, TextFormatFlags.Default, false); + } + + public static Size MeasureText (IDeviceContext dc, string text, Font font) + { + return MeasureTextInternal (dc, text, font, Size.Empty, TextFormatFlags.Default, false); + } + + public static Size MeasureText (string text, Font font, Size proposedSize) + { + return MeasureTextInternal (Hwnd.GraphicsContext, text, font, proposedSize, TextFormatFlags.Default, false); + } + + public static Size MeasureText (IDeviceContext dc, string text, Font font, Size proposedSize) + { + return MeasureTextInternal (dc, text, font, proposedSize, TextFormatFlags.Default, false); + } + + public static Size MeasureText (string text, Font font, Size proposedSize, TextFormatFlags flags) + { + return MeasureTextInternal (Hwnd.GraphicsContext, text, font, proposedSize, flags, false); + } + + public static Size MeasureText (IDeviceContext dc, string text, Font font, Size proposedSize, TextFormatFlags flags) + { + return MeasureTextInternal (dc, text, font, proposedSize, flags, false); + } + #endregion + + #region Internal Methods That Do Stuff + internal static void DrawTextInternal (IDeviceContext dc, string text, Font font, Rectangle bounds, Color foreColor, Color backColor, TextFormatFlags flags, bool useDrawString) + { + if (dc == null) + throw new ArgumentNullException ("dc"); + + if (text == null || text.Length == 0) + return; + + // We use MS GDI API's unless told not to, or we aren't on Windows + if (!useDrawString && !XplatUI.RunningOnUnix) { + if ((flags & TextFormatFlags.VerticalCenter) == TextFormatFlags.VerticalCenter || (flags & TextFormatFlags.Bottom) == TextFormatFlags.Bottom) + flags |= TextFormatFlags.SingleLine; + + // Calculate the text bounds (there is often padding added) + Rectangle new_bounds = PadRectangle (bounds, flags); + new_bounds.Offset ((int)(dc as Graphics).Transform.OffsetX, (int)(dc as Graphics).Transform.OffsetY); + + IntPtr hdc = IntPtr.Zero; + bool clear_clip_region = false; + + // If we need to use the graphics clipping region, add it to our hdc + if ((flags & TextFormatFlags.PreserveGraphicsClipping) == TextFormatFlags.PreserveGraphicsClipping) { + Graphics graphics = (Graphics)dc; + Region clip_region = graphics.Clip; + + if (!clip_region.IsInfinite (graphics)) { + IntPtr hrgn = clip_region.GetHrgn (graphics); + hdc = dc.GetHdc (); + SelectClipRgn (hdc, hrgn); + DeleteObject (hrgn); + + clear_clip_region = true; + } + } + + if (hdc == IntPtr.Zero) + hdc = dc.GetHdc (); + + // Set the fore color + if (foreColor != Color.Empty) + SetTextColor (hdc, ColorTranslator.ToWin32 (foreColor)); + + // Set the back color + if (backColor != Color.Transparent && backColor != Color.Empty) { + SetBkMode (hdc, 2); //1-Transparent, 2-Opaque + SetBkColor (hdc, ColorTranslator.ToWin32 (backColor)); + } + else { + SetBkMode (hdc, 1); //1-Transparent, 2-Opaque + } + + XplatUIWin32.RECT r = XplatUIWin32.RECT.FromRectangle (new_bounds); + + IntPtr prevobj; + + if (font != null) { + prevobj = SelectObject (hdc, font.ToHfont ()); + Win32DrawText (hdc, text, text.Length, ref r, (int)flags); + prevobj = SelectObject (hdc, prevobj); + DeleteObject (prevobj); + } + else { + Win32DrawText (hdc, text, text.Length, ref r, (int)flags); + } + + if (clear_clip_region) + SelectClipRgn (hdc, IntPtr.Zero); + + dc.ReleaseHdc (); + } + // Use Graphics.DrawString as a fallback method + else { + Graphics g; + IntPtr hdc = IntPtr.Zero; + + if (dc is Graphics) + g = (Graphics)dc; + else { + hdc = dc.GetHdc (); + g = Graphics.FromHdc (hdc); + } + + StringFormat sf = FlagsToStringFormat (flags); + + Rectangle new_bounds = PadDrawStringRectangle (bounds, flags); + + g.DrawString (text, font, ThemeEngine.Current.ResPool.GetSolidBrush (foreColor), new_bounds, sf); + + if (!(dc is Graphics)) { + g.Dispose (); + dc.ReleaseHdc (); + } + } + } + + internal static Size MeasureTextInternal (IDeviceContext dc, string text, Font font, Size proposedSize, TextFormatFlags flags, bool useMeasureString) + { + if (!useMeasureString && !XplatUI.RunningOnUnix) { + // Tell DrawText to calculate size instead of draw + flags |= (TextFormatFlags)1024; // DT_CALCRECT + + IntPtr hdc = dc.GetHdc (); + + XplatUIWin32.RECT r = XplatUIWin32.RECT.FromRectangle (new Rectangle (Point.Empty, proposedSize)); + + IntPtr prevobj; + + if (font != null) { + prevobj = SelectObject (hdc, font.ToHfont ()); + Win32DrawText (hdc, text, text.Length, ref r, (int)flags); + prevobj = SelectObject (hdc, prevobj); + DeleteObject (prevobj); + } + else { + Win32DrawText (hdc, text, text.Length, ref r, (int)flags); + } + + dc.ReleaseHdc (); + + // Really, I am just making something up here, which as far as I can tell, MS + // just makes something up as well. This will require lots of tweaking to match MS. :( + Size retval = r.ToRectangle ().Size; + + if (retval.Width > 0 && (flags & TextFormatFlags.NoPadding) == 0) { + retval.Width += 6; + retval.Width += (int)retval.Height / 8; + } + + return retval; + } + else { + StringFormat sf = FlagsToStringFormat (flags); + + Size retval; + + int proposedWidth; + if (proposedSize.Width == 0) + proposedWidth = Int32.MaxValue; + else { + proposedWidth = proposedSize.Width; + if ((flags & TextFormatFlags.NoPadding) == 0) + proposedWidth -= 9; + } + if (dc is Graphics) + retval = (dc as Graphics).MeasureString (text, font, proposedWidth, sf).ToSize (); + else + retval = TextRenderer.MeasureString (text, font, proposedWidth, sf).ToSize (); + + if (retval.Width > 0 && (flags & TextFormatFlags.NoPadding) == 0) + retval.Width += 9; + + return retval; + } + } + #endregion + +#region Internal Methods That Are Just Overloads + internal static void DrawTextInternal (IDeviceContext dc, string text, Font font, Point pt, Color foreColor, bool useDrawString) + { + DrawTextInternal (dc, text, font, pt, foreColor, Color.Transparent, TextFormatFlags.Default, useDrawString); + } + + internal static void DrawTextInternal (IDeviceContext dc, string text, Font font, Rectangle bounds, Color foreColor, bool useDrawString) + { + DrawTextInternal (dc, text, font, bounds, foreColor, Color.Transparent, TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter, useDrawString); + } + + internal static void DrawTextInternal (IDeviceContext dc, string text, Font font, Point pt, Color foreColor, Color backColor, bool useDrawString) + { + DrawTextInternal (dc, text, font, pt, foreColor, backColor, TextFormatFlags.Default, useDrawString); + } + + internal static void DrawTextInternal (IDeviceContext dc, string text, Font font, Point pt, Color foreColor, TextFormatFlags flags, bool useDrawString) + { + DrawTextInternal (dc, text, font, pt, foreColor, Color.Transparent, flags, useDrawString); + } + + internal static void DrawTextInternal (IDeviceContext dc, string text, Font font, Rectangle bounds, Color foreColor, Color backColor, bool useDrawString) + { + DrawTextInternal (dc, text, font, bounds, foreColor, backColor, TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter, useDrawString); + } + + internal static void DrawTextInternal (IDeviceContext dc, string text, Font font, Rectangle bounds, Color foreColor, TextFormatFlags flags, bool useDrawString) + { + DrawTextInternal (dc, text, font, bounds, foreColor, Color.Transparent, flags, useDrawString); + } + + internal static Size MeasureTextInternal (string text, Font font, bool useMeasureString) + { + return MeasureTextInternal (Hwnd.GraphicsContext, text, font, Size.Empty, TextFormatFlags.Default, useMeasureString); + } + + internal static void DrawTextInternal (IDeviceContext dc, string text, Font font, Point pt, Color foreColor, Color backColor, TextFormatFlags flags, bool useDrawString) + { + Size sz = MeasureTextInternal (dc, text, font, useDrawString); + DrawTextInternal (dc, text, font, new Rectangle (pt, sz), foreColor, backColor, flags, useDrawString); + } + + internal static Size MeasureTextInternal (IDeviceContext dc, string text, Font font, bool useMeasureString) + { + return MeasureTextInternal (dc, text, font, Size.Empty, TextFormatFlags.Default, useMeasureString); + } + + internal static Size MeasureTextInternal (string text, Font font, Size proposedSize, bool useMeasureString) + { + return MeasureTextInternal (Hwnd.GraphicsContext, text, font, proposedSize, TextFormatFlags.Default, useMeasureString); + } + + internal static Size MeasureTextInternal (IDeviceContext dc, string text, Font font, Size proposedSize, bool useMeasureString) + { + return MeasureTextInternal (dc, text, font, proposedSize, TextFormatFlags.Default, useMeasureString); + } + + internal static Size MeasureTextInternal (string text, Font font, Size proposedSize, TextFormatFlags flags, bool useMeasureString) + { + return MeasureTextInternal (Hwnd.GraphicsContext, text, font, proposedSize, flags, useMeasureString); + } +#endregion + + #region Thread-Safe Static Graphics Methods + internal static SizeF MeasureString (string text, Font font) + { + return Hwnd.GraphicsContext.MeasureString (text, font); + } + + internal static SizeF MeasureString (string text, Font font, int width) + { + return Hwnd.GraphicsContext.MeasureString (text, font, width); + } + + internal static SizeF MeasureString (string text, Font font, SizeF layoutArea) + { + return Hwnd.GraphicsContext.MeasureString (text, font, layoutArea); + } + + internal static SizeF MeasureString (string text, Font font, int width, StringFormat format) + { + return Hwnd.GraphicsContext.MeasureString (text, font, width, format); + } + + internal static SizeF MeasureString (string text, Font font, PointF origin, StringFormat stringFormat) + { + return Hwnd.GraphicsContext.MeasureString (text, font, origin, stringFormat); + } + + internal static SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat stringFormat) + { + return Hwnd.GraphicsContext.MeasureString (text, font, layoutArea, stringFormat); + } + + internal static SizeF MeasureString (string text, Font font, SizeF layoutArea, StringFormat stringFormat, out int charactersFitted, out int linesFilled) + { + return Hwnd.GraphicsContext.MeasureString (text, font, layoutArea, stringFormat, out charactersFitted, out linesFilled); + } + + internal static Region[] MeasureCharacterRanges (string text, Font font, RectangleF layoutRect, StringFormat stringFormat) + { + return Hwnd.GraphicsContext.MeasureCharacterRanges (text, font, layoutRect, stringFormat); + } + + internal static SizeF GetDpi () + { + return new SizeF (Hwnd.GraphicsContext.DpiX, Hwnd.GraphicsContext.DpiY); + } + #endregion + +#region Private Methods + private static StringFormat FlagsToStringFormat (TextFormatFlags flags) + { + StringFormat sf = new StringFormat (); + + // Translation table: http://msdn.microsoft.com/msdnmag/issues/06/03/TextRendering/default.aspx?fig=true#fig4 + + // Horizontal Alignment + if ((flags & TextFormatFlags.HorizontalCenter) == TextFormatFlags.HorizontalCenter) + sf.Alignment = StringAlignment.Center; + else if ((flags & TextFormatFlags.Right) == TextFormatFlags.Right) + sf.Alignment = StringAlignment.Far; + else + sf.Alignment = StringAlignment.Near; + + // Vertical Alignment + if ((flags & TextFormatFlags.Bottom) == TextFormatFlags.Bottom) + sf.LineAlignment = StringAlignment.Far; + else if ((flags & TextFormatFlags.VerticalCenter) == TextFormatFlags.VerticalCenter) + sf.LineAlignment = StringAlignment.Center; + else + sf.LineAlignment = StringAlignment.Near; + + // Ellipsis + if ((flags & TextFormatFlags.EndEllipsis) == TextFormatFlags.EndEllipsis) + sf.Trimming = StringTrimming.EllipsisCharacter; + else if ((flags & TextFormatFlags.PathEllipsis) == TextFormatFlags.PathEllipsis) + sf.Trimming = StringTrimming.EllipsisPath; + else if ((flags & TextFormatFlags.WordEllipsis) == TextFormatFlags.WordEllipsis) + sf.Trimming = StringTrimming.EllipsisWord; + else + sf.Trimming = StringTrimming.Character; + + // Hotkey Prefix + if ((flags & TextFormatFlags.NoPrefix) == TextFormatFlags.NoPrefix) + sf.HotkeyPrefix = HotkeyPrefix.None; + else if ((flags & TextFormatFlags.HidePrefix) == TextFormatFlags.HidePrefix) + sf.HotkeyPrefix = HotkeyPrefix.Hide; + else + sf.HotkeyPrefix = HotkeyPrefix.Show; + + // Text Padding + if ((flags & TextFormatFlags.NoPadding) == TextFormatFlags.NoPadding) + sf.FormatFlags |= StringFormatFlags.FitBlackBox; + + // Text Wrapping + if ((flags & TextFormatFlags.SingleLine) == TextFormatFlags.SingleLine) + sf.FormatFlags |= StringFormatFlags.NoWrap; + else if ((flags & TextFormatFlags.TextBoxControl) == TextFormatFlags.TextBoxControl) + sf.FormatFlags |= StringFormatFlags.LineLimit; + + // Other Flags + //if ((flags & TextFormatFlags.RightToLeft) == TextFormatFlags.RightToLeft) + // sf.FormatFlags |= StringFormatFlags.DirectionRightToLeft; + if ((flags & TextFormatFlags.NoClipping) == TextFormatFlags.NoClipping) + sf.FormatFlags |= StringFormatFlags.NoClip; + + return sf; + } + + private static Rectangle PadRectangle (Rectangle r, TextFormatFlags flags) + { + if ((flags & TextFormatFlags.NoPadding) == 0 && (flags & TextFormatFlags.Right) == 0 && (flags & TextFormatFlags.HorizontalCenter) == 0) { + r.X += 3; + r.Width -= 3; + } + if ((flags & TextFormatFlags.NoPadding) == 0 && (flags & TextFormatFlags.Right) == TextFormatFlags.Right) { + r.Width -= 4; + } + if ((flags & TextFormatFlags.LeftAndRightPadding) == TextFormatFlags.LeftAndRightPadding) { + r.X += 2; + r.Width -= 2; + } + if ((flags & TextFormatFlags.WordEllipsis) == TextFormatFlags.WordEllipsis || (flags & TextFormatFlags.EndEllipsis) == TextFormatFlags.EndEllipsis || (flags & TextFormatFlags.WordBreak) == TextFormatFlags.WordBreak) { + r.Width -= 4; + } + if ((flags & TextFormatFlags.VerticalCenter) == TextFormatFlags.VerticalCenter) { + r.Y += 1; + } + + return r; + } + + private static Rectangle PadDrawStringRectangle (Rectangle r, TextFormatFlags flags) + { + if ((flags & TextFormatFlags.NoPadding) == 0 && (flags & TextFormatFlags.Right) == 0 && (flags & TextFormatFlags.HorizontalCenter) == 0) { + r.X += 1; + r.Width -= 1; + } + if ((flags & TextFormatFlags.NoPadding) == 0 && (flags & TextFormatFlags.Right) == TextFormatFlags.Right) { + r.Width -= 4; + } + if ((flags & TextFormatFlags.NoPadding) == TextFormatFlags.NoPadding) { + r.X -= 2; + } + if ((flags & TextFormatFlags.NoPadding) == 0 && (flags & TextFormatFlags.Bottom) == TextFormatFlags.Bottom) { + r.Y += 1; + } + if ((flags & TextFormatFlags.LeftAndRightPadding) == TextFormatFlags.LeftAndRightPadding) { + r.X += 2; + r.Width -= 2; + } + if ((flags & TextFormatFlags.VerticalCenter) == TextFormatFlags.VerticalCenter && XplatUI.RunningOnUnix) { + r.Y -= 1; + } + + return r; + } +#endregion + +#region DllImports (Windows) + [DllImport ("user32", CharSet = CharSet.Unicode, EntryPoint = "DrawText")] + static extern int Win32DrawText (IntPtr hdc, string lpStr, int nCount, ref XplatUIWin32.RECT lpRect, int wFormat); + + [DllImport ("gdi32")] + static extern int SetTextColor (IntPtr hdc, int crColor); + + [DllImport ("gdi32")] + static extern IntPtr SelectObject (IntPtr hDC, IntPtr hObject); + + [DllImport ("gdi32")] + static extern int SetBkColor (IntPtr hdc, int crColor); + + [DllImport ("gdi32")] + static extern int SetBkMode (IntPtr hdc, int iBkMode); + + [DllImport ("gdi32")] + static extern bool DeleteObject (IntPtr objectHandle); + + [DllImport("gdi32")] + static extern bool SelectClipRgn(IntPtr hdc, IntPtr hrgn); +#endregion + } +} diff --git a/source/ShiftUI/Internal/Theme.cs b/source/ShiftUI/Internal/Theme.cs new file mode 100644 index 0000000..4f1eac6 --- /dev/null +++ b/source/ShiftUI/Internal/Theme.cs @@ -0,0 +1,1063 @@ +// 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) 2004-2005 Novell, Inc. +// +// Authors: +// Jordi Mas i Hernandez, [email protected] +// Peter Dennis Bartok, [email protected] +// + +using System.Collections; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Reflection; +using System; + +namespace ShiftUI +{ + internal enum UIIcon { + PlacesRecentDocuments, + PlacesDesktop, + PlacesPersonal, + PlacesMyComputer, + PlacesMyNetwork, + MessageBoxError, + MessageBoxQuestion, + MessageBoxWarning, + MessageBoxInfo, + + NormalFolder + } + + internal struct CPColor { + internal Color Dark; + internal Color DarkDark; + internal Color Light; + internal Color LightLight; + + internal static CPColor Empty; + } + + // Implements a pool of system resources + internal class SystemResPool + { + private Hashtable pens = new Hashtable (); + private Hashtable dashpens = new Hashtable (); + private Hashtable sizedpens = new Hashtable (); + private Hashtable solidbrushes = new Hashtable (); + private Hashtable hatchbrushes = new Hashtable (); + private Hashtable uiImages = new Hashtable(); + private Hashtable cpcolors = new Hashtable (); + + public SystemResPool () {} + + public Pen GetPen (Color color) + { + int hash = color.ToArgb (); + + lock (pens) { + Pen res = pens [hash] as Pen; + if (res != null) + return res; + + Pen pen = new Pen (color); + pens.Add (hash, pen); + return pen; + } + } + + public Pen GetDashPen (Color color, DashStyle dashStyle) + { + string hash = color.ToString() + dashStyle; + + lock (dashpens) { + Pen res = dashpens [hash] as Pen; + if (res != null) + return res; + + Pen pen = new Pen (color); + pen.DashStyle = dashStyle; + dashpens [hash] = pen; + return pen; + } + } + + public Pen GetSizedPen (Color color, int size) + { + string hash = color.ToString () + size; + + lock (sizedpens) { + Pen res = sizedpens [hash] as Pen; + if (res != null) + return res; + + Pen pen = new Pen (color, size); + sizedpens [hash] = pen; + return pen; + } + } + + public SolidBrush GetSolidBrush (Color color) + { + int hash = color.ToArgb (); + + lock (solidbrushes) { + SolidBrush res = solidbrushes [hash] as SolidBrush; + if (res != null) + return res; + + SolidBrush brush = new SolidBrush (color); + solidbrushes.Add (hash, brush); + return brush; + } + } + + public HatchBrush GetHatchBrush (HatchStyle hatchStyle, Color foreColor, Color backColor) + { + string hash = ((int)hatchStyle).ToString () + foreColor.ToString () + backColor.ToString (); + + lock (hatchbrushes) { + HatchBrush brush = (HatchBrush) hatchbrushes[hash]; + if (brush == null) { + brush = new HatchBrush (hatchStyle, foreColor, backColor); + hatchbrushes.Add (hash, brush); + } + return brush; + } + } + + public void AddUIImage (Image image, string name, int size) + { + string hash = name + size.ToString(); + + lock (uiImages) { + if (uiImages.Contains (hash)) + return; + uiImages.Add (hash, image); + } + } + + public Image GetUIImage(string name, int size) + { + string hash = name + size.ToString(); + + Image image = uiImages [hash] as Image; + + return image; + } + + public CPColor GetCPColor (Color color) + { + lock (cpcolors) { + object tmp = cpcolors [color]; + + if (tmp == null) { + CPColor cpcolor = new CPColor (); + cpcolor.Dark = WidgetPaint.Dark (color); + cpcolor.DarkDark = WidgetPaint.DarkDark (color); + cpcolor.Light = WidgetPaint.Light (color); + cpcolor.LightLight = WidgetPaint.LightLight (color); + + cpcolors.Add (color, cpcolor); + + return cpcolor; + } + + return (CPColor)tmp; + } + } + } + + internal abstract class Theme + { + protected Array syscolors; + Font default_font; + protected Color defaultWindowBackColor; + protected Color defaultWindowForeColor; + internal SystemResPool ResPool = new SystemResPool (); + private MethodInfo update; + + protected Theme () + { + } + + private void SetSystemColors (KnownColor kc, Color value) + { + if (update == null) { + Type known_colors = Type.GetType ("System.Drawing.KnownColors, " + Consts.AssemblySystem_Drawing); + if (known_colors != null) + update = known_colors.GetMethod ("Update", BindingFlags.Static | BindingFlags.Public); + } + if (update != null) + update.Invoke (null, new object [2] { (int)kc, value.ToArgb () }); + } + + /* OS Feature support */ + public abstract Version Version { + get; + } + + /* Default properties */ + public virtual Color ColorScrollBar { + get { return SystemColors.ScrollBar; } + set { SetSystemColors (KnownColor.ScrollBar, value); } + } + + public virtual Color ColorDesktop { + get { return SystemColors.Desktop;} + set { SetSystemColors (KnownColor.Desktop, value); } + } + + public virtual Color ColorActiveCaption { + get { return SystemColors.ActiveCaption;} + set { SetSystemColors (KnownColor.ActiveCaption, value); } + } + + public virtual Color ColorInactiveCaption { + get { return SystemColors.InactiveCaption;} + set { SetSystemColors (KnownColor.InactiveCaption, value); } + } + + public virtual Color ColorMenu { + get { return SystemColors.Menu;} + set { SetSystemColors (KnownColor.Menu, value); } + } + + public virtual Color ColorWindow { + get { return SystemColors.Window;} + set { SetSystemColors (KnownColor.Window, value); } + } + + public virtual Color ColorWindowFrame { + get { return SystemColors.WindowFrame;} + set { SetSystemColors (KnownColor.WindowFrame, value); } + } + + public virtual Color ColorMenuText { + get { return SystemColors.MenuText;} + set { SetSystemColors (KnownColor.MenuText, value); } + } + + public virtual Color ColorWindowText { + get { return SystemColors.WindowText;} + set { SetSystemColors (KnownColor.WindowText, value); } + } + + public virtual Color ColorActiveCaptionText { + get { return SystemColors.ActiveCaptionText;} + set { SetSystemColors (KnownColor.ActiveCaptionText, value); } + } + + public virtual Color ColorActiveBorder { + get { return SystemColors.ActiveBorder;} + set { SetSystemColors (KnownColor.ActiveBorder, value); } + } + + public virtual Color ColorInactiveBorder{ + get { return SystemColors.InactiveBorder;} + set { SetSystemColors (KnownColor.InactiveBorder, value); } + } + + public virtual Color ColorAppWorkspace { + get { return SystemColors.AppWorkspace;} + set { SetSystemColors (KnownColor.AppWorkspace, value); } + } + + public virtual Color ColorHighlight { + get { return SystemColors.Highlight;} + set { SetSystemColors (KnownColor.Highlight, value); } + } + + public virtual Color ColorHighlightText { + get { return SystemColors.HighlightText;} + set { SetSystemColors (KnownColor.HighlightText, value); } + } + + public virtual Color ColorControl { + get { return SystemColors.Control; } + set { SetSystemColors (KnownColor.Control, value); } + } + + public virtual Color ColorControlDark { + get { return SystemColors.ControlDark;} + set { SetSystemColors (KnownColor.ControlDark, value); } + } + + public virtual Color ColorGrayText { + get { return SystemColors.GrayText;} + set { SetSystemColors (KnownColor.GrayText, value); } + } + + public virtual Color ColorControlText { + get { return SystemColors.ControlText;} + set { SetSystemColors (KnownColor.ControlText, value); } + } + + public virtual Color ColorInactiveCaptionText { + get { return SystemColors.InactiveCaptionText;} + set { SetSystemColors (KnownColor.InactiveCaptionText, value); } + } + + public virtual Color ColorControlLight { + get { return SystemColors.ControlLight;} + set { SetSystemColors (KnownColor.ControlLight, value); } + } + + public virtual Color ColorControlDarkDark { + get { return SystemColors.ControlDarkDark;} + set { SetSystemColors (KnownColor.ControlDarkDark, value); } + } + + public virtual Color ColorControlLightLight { + get { return SystemColors.ControlLightLight;} + set { SetSystemColors (KnownColor.ControlLightLight, value); } + } + + public virtual Color ColorInfoText { + get { return SystemColors.InfoText;} + set { SetSystemColors (KnownColor.InfoText, value); } + } + + public virtual Color ColorInfo { + get { return SystemColors.Info;} + set { SetSystemColors (KnownColor.Info, value); } + } + + public virtual Color ColorHotTrack { + get { return SystemColors.HotTrack;} + set { SetSystemColors (KnownColor.HotTrack, value);} + } + + public virtual Color DefaultControlBackColor { + get { return ColorControl; } + set { ColorControl = value; } + } + + public virtual Color DefaultControlForeColor { + get { return ColorControlText; } + set { ColorControlText = value; } + } + + public virtual Font DefaultFont { + get { return default_font ?? (default_font = SystemFonts.DefaultFont); } + } + + public virtual Color DefaultWindowBackColor { + get { return defaultWindowBackColor; } + } + + public virtual Color DefaultWindowForeColor { + get { return defaultWindowForeColor; } + } + + public virtual Color GetColor (XplatUIWin32.GetSysColorIndex idx) + { + return (Color) syscolors.GetValue ((int)idx); + } + + public virtual void SetColor (XplatUIWin32.GetSysColorIndex idx, Color color) + { + syscolors.SetValue (color, (int) idx); + } + + // Theme/UI specific defaults + public virtual ArrangeDirection ArrangeDirection { + get { + return ArrangeDirection.Down; + } + } + + public virtual ArrangeStartingPosition ArrangeStartingPosition { + get { + return ArrangeStartingPosition.BottomLeft; + } + } + + public virtual int BorderMultiplierFactor { get { return 1; } } + + public virtual Size BorderSizableSize { + get { + return new Size (3, 3); + } + } + + public virtual Size Border3DSize { + get { + return XplatUI.Border3DSize; + } + } + + public virtual Size BorderStaticSize { + get { + return new Size(1, 1); + } + } + + public virtual Size BorderSize { + get { + return XplatUI.BorderSize; + } + } + + public virtual Size CaptionButtonSize { + get { + return XplatUI.CaptionButtonSize; + } + } + + public virtual int CaptionHeight { + get { + return XplatUI.CaptionHeight; + } + } + + public virtual Size DoubleClickSize { + get { + return new Size(4, 4); + } + } + + public virtual int DoubleClickTime { + get { + return XplatUI.DoubleClickTime; + } + } + + public virtual Size FixedFrameBorderSize { + get { + return XplatUI.FixedFrameBorderSize; + } + } + + public virtual Size FrameBorderSize { + get { + return XplatUI.FrameBorderSize; + } + } + + public virtual int HorizontalFocusThickness { get { return 1; } } + + public virtual int HorizontalScrollBarArrowWidth { + get { + return 16; + } + } + + public virtual int HorizontalScrollBarHeight { + get { + return 16; + } + } + + public virtual int HorizontalScrollBarThumbWidth { + get { + return 16; + } + } + + public virtual Size IconSpacingSize { + get { + return new Size(75, 75); + } + } + + public virtual bool MenuAccessKeysUnderlined { + get { + try { + return XplatUI.MenuAccessKeysUnderlined; + } + catch(Exception ex) { + Console.WriteLine("[ShiftUI] XplatUI error: {0}\r\nInnerException: {1}", ex.Message, ex.InnerException.Message); + return false; + } + } + } + + public virtual Size MenuBarButtonSize { + get { return XplatUI.MenuBarButtonSize; } + } + + public virtual Size MenuButtonSize { + get { + return XplatUI.MenuButtonSize; + } + } + + public virtual Size MenuCheckSize { + get { + return new Size(13, 13); + } + } + + public virtual Font MenuFont { + get { + return default_font ?? (default_font = SystemFonts.DefaultFont); + } + } + + public virtual int MenuHeight { + get { + return XplatUI.MenuHeight; + } + } + + public virtual int MouseWheelScrollLines { + get { + return 3; + } + } + + public virtual bool RightAlignedMenus { + get { + return false; + } + } + + public virtual Size ToolWindowCaptionButtonSize { + get { + return XplatUI.ToolWindowCaptionButtonSize; + } + } + + public virtual int ToolWindowCaptionHeight { + get { + return XplatUI.ToolWindowCaptionHeight; + } + } + + public virtual int VerticalFocusThickness { get { return 1; } } + + public virtual int VerticalScrollBarArrowHeight { + get { + return 16; + } + } + + public virtual int VerticalScrollBarThumbHeight { + get { + return 16; + } + } + + public virtual int VerticalScrollBarWidth { + get { + return 16; + } + } + + public abstract Font WindowBorderFont { + get; + } + + public int Clamp (int value, int lower, int upper) + { + if (value < lower) return lower; + else if (value > upper) return upper; + else return value; + } + + [MonoInternalNote ("Figure out where to point for My Network Places")] + public virtual string Places(UIIcon index) { + switch (index) { + case UIIcon.PlacesRecentDocuments: { + // Default = "Recent Documents" + return Environment.GetFolderPath(Environment.SpecialFolder.Recent); + } + + case UIIcon.PlacesDesktop: { + // Default = "Desktop" + return Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory); + } + + case UIIcon.PlacesPersonal: { + // Default = "My Documents" + return Environment.GetFolderPath(Environment.SpecialFolder.Personal); + } + + case UIIcon.PlacesMyComputer: { + // Default = "My Computer" + return Environment.GetFolderPath(Environment.SpecialFolder.MyComputer); + } + + case UIIcon.PlacesMyNetwork: { + // Default = "My Network Places" + return "/tmp"; + } + + default: { + throw new ArgumentOutOfRangeException("index", index, "Unsupported place"); + } + } + } + + // + // This routine fetches images embedded as assembly resources (not + // resgen resources). It optionally scales the image to fit the + // specified size x dimension (it adjusts y automatically to fit that). + // + private Image GetSizedResourceImage(string name, int width) + { + Image image = ResPool.GetUIImage (name, width); + if (image != null) + return image; + + string fullname; + + if (width > 0) { + // Try name_width + fullname = String.Format("{1}_{0}", name, width); + if (image != null){ + ResPool.AddUIImage (image, name, width); + return image; + } + } + + // Just try name + if (image == null) + return null; + + ResPool.AddUIImage (image, name, 0); + if (image.Width != width && width != 0){ + Console.Error.WriteLine ("warning: requesting icon that not been tuned {0}_{1} {2}", width, name, image.Width); + int height = (image.Height * width)/image.Width; + Bitmap b = new Bitmap (width, height); + using (Graphics g = Graphics.FromImage (b)) + g.DrawImage (image, 0, 0, width, height); + ResPool.AddUIImage (b, name, width); + + return b; + } + return image; + } + + public virtual Image Images(UIIcon index) { + return Images(index, 0); + } + + public virtual Image Images(UIIcon index, int size) { + switch (index) { + case UIIcon.PlacesRecentDocuments: + return GetSizedResourceImage ("document-open.png", size); + case UIIcon.PlacesDesktop: + return GetSizedResourceImage ("user-desktop.png", size); + case UIIcon.PlacesPersonal: + return GetSizedResourceImage ("user-home.png", size); + case UIIcon.PlacesMyComputer: + return GetSizedResourceImage ("computer.png", size); + case UIIcon.PlacesMyNetwork: + return GetSizedResourceImage ("folder-remote.png", size); + + // Icons for message boxes + case UIIcon.MessageBoxError: + return GetSizedResourceImage ("dialog-error.png", size); + case UIIcon.MessageBoxInfo: + return GetSizedResourceImage ("dialog-information.png", size); + case UIIcon.MessageBoxQuestion: + return GetSizedResourceImage ("dialog-question.png", size); + case UIIcon.MessageBoxWarning: + return GetSizedResourceImage ("dialog-warning.png", size); + + // misc Icons + case UIIcon.NormalFolder: + return GetSizedResourceImage ("folder.png", size); + + default: { + throw new ArgumentException("Invalid Icon type requested", "index"); + } + } + } + + public virtual Image Images(string mimetype, string extension, int size) { + return null; + } + + #region Principal Theme Methods + // To let the theme now that a change of defaults (colors, etc) was detected and force a re-read (and possible recreation of cached resources) + public abstract void ResetDefaults(); + + // If the theme writes directly to a window instead of a device context + public abstract bool DoubleBufferingSupported {get;} + #endregion // Principal Theme Methods + + #region OwnerDraw Support + public abstract void DrawOwnerDrawBackground (DrawItemEventArgs e); + public abstract void DrawOwnerDrawFocusRectangle (DrawItemEventArgs e); + #endregion // OwnerDraw Support + + #region Button + public abstract Size CalculateButtonAutoSize (Button button); + public abstract void CalculateButtonTextAndImageLayout (Graphics g, ButtonBase b, out Rectangle textRectangle, out Rectangle imageRectangle); + public abstract void DrawButton (Graphics g, Button b, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle); + public abstract void DrawFlatButton (Graphics g, ButtonBase b, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle); + public abstract void DrawPopupButton (Graphics g, Button b, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle); + #endregion // Button + + #region ButtonBase + // Drawing + public abstract void DrawButtonBase(Graphics dc, Rectangle clip_area, ButtonBase button); + + // Sizing + public abstract Size ButtonBaseDefaultSize{get;} + #endregion // ButtonBase + + #region CheckBox + public abstract Size CalculateCheckBoxAutoSize (CheckBox checkBox); + public abstract void CalculateCheckBoxTextAndImageLayout (ButtonBase b, Point offset, out Rectangle glyphArea, out Rectangle textRectangle, out Rectangle imageRectangle); + public abstract void DrawCheckBox (Graphics g, CheckBox cb, Rectangle glyphArea, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle); + public abstract void DrawCheckBox (Graphics dc, Rectangle clip_area, CheckBox checkbox); + + #endregion // CheckBox + + #region CheckedListBox + // Drawing + public abstract void DrawCheckedListBoxItem (CheckedListBox ctrl, DrawItemEventArgs e); + #endregion // CheckedListBox + + #region ComboBox + // Drawing + public abstract void DrawComboBoxItem (ComboBox ctrl, DrawItemEventArgs e); + public abstract void DrawFlatStyleComboButton (Graphics graphics, Rectangle rectangle, ButtonState state); + public abstract void ComboBoxDrawNormalDropDownButton (ComboBox comboBox, Graphics g, Rectangle clippingArea, Rectangle area, ButtonState state); + public abstract bool ComboBoxNormalDropDownButtonHasTransparentBackground (ComboBox comboBox, ButtonState state); + public abstract bool ComboBoxDropDownButtonHasHotElementStyle (ComboBox comboBox); + public abstract void ComboBoxDrawBackground (ComboBox comboBox, Graphics g, Rectangle clippingArea, FlatStyle style); + public abstract bool CombBoxBackgroundHasHotElementStyle (ComboBox comboBox); + #endregion // ComboBox + + #region Widget + public abstract Font GetLinkFont (Widget control); + #endregion // Widget + + + /* FIXME: I really don't feel like implementing DataGrids. Too much code. + #region Datagrid + public abstract int DataGridPreferredColumnWidth { get; } + public abstract int DataGridMinimumColumnCheckBoxHeight { get; } + public abstract int DataGridMinimumColumnCheckBoxWidth { get; } + + // Default colours + public abstract Color DataGridAlternatingBackColor { get; } + public abstract Color DataGridBackColor { get; } + public abstract Color DataGridBackgroundColor { get; } + public abstract Color DataGridCaptionBackColor { get; } + public abstract Color DataGridCaptionForeColor { get; } + public abstract Color DataGridGridLineColor { get; } + public abstract Color DataGridHeaderBackColor { get; } + public abstract Color DataGridHeaderForeColor { get; } + public abstract Color DataGridLinkColor { get; } + public abstract Color DataGridLinkHoverColor { get; } + public abstract Color DataGridParentRowsBackColor { get; } + public abstract Color DataGridParentRowsForeColor { get; } + public abstract Color DataGridSelectionBackColor { get; } + public abstract Color DataGridSelectionForeColor { get; } + // Paint + public abstract void DataGridPaint (PaintEventArgs pe, DataGrid grid); + public abstract void DataGridPaintCaption (Graphics g, Rectangle clip, DataGrid grid); + public abstract void DataGridPaintColumnHeaders (Graphics g, Rectangle clip, DataGrid grid); + public abstract void DataGridPaintColumnHeader (Graphics g, Rectangle bounds, DataGrid grid, int col); + public abstract void DataGridPaintRowContents (Graphics g, int row, Rectangle row_rect, bool is_newrow, Rectangle clip, DataGrid grid); + public abstract void DataGridPaintRowHeader (Graphics g, Rectangle bounds, int row, DataGrid grid); + public abstract void DataGridPaintRowHeaderArrow (Graphics g, Rectangle bounds, DataGrid grid); + public abstract void DataGridPaintRowHeaderStar (Graphics g, Rectangle bounds, DataGrid grid); + public abstract void DataGridPaintParentRows (Graphics g, Rectangle bounds, DataGrid grid); + public abstract void DataGridPaintParentRow (Graphics g, Rectangle bounds, DataGridDataSource row, DataGrid grid); + public abstract void DataGridPaintRows (Graphics g, Rectangle cells, Rectangle clip, DataGrid grid); + public abstract void DataGridPaintRow (Graphics g, int row, Rectangle row_rect, bool is_newrow, Rectangle clip, DataGrid grid); + public abstract void DataGridPaintRelationRow (Graphics g, int row, Rectangle row_rect, bool is_newrow, Rectangle clip, DataGrid grid); + + #endregion // Datagrid + + #region DataGridView + #region DataGridViewHeaderCell + #region DataGridViewRowHeaderCell + public abstract bool DataGridViewRowHeaderCellDrawBackground (DataGridViewRowHeaderCell cell, Graphics g, Rectangle bounds); + public abstract bool DataGridViewRowHeaderCellDrawSelectionBackground (DataGridViewRowHeaderCell cell); + public abstract bool DataGridViewRowHeaderCellDrawBorder (DataGridViewRowHeaderCell cell, Graphics g, Rectangle bounds); + #endregion + #region DataGridViewColumnHeaderCell + public abstract bool DataGridViewColumnHeaderCellDrawBackground (DataGridViewColumnHeaderCell cell, Graphics g, Rectangle bounds); + public abstract bool DataGridViewColumnHeaderCellDrawBorder (DataGridViewColumnHeaderCell cell, Graphics g, Rectangle bounds); + #endregion + public abstract bool DataGridViewHeaderCellHasPressedStyle (DataGridView dataGridView); + public abstract bool DataGridViewHeaderCellHasHotStyle (DataGridView dataGridView); + #endregion + #endregion +*/ + + #region DateTimePicker + public abstract void DrawDateTimePicker(Graphics dc, Rectangle clip_rectangle, DateTimePicker dtp); + public abstract bool DateTimePickerBorderHasHotElementStyle { get; } + public abstract Rectangle DateTimePickerGetDropDownButtonArea (DateTimePicker dateTimePicker); + public abstract Rectangle DateTimePickerGetDateArea (DateTimePicker dateTimePicker); + public abstract bool DateTimePickerDropDownButtonHasHotElementStyle { get; } + #endregion // DateTimePicker + + #region GroupBox + // Drawing + public abstract void DrawGroupBox (Graphics dc, Rectangle clip_area, GroupBox box); + + // Sizing + public abstract Size GroupBoxDefaultSize{get;} + #endregion // GroupBox + + #region HScrollBar + public abstract Size HScrollBarDefaultSize{get;} // Default size of the scrollbar + #endregion // HScrollBar + + #region ListBox + // Drawing + public abstract void DrawListBoxItem (ListBox ctrl, DrawItemEventArgs e); + #endregion // ListBox + + #region ListView + // Drawing + public abstract void DrawListViewItems (Graphics dc, Rectangle clip_rectangle, ListView control); + public abstract void DrawListViewHeader (Graphics dc, Rectangle clip_rectangle, ListView control); + public abstract void DrawListViewHeaderDragDetails (Graphics dc, ListView control, ColumnHeader drag_column, int target_x); + public abstract bool ListViewHasHotHeaderStyle { get; } + + // Sizing + public abstract int ListViewGetHeaderHeight (ListView listView, Font font); + public abstract Size ListViewCheckBoxSize { get; } + public abstract int ListViewColumnHeaderHeight { get; } + public abstract int ListViewDefaultColumnWidth { get; } + public abstract int ListViewVerticalSpacing { get; } + public abstract int ListViewEmptyColumnWidth { get; } + public abstract int ListViewHorizontalSpacing { get; } + public abstract Size ListViewDefaultSize { get; } + public abstract int ListViewGroupHeight { get; } + public abstract int ListViewItemPaddingWidth { get; } + public abstract int ListViewTileWidthFactor { get; } + public abstract int ListViewTileHeightFactor { get; } + #endregion // ListView + + #region Menus + public abstract void CalcItemSize (Graphics dc, MenuItem item, int y, int x, bool menuBar); + public abstract void CalcPopupMenuSize (Graphics dc, Menu menu); + public abstract int CalcMenuBarSize (Graphics dc, Menu menu, int width); + public abstract void DrawMenuBar (Graphics dc, Menu menu, Rectangle rect); + public abstract void DrawMenuItem (MenuItem item, DrawItemEventArgs e); + public abstract void DrawPopupMenu (Graphics dc, Menu menu, Rectangle cliparea, Rectangle rect); + #endregion // Menus + + #region MonthCalendar + public abstract void DrawMonthCalendar(Graphics dc, Rectangle clip_rectangle, MonthCalendar month_calendar); + #endregion // MonthCalendar + + #region Panel + // Sizing + public abstract Size PanelDefaultSize{get;} + #endregion // Panel + + #region PictureBox + // Drawing + public abstract void DrawPictureBox (Graphics dc, Rectangle clip, PictureBox pb); + + // Sizing + public abstract Size PictureBoxDefaultSize{get;} + #endregion // PictureBox + + /* FIXME: No printing. + #region PrintPreviewControl + public abstract int PrintPreviewControlPadding{get;} + public abstract Size PrintPreviewControlGetPageSize (PrintPreviewControl preview); + public abstract void PrintPreviewWidgetPaint (PaintEventArgs pe, PrintPreviewControl preview, Size page_image_size); + #endregion // PrintPreviewControl +*/ + #region ProgressBar + // Drawing + public abstract void DrawProgressBar (Graphics dc, Rectangle clip_rectangle, ProgressBar progress_bar); + + // Sizing + public abstract Size ProgressBarDefaultSize{get;} + #endregion // ProgressBar + + #region RadioButton + // Drawing + public abstract Size CalculateRadioButtonAutoSize (RadioButton rb); + public abstract void CalculateRadioButtonTextAndImageLayout (ButtonBase b, Point offset, out Rectangle glyphArea, out Rectangle textRectangle, out Rectangle imageRectangle); + public abstract void DrawRadioButton (Graphics g, RadioButton rb, Rectangle glyphArea, Rectangle textBounds, Rectangle imageBounds, Rectangle clipRectangle); + public abstract void DrawRadioButton (Graphics dc, Rectangle clip_rectangle, RadioButton radio_button); + + // Sizing + public abstract Size RadioButtonDefaultSize{get;} + #endregion // RadioButton + + #region ScrollBar + // Drawing + //public abstract void DrawScrollBar (Graphics dc, Rectangle area, ScrollBar bar, ref Rectangle thumb_pos, ref Rectangle first_arrow_area, ref Rectangle second_arrow_area, ButtonState first_arrow, ButtonState second_arrow, ref int scrollbutton_width, ref int scrollbutton_height, bool vert); + public abstract void DrawScrollBar (Graphics dc, Rectangle clip_rectangle, ScrollBar bar); + + // Sizing + public abstract int ScrollBarButtonSize {get;} // Size of the scroll button + + public abstract bool ScrollBarHasHotElementStyles { get; } + + public abstract bool ScrollBarHasPressedThumbStyle { get; } + + public abstract bool ScrollBarHasHoverArrowButtonStyle { get; } + #endregion // ScrollBar + + #region StatusBar + // Drawing + public abstract void DrawStatusBar (Graphics dc, Rectangle clip_rectangle, StatusBar sb); + + // Sizing + public abstract int StatusBarSizeGripWidth {get;} // Size of Resize area + public abstract int StatusBarHorzGapWidth {get;} // Gap between panels + public abstract Size StatusBarDefaultSize{get;} + #endregion // StatusBar + + #region TabControl + public abstract Size TabControlDefaultItemSize {get; } + public abstract Point TabControlDefaultPadding {get; } + public abstract int TabControlMinimumTabWidth {get; } + public abstract Rectangle TabWidgetselectedDelta { get; } + public abstract int TabWidgetselectedSpacing { get; } + public abstract int TabPanelOffsetX { get; } + public abstract int TabPanelOffsetY { get; } + public abstract int TabControlColSpacing { get; } + public abstract Point TabControlImagePadding { get; } + public abstract int TabWidgetscrollerWidth { get; } + + public abstract Rectangle TabControlGetDisplayRectangle (TabWidget tab); + public abstract Rectangle TabControlGetPanelRect (TabWidget tab); + public abstract Size TabControlGetSpacing (TabWidget tab); + public abstract void DrawTabControl (Graphics dc, Rectangle area, TabWidget tab); + #endregion + + #region TextBoxBase + public abstract void TextBoxBaseFillBackground (TextBoxBase textBoxBase, Graphics g, Rectangle clippingArea); + public abstract bool TextBoxBaseHandleWmNcPaint (TextBoxBase textBoxBase, ref Message m); + public abstract bool TextBoxBaseShouldPaintBackground (TextBoxBase textBoxBase); + #endregion + + /*#region ToolBar + // Drawing + public abstract void DrawToolBar (Graphics dc, Rectangle clip_rectangle, ToolBar control); + + // Sizing + public abstract int ToolBarGripWidth {get;} // Grip width for the ToolBar + public abstract int ToolBarImageGripWidth {get;} // Grip width for the Image on the ToolBarButton + public abstract int ToolBarSeparatorWidth {get;} // width of the separator + public abstract int ToolBarDropDownWidth { get; } // width of the dropdown arrow rect + public abstract int ToolBarDropDownArrowWidth { get; } // width for the dropdown arrow on the ToolBarButton + public abstract int ToolBarDropDownArrowHeight { get; } // height for the dropdown arrow on the ToolBarButton + public abstract Size ToolBarDefaultSize{get;} + + public abstract bool ToolBarHasHotElementStyles (ToolBar toolBar); + public abstract bool ToolBarHasHotCheckedElementStyles { get; } + #endregion // ToolBar +*/ + + #region ToolTip + public abstract void DrawToolTip(Graphics dc, Rectangle clip_rectangle, ToolTip.ToolTipWindow control); + public abstract Size ToolTipSize(ToolTip.ToolTipWindow tt, string text); + public abstract bool ToolTipTransparentBackground { get; } + #endregion // ToolTip + + #region BalloonWindow + public abstract void ShowBalloonWindow (IntPtr handle, int timeout, string title, string text, ToolTipIcon icon); + public abstract void HideBalloonWindow (IntPtr handle); + public abstract void DrawBalloonWindow (Graphics dc, Rectangle clip, NotifyIcon.BalloonWindow control); + public abstract Rectangle BalloonWindowRect (NotifyIcon.BalloonWindow control); + #endregion // BalloonWindow + + #region TrackBar + // Drawing + public abstract void DrawTrackBar (Graphics dc, Rectangle clip_rectangle, TrackBar tb); + + // Sizing + public abstract Size TrackBarDefaultSize{get; } // Default size for the TrackBar control + + public abstract int TrackBarValueFromMousePosition (int x, int y, TrackBar tb); + + public abstract bool TrackBarHasHotThumbStyle { get; } + #endregion // TrackBar + + #region UpDownBase + public abstract void UpDownBaseDrawButton (Graphics g, Rectangle bounds, bool top, VisualStyles.PushButtonState state); + public abstract bool UpDownBaseHasHotButtonStyle { get; } + #endregion + + #region VScrollBar + public abstract Size VScrollBarDefaultSize{get;} // Default size of the scrollbar + #endregion // VScrollBar + + #region TreeView + public abstract Size TreeViewDefaultSize { get; } + public abstract void TreeViewDrawNodePlusMinus (TreeView treeView, TreeNode node, Graphics dc, int x, int middle); + #endregion + + #region Managed window + public abstract void DrawManagedWindowDecorations (Graphics dc, Rectangle clip, InternalWindowManager wm); + public abstract int ManagedWindowTitleBarHeight (InternalWindowManager wm); + public abstract int ManagedWindowBorderWidth (InternalWindowManager wm); + public abstract int ManagedWindowIconWidth (InternalWindowManager wm); + public abstract Size ManagedWindowButtonSize (InternalWindowManager wm); + public abstract void ManagedWindowSetButtonLocations (InternalWindowManager wm); + public abstract Rectangle ManagedWindowGetTitleBarIconArea (InternalWindowManager wm); + public abstract Size ManagedWindowGetMenuButtonSize (InternalWindowManager wm); + public abstract bool ManagedWindowTitleButtonHasHotElementStyle (TitleButton button, Form form); + public abstract void ManagedWindowDrawMenuButton (Graphics dc, TitleButton button, Rectangle clip, InternalWindowManager wm); + public abstract void ManagedWindowOnSizeInitializedOrChanged (Form form); + public const int ManagedWindowSpacingAfterLastTitleButton = 2; + #endregion + + #region WidgetPaint Methods + public abstract void CPDrawBorder (Graphics graphics, Rectangle bounds, Color leftColor, int leftWidth, + ButtonBorderStyle leftStyle, Color topColor, int topWidth, ButtonBorderStyle topStyle, + Color rightColor, int rightWidth, ButtonBorderStyle rightStyle, Color bottomColor, + int bottomWidth, ButtonBorderStyle bottomStyle); + + public abstract void CPDrawBorder (Graphics graphics, RectangleF bounds, Color leftColor, int leftWidth, + ButtonBorderStyle leftStyle, Color topColor, int topWidth, ButtonBorderStyle topStyle, + Color rightColor, int rightWidth, ButtonBorderStyle rightStyle, Color bottomColor, + int bottomWidth, ButtonBorderStyle bottomStyle); + + public abstract void CPDrawBorder3D (Graphics graphics, Rectangle rectangle, Border3DStyle style, Border3DSide sides); + public abstract void CPDrawBorder3D (Graphics graphics, Rectangle rectangle, Border3DStyle style, Border3DSide sides, Color control_color); + public abstract void CPDrawButton (Graphics graphics, Rectangle rectangle, ButtonState state); + public abstract void CPDrawCaptionButton (Graphics graphics, Rectangle rectangle, CaptionButton button, ButtonState state); + public abstract void CPDrawCheckBox (Graphics graphics, Rectangle rectangle, ButtonState state); + public abstract void CPDrawComboButton (Graphics graphics, Rectangle rectangle, ButtonState state); + public abstract void CPDrawContainerGrabHandle (Graphics graphics, Rectangle bounds); + public abstract void CPDrawFocusRectangle (Graphics graphics, Rectangle rectangle, Color foreColor, Color backColor); + public abstract void CPDrawGrabHandle (Graphics graphics, Rectangle rectangle, bool primary, bool enabled); + public abstract void CPDrawGrid (Graphics graphics, Rectangle area, Size pixelsBetweenDots, Color backColor); + public abstract void CPDrawImageDisabled (Graphics graphics, Image image, int x, int y, Color background); + public abstract void CPDrawLockedFrame (Graphics graphics, Rectangle rectangle, bool primary); + public abstract void CPDrawMenuGlyph (Graphics graphics, Rectangle rectangle, MenuGlyph glyph, Color color, Color backColor); + public abstract void CPDrawMixedCheckBox (Graphics graphics, Rectangle rectangle, ButtonState state); + public abstract void CPDrawRadioButton (Graphics graphics, Rectangle rectangle, ButtonState state); + public abstract void CPDrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style); + public abstract void CPDrawReversibleLine (Point start, Point end, Color backColor); + public abstract void CPDrawScrollButton (Graphics graphics, Rectangle rectangle, ScrollButton button, ButtonState state); + public abstract void CPDrawSelectionFrame (Graphics graphics, bool active, Rectangle outsideRect, Rectangle insideRect, + Color backColor); + public abstract void CPDrawSizeGrip (Graphics graphics, Color backColor, Rectangle bounds); + public abstract void CPDrawStringDisabled (Graphics graphics, string s, Font font, Color color, RectangleF layoutRectangle, + StringFormat format); + public abstract void CPDrawStringDisabled (IDeviceContext dc, string s, Font font, Color color, Rectangle layoutRectangle, TextFormatFlags format); + public abstract void CPDrawVisualStyleBorder (Graphics graphics, Rectangle bounds); + public abstract void CPDrawBorderStyle (Graphics dc, Rectangle area, BorderStyle border_style); + #endregion // WidgetPaint Methods + } +} diff --git a/source/ShiftUI/Internal/Timer.cs b/source/ShiftUI/Internal/Timer.cs new file mode 100644 index 0000000..e51c40d --- /dev/null +++ b/source/ShiftUI/Internal/Timer.cs @@ -0,0 +1,170 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) + + +using System; +using System.Threading; +using System.ComponentModel; + +namespace ShiftUI { + [DefaultProperty("Interval")] + [DefaultEvent("Tick")] + [ToolboxItemFilter("ShiftUI", ToolboxItemFilterType.Allow)] + public class Timer : Component { + + private bool enabled; + private int interval = 100; + private DateTime expires; + internal Thread thread; + internal bool Busy; + internal IntPtr window; + object Widget_tag; + + internal static readonly int Minimum = 15; + + public Timer () + { + enabled = false; + } + + public Timer (IContainer container) : this () + { + container.Add (this); + } + + [DefaultValue (false)] + public virtual bool Enabled { + get { + return enabled; + } + set { + if (value != enabled) { + enabled = value; + if (value) { + // Use AddTicks so we get some rounding + expires = DateTime.UtcNow.AddMilliseconds (interval > Minimum ? interval : Minimum); + + thread = Thread.CurrentThread; + XplatUI.SetTimer (this); + } else { + XplatUI.KillTimer (this); + thread = null; + } + } + } + } + + [DefaultValue (100)] + public int Interval { + get { + return interval; + } + set { + if (value <= 0) + throw new ArgumentOutOfRangeException ("Interval", string.Format ("'{0}' is not a valid value for Interval. Interval must be greater than 0.", value)); + + if (interval == value) { + return; + } + + interval = value; + + // Use AddTicks so we get some rounding + expires = DateTime.UtcNow.AddMilliseconds (interval > Minimum ? interval : Minimum); + + if (enabled == true) { + XplatUI.KillTimer (this); + XplatUI.SetTimer (this); + } + } + } + + [Localizable(false)] + [Bindable(true)] + [TypeConverter(typeof(StringConverter))] + [DefaultValue(null)] + [MWFCategory("Data")] + public object Tag { + get { + return Widget_tag; + } + + set { + Widget_tag = value; + } + } + + public void Start () + { + Enabled = true; + } + + public void Stop () + { + Enabled = false; + } + + internal DateTime Expires { + get { + return expires; + } + } + + public event EventHandler Tick; + + public override string ToString () + { + return base.ToString () + ", Interval: " + Interval; + } + + internal void Update (DateTime update) + { + expires = update.AddMilliseconds (interval > Minimum ? interval : Minimum); + } + + internal void FireTick () + { + OnTick (EventArgs.Empty); + } + + + protected virtual void OnTick (EventArgs e) + { + if (Tick != null) + Tick (this, e); + } + + protected override void Dispose (bool disposing) + { + base.Dispose (disposing); + Enabled = false; + } + + internal void TickHandler (object sender, EventArgs e) + { + OnTick (e); + } + } +} + diff --git a/source/ShiftUI/Internal/ToolBarAppearance.cs b/source/ShiftUI/Internal/ToolBarAppearance.cs new file mode 100644 index 0000000..ef3e110 --- /dev/null +++ b/source/ShiftUI/Internal/ToolBarAppearance.cs @@ -0,0 +1,40 @@ +// +// ShiftUI.ToolBarAppearance.cs +// +// 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) 2004 Novell, Inc. +// +// Authors: +// Ravindra ([email protected]) +// +// + + +// COMPLETE + +namespace ShiftUI +{ + public enum ToolBarAppearance + { + Normal = 0, + Flat = 1 + } +} diff --git a/source/ShiftUI/Internal/ToolBarButtonStyle.cs b/source/ShiftUI/Internal/ToolBarButtonStyle.cs new file mode 100644 index 0000000..fffcd99 --- /dev/null +++ b/source/ShiftUI/Internal/ToolBarButtonStyle.cs @@ -0,0 +1,41 @@ +// +// ShiftUI.ToolBarButtonStyle.cs +// +// 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) 2004 Novell, Inc. +// +// Authors: +// Ravindra ([email protected]) +// + + +// COMPLETE + +namespace ShiftUI +{ + public enum ToolBarButtonStyle + { + PushButton = 1, + ToggleButton = 2, + Separator = 3, + DropDownButton =4 + } +} diff --git a/source/ShiftUI/Internal/ToolBarTextAlign.cs b/source/ShiftUI/Internal/ToolBarTextAlign.cs new file mode 100644 index 0000000..9850ca6 --- /dev/null +++ b/source/ShiftUI/Internal/ToolBarTextAlign.cs @@ -0,0 +1,39 @@ +// +// ShiftUI.ToolBarTextAlign.cs +// +// 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) 2004 Novell, Inc. +// +// Authors: +// Ravindra ([email protected]) +// + + +// COMPLETE + +namespace ShiftUI +{ + public enum ToolBarTextAlign + { + Underneath = 0, + Right = 1 + } +} diff --git a/source/ShiftUI/Internal/ToolTip.cs b/source/ShiftUI/Internal/ToolTip.cs new file mode 100644 index 0000000..24895fb --- /dev/null +++ b/source/ShiftUI/Internal/ToolTip.cs @@ -0,0 +1,1004 @@ +// 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) 2004 Novell, Inc. (http://www.novell.com) +// +// Authors: +// Peter Bartok [email protected] +// +// + +using System.Collections; +using System.ComponentModel; +using System.Drawing; +using System.Drawing.Text; +using ShiftUI; +using System; + +namespace ShiftUI { + [DefaultEvent ("Popup")] + [ProvideProperty ("ToolTip", typeof(Widget))] + [ToolboxItemFilter("ShiftUI", ToolboxItemFilterType.Allow)] + public class ToolTip : System.ComponentModel.Component, System.ComponentModel.IExtenderProvider { + #region Local variables + internal bool is_active; + internal int automatic_delay; + internal int autopop_delay; + internal int initial_delay; + internal int re_show_delay; + internal bool show_always; + + internal Color back_color; + internal Color fore_color; + + internal ToolTipWindow tooltip_window; // The actual tooltip window + internal Hashtable tooltip_strings; // List of strings for each Widget, indexed by Widget + internal ArrayList Widgets; + internal Widget active_Widget; // Widget for which the tooltip is currently displayed + internal Widget last_Widget; // last Widget the mouse was in + internal Timer timer; // Used for the various intervals + private Form hooked_form; + + private bool isBalloon; + private bool owner_draw; + private bool stripAmpersands; + private ToolTipIcon tool_tip_icon; + private bool useAnimation; + private bool useFading; + private object tag; + + #endregion // Local variables + + #region ToolTipWindow Class + internal class ToolTipWindow : Widget { + #region ToolTipWindow Class Local Variables + private Widget associated_Widget; + internal Icon icon; + internal string title = String.Empty; + internal Rectangle icon_rect; + internal Rectangle title_rect; + internal Rectangle text_rect; + #endregion // ToolTipWindow Class Local Variables + + #region ToolTipWindow Class Constructor + internal ToolTipWindow() { + Visible = false; + Size = new Size(100, 20); + ForeColor = ThemeEngine.Current.ColorInfoText; + BackColor = ThemeEngine.Current.ColorInfo; + + VisibleChanged += new EventHandler(ToolTipWindow_VisibleChanged); + + // UIA Framework: Used to generate UnPopup + VisibleChanged += new EventHandler (OnUIAToolTip_VisibleChanged); + + SetStyle (Widgetstyles.UserPaint | Widgetstyles.AllPaintingInWmPaint, true); + SetStyle (Widgetstyles.ResizeRedraw, true); + if (ThemeEngine.Current.ToolTipTransparentBackground) { + SetStyle (Widgetstyles.SupportsTransparentBackColor, true); + BackColor = Color.Transparent; + } else + SetStyle (Widgetstyles.Opaque, true); + } + + #endregion // ToolTipWindow Class Constructor + + #region ToolTipWindow Class Protected Instance Methods + protected override void OnCreateWidget() { + base.OnCreateWidget (); + XplatUI.SetTopmost(this.window.Handle, true); + } + + protected override CreateParams CreateParams { + get { + CreateParams cp; + + cp = base.CreateParams; + + cp.Style = (int)WindowStyles.WS_POPUP; + cp.Style |= (int)WindowStyles.WS_CLIPSIBLINGS; + + cp.ExStyle = (int)(WindowExStyles.WS_EX_TOOLWINDOW | WindowExStyles.WS_EX_TOPMOST); + + return cp; + } + } + + protected override void OnPaint(PaintEventArgs pevent) { + // We don't do double-buffering on purpose: + // 1) we'd have to meddle with is_visible, it destroys the buffers if !visible + // 2) We don't draw much, no need to double buffer + base.OnPaint(pevent); + + OnDraw (new DrawToolTipEventArgs (pevent.Graphics, associated_Widget, associated_Widget, ClientRectangle, this.Text, this.BackColor, this.ForeColor, this.Font)); + } + + protected override void OnTextChanged (EventArgs args) + { + Invalidate (); + base.OnTextChanged (args); + } + + protected override void WndProc(ref Message m) { + if (m.Msg == (int)Msg.WM_SETFOCUS) { + if (m.WParam != IntPtr.Zero) { + XplatUI.SetFocus(m.WParam); + } + } + base.WndProc (ref m); + } + + + #endregion // ToolTipWindow Class Protected Instance Methods + + #region ToolTipWindow Class Private Methods + internal virtual void OnDraw (DrawToolTipEventArgs e) + { + DrawToolTipEventHandler eh = (DrawToolTipEventHandler)(Events[DrawEvent]); + if (eh != null) + eh (this, e); + else + ThemeEngine.Current.DrawToolTip (e.Graphics, e.Bounds, this); + } + + internal virtual void OnPopup (PopupEventArgs e) + { + PopupEventHandler eh = (PopupEventHandler)(Events[PopupEvent]); + if (eh != null) + eh (this, e); + else + e.ToolTipSize = ThemeEngine.Current.ToolTipSize (this, Text); + } + + private void ToolTipWindow_VisibleChanged(object sender, EventArgs e) { + Widget Widget = (Widget)sender; + + if (Widget.is_visible) { + XplatUI.SetTopmost(Widget.window.Handle, true); + } else { + XplatUI.SetTopmost(Widget.window.Handle, false); + } + } + + // UIA Framework + private void OnUIAToolTip_VisibleChanged (object sender, EventArgs e) + { + if (Visible == false) + OnUnPopup (new PopupEventArgs (associated_Widget, associated_Widget, false, Size.Empty)); + } + + private void OnUnPopup (PopupEventArgs e) + { + PopupEventHandler eh = (PopupEventHandler) (Events [UnPopupEvent]); + if (eh != null) + eh (this, e); + } + + + #endregion // ToolTipWindow Class Protected Instance Methods + + #region Internal Properties + internal override bool ActivateOnShow { get { return false; } } + #endregion + + // This Present is used when we are using the expicit Show methods for 2.0. + // It will not reposition the window. + public void PresentModal (Widget Widget, string text) + { + if (IsDisposed) + return; + + Size display_size; + XplatUI.GetDisplaySize (out display_size); + + associated_Widget = Widget; + + Text = text; + + PopupEventArgs pea = new PopupEventArgs (Widget, Widget, false, Size.Empty); + OnPopup (pea); + + if (pea.Cancel) + return; + + Size = pea.ToolTipSize; + + Visible = true; + } + + public void Present (Widget Widget, string text) + { + if (IsDisposed) + return; + + Size display_size; + XplatUI.GetDisplaySize (out display_size); + + associated_Widget = Widget; + + Text = text; + + PopupEventArgs pea = new PopupEventArgs (Widget, Widget, false, Size.Empty); + OnPopup (pea); + + if (pea.Cancel) + return; + + Size size = pea.ToolTipSize; + + Width = size.Width; + Height = size.Height; + + int cursor_w, cursor_h, hot_x, hot_y; + XplatUI.GetCursorInfo (Widget.Cursor.Handle, out cursor_w, out cursor_h, out hot_x, out hot_y); + Point loc = Widget.MousePosition; + loc.Y += (cursor_h - hot_y); + + if ((loc.X + Width) > display_size.Width) + loc.X = display_size.Width - Width; + + if ((loc.Y + Height) > display_size.Height) + loc.Y = Widget.MousePosition.Y - Height - hot_y; + + Location = loc; + Visible = true; + BringToFront (); + } + + + #region Internal Events + static object DrawEvent = new object (); + static object PopupEvent = new object (); + + // UIA Framework + static object UnPopupEvent = new object (); + + public event DrawToolTipEventHandler Draw { + add { Events.AddHandler (DrawEvent, value); } + remove { Events.RemoveHandler (DrawEvent, value); } + } + + public event PopupEventHandler Popup { + add { Events.AddHandler (PopupEvent, value); } + remove { Events.RemoveHandler (PopupEvent, value); } + } + + internal event PopupEventHandler UnPopup { + add { Events.AddHandler (UnPopupEvent, value); } + remove { Events.RemoveHandler (UnPopupEvent, value); } + } + #endregion + } + #endregion // ToolTipWindow Class + + #region Public Constructors & Destructors + public ToolTip() { + + // Defaults from MS + is_active = true; + automatic_delay = 500; + autopop_delay = 5000; + initial_delay = 500; + re_show_delay = 100; + show_always = false; + back_color = SystemColors.Info; + fore_color = SystemColors.InfoText; + + isBalloon = false; + stripAmpersands = false; + useAnimation = true; + useFading = true; + tooltip_strings = new Hashtable(5); + Widgets = new ArrayList(5); + + tooltip_window = new ToolTipWindow(); + tooltip_window.MouseLeave += new EventHandler(Widget_MouseLeave); + tooltip_window.Draw += new DrawToolTipEventHandler (tooltip_window_Draw); + tooltip_window.Popup += new PopupEventHandler (tooltip_window_Popup); + + // UIA Framework: Static event handlers + tooltip_window.UnPopup += delegate (object sender, PopupEventArgs args) { + OnUnPopup (args); + }; + UnPopup += new PopupEventHandler (OnUIAUnPopup); + + timer = new Timer(); + timer.Enabled = false; + timer.Tick +=new EventHandler(timer_Tick); + + } + + + #region UIA Framework: Events, Delegates and Methods + // NOTE: + // We are using Reflection to add/remove internal events. + // Class ToolTipListener uses the events. + // + // - UIAUnPopup. Event used to generate ChildRemoved in ToolTip + // - UIAToolTipHookUp. Event used to keep track of associated Widgets + // - UIAToolTipUnhookUp. Event used to remove track of associated Widgets + static object UnPopupEvent = new object (); + + internal event PopupEventHandler UnPopup { + add { Events.AddHandler (UnPopupEvent, value); } + remove { Events.RemoveHandler (UnPopupEvent, value); } + } + + internal static event PopupEventHandler UIAUnPopup; + internal static event WidgetEventHandler UIAToolTipHookUp; + internal static event WidgetEventHandler UIAToolTipUnhookUp; + + internal Rectangle UIAToolTipRectangle { + get { return tooltip_window.Bounds; } + } + + internal static void OnUIAUnPopup (object sender, PopupEventArgs args) + { + if (UIAUnPopup != null) + UIAUnPopup (sender, args); + } + + internal static void OnUIAToolTipHookUp (object sender, WidgetEventArgs args) + { + if (UIAToolTipHookUp != null) + UIAToolTipHookUp (sender, args); + } + + internal static void OnUIAToolTipUnhookUp (object sender, WidgetEventArgs args) + { + if (UIAToolTipUnhookUp != null) + UIAToolTipUnhookUp (sender, args); + } + + #endregion + + public ToolTip(System.ComponentModel.IContainer cont) : this() { + cont.Add (this); + } + + ~ToolTip() { + } + #endregion // Public Constructors & Destructors + + #region Public Instance Properties + [DefaultValue (true)] + public bool Active { + get { + return is_active; + } + + set { + if (is_active != value) { + is_active = value; + + if (tooltip_window.Visible) { + tooltip_window.Visible = false; + active_Widget = null; + } + } + } + } + + [DefaultValue (500)] + [RefreshProperties (RefreshProperties.All)] + public int AutomaticDelay { + get { + return automatic_delay; + } + + set { + if (automatic_delay != value) { + automatic_delay = value; + autopop_delay = automatic_delay * 10; + initial_delay = automatic_delay; + re_show_delay = automatic_delay / 5; + } + } + } + + [RefreshProperties (RefreshProperties.All)] + public int AutoPopDelay { + get { + return autopop_delay; + } + + set { + if (autopop_delay != value) { + autopop_delay = value; + } + } + } + + [DefaultValue ("Color [Info]")] + public Color BackColor { + get { return this.back_color; } + set { this.back_color = value; tooltip_window.BackColor = value; } + } + + [DefaultValue ("Color [InfoText]")] + public Color ForeColor + { + get { return this.fore_color; } + set { this.fore_color = value; tooltip_window.ForeColor = value; } + } + + [RefreshProperties (RefreshProperties.All)] + public int InitialDelay { + get { + return initial_delay; + } + + set { + if (initial_delay != value) { + initial_delay = value; + } + } + } + + [DefaultValue (false)] + public bool OwnerDraw { + get { return this.owner_draw; } + set { this.owner_draw = value; } + } + + [RefreshProperties (RefreshProperties.All)] + public int ReshowDelay { + get { + return re_show_delay; + } + + set { + if (re_show_delay != value) { + re_show_delay = value; + } + } + } + + [DefaultValue (false)] + public bool ShowAlways { + get { + return show_always; + } + + set { + if (show_always != value) { + show_always = value; + } + } + } + + + [DefaultValue (false)] + public bool IsBalloon { + get { return isBalloon; } + set { isBalloon = value; } + } + + [Browsable (true)] + [DefaultValue (false)] + public bool StripAmpersands { + get { return stripAmpersands; } + set { stripAmpersands = value; } + } + + [Localizable (false)] + [Bindable (true)] + [TypeConverter (typeof (StringConverter))] + [DefaultValue (null)] + public object Tag { + get { return tag; } + set { tag = value; } + } + + [DefaultValue (ToolTipIcon.None)] + public ToolTipIcon ToolTipIcon { + get { return this.tool_tip_icon; } + set { + switch (value) { + case ToolTipIcon.None: + tooltip_window.icon = null; + break; + case ToolTipIcon.Error: + tooltip_window.icon = SystemIcons.Error; + break; + case ToolTipIcon.Warning: + tooltip_window.icon = SystemIcons.Warning; + break; + case ToolTipIcon.Info: + tooltip_window.icon = SystemIcons.Information; + break; + } + + tool_tip_icon = value; + } + } + + [DefaultValue ("")] + public string ToolTipTitle { + get { return tooltip_window.title; } + set { + if (value == null) + value = String.Empty; + + tooltip_window.title = value; + } + } + + [Browsable (true)] + [DefaultValue (true)] + public bool UseAnimation { + get { return useAnimation; } + set { useAnimation = value; } + } + + [Browsable (true)] + [DefaultValue (true)] + public bool UseFading { + get { return useFading; } + set { useFading = value; } + } + + #endregion // Public Instance Properties + + #region Protected Properties + protected virtual CreateParams CreateParams + { + get + { + CreateParams cp = new CreateParams (); + + cp.Style = 2; + + return cp; + } + } + #endregion + + #region Public Instance Methods + public bool CanExtend(object target) { + return false; + } + + [Localizable (true)] + [DefaultValue ("")] + public string GetToolTip (Widget Widget) + { + string tooltip = (string)tooltip_strings[Widget]; + if (tooltip == null) + return ""; + return tooltip; + } + + public void RemoveAll() { + tooltip_strings.Clear(); + //UIA Framework: ToolTip isn't associated anymore + foreach (Widget Widget in Widgets) + OnUIAToolTipUnhookUp (this, new WidgetEventArgs (Widget)); + + Widgets.Clear(); + } + + public void SetToolTip(Widget Widget, string caption) { + // UIA Framework + OnUIAToolTipHookUp (this, new WidgetEventArgs (Widget)); + tooltip_strings[Widget] = caption; + + // no need for duplicates + if (!Widgets.Contains(Widget)) { + Widget.MouseEnter += new EventHandler(Widget_MouseEnter); + Widget.MouseMove += new MouseEventHandler(Widget_MouseMove); + Widget.MouseLeave += new EventHandler(Widget_MouseLeave); + Widget.MouseDown += new MouseEventHandler (Widget_MouseDown); + Widgets.Add(Widget); + } + + // if SetToolTip is called from a Widget and the mouse is currently over that Widget, + // make sure that tooltip_window.Text gets updated if it's being shown, + // or show the tooltip for it if is not + if (active_Widget == Widget && caption != null && state == TipState.Show) { + Size size = ThemeEngine.Current.ToolTipSize(tooltip_window, caption); + tooltip_window.Width = size.Width; + tooltip_window.Height = size.Height; + tooltip_window.Text = caption; + timer.Stop (); + timer.Start (); + } else if (Widget.IsHandleCreated && MouseInWidget (Widget, false)) + ShowTooltip (Widget); + } + + public override string ToString() { + return base.ToString() + " InitialDelay: " + initial_delay + ", ShowAlways: " + show_always; + } + + public void Show (string text, IWin32Window window) + { + Show (text, window, 0); + } + + public void Show (string text, IWin32Window window, int duration) + { + if (window == null) + throw new ArgumentNullException ("window"); + if (duration < 0) + throw new ArgumentOutOfRangeException ("duration", "duration cannot be less than zero"); + + if (!Active) + return; + + timer.Stop (); + + Widget c = (Widget)window; + + XplatUI.SetOwner (tooltip_window.Handle, c.TopLevelWidget.Handle); + + // If the mouse is in the requested window, use that position + // Else, center in the requested window + if (c.ClientRectangle.Contains (c.PointToClient (Widget.MousePosition))) { + tooltip_window.Location = Widget.MousePosition; + tooltip_strings[c] = text; + HookupWidgetEvents (c); + } + else + tooltip_window.Location = c.PointToScreen (new Point (c.Width / 2, c.Height / 2)); + + // We need to hide our tooltip if the form loses focus, is closed, or is minimized + HookupFormEvents ((Form)c.TopLevelWidget); + + tooltip_window.PresentModal ((Widget)window, text); + + state = TipState.Show; + + if (duration > 0) { + timer.Interval = duration; + timer.Start (); + } + } + + public void Show (string text, IWin32Window window, Point point) + { + Show (text, window, point, 0); + } + + public void Show (string text, IWin32Window window, int x, int y) + { + Show (text, window, new Point (x, y), 0); + } + + public void Show (string text, IWin32Window window, Point point, int duration) + { + if (window == null) + throw new ArgumentNullException ("window"); + if (duration < 0) + throw new ArgumentOutOfRangeException ("duration", "duration cannot be less than zero"); + + if (!Active) + return; + + timer.Stop (); + + Widget c = (Widget)window; + + Point display_point = c.PointToScreen (Point.Empty); + display_point.X += point.X; + display_point.Y += point.Y; + + XplatUI.SetOwner (tooltip_window.Handle, c.TopLevelWidget.Handle); + + // We need to hide our tooltip if the form loses focus, is closed, or is minimized + HookupFormEvents ((Form)c.TopLevelWidget); + + tooltip_window.Location = display_point; + tooltip_window.PresentModal ((Widget)window, text); + + state = TipState.Show; + + if (duration > 0) { + timer.Interval = duration; + timer.Start (); + } + } + + public void Show (string text, IWin32Window window, int x, int y, int duration) + { + Show (text, window, new Point (x, y), duration); + } + + public void Hide (IWin32Window win) + { + timer.Stop (); + state = TipState.Initial; + + UnhookFormEvents (); + tooltip_window.Visible = false; + } + #endregion // Public Instance Methods + + #region Protected Instance Methods + protected override void Dispose(bool disposing) { + // call the base impl first to avoid conflicts with any parent's events + base.Dispose (disposing); + + if (disposing) { + // Mop up the mess; or should we wait for the GC to kick in? + timer.Stop(); + timer.Dispose(); + + // Not sure if we should clean up tooltip_window + tooltip_window.Dispose(); + + tooltip_strings.Clear(); + + //UIA Framework: ToolTip isn't associated anymore + foreach (Widget Widget in Widgets) + OnUIAToolTipUnhookUp (this, new WidgetEventArgs (Widget)); + Widgets.Clear(); + } + } + + protected void StopTimer () + { + timer.Stop (); + } + #endregion // Protected Instance Methods + + internal enum TipState { + Initial, + Show, + Down + } + + TipState state = TipState.Initial; + + #region Private Methods + + private void HookupFormEvents (Form form) + { + hooked_form = form; + + form.Deactivate += new EventHandler (Form_Deactivate); + form.Closed += new EventHandler (Form_Closed); + form.Resize += new EventHandler (Form_Resize); + } + + private void HookupWidgetEvents (Widget widget) + { + if (!Widgets.Contains (widget)) { + widget.MouseEnter += new EventHandler (Widget_MouseEnter); + widget.MouseMove += new MouseEventHandler (Widget_MouseMove); + widget.MouseLeave += new EventHandler (Widget_MouseLeave); + widget.MouseDown += new MouseEventHandler (Widget_MouseDown); + Widgets.Add (widget); + } + } + + private void UnhookWidgetEvents (Widget widget) + { + widget.MouseEnter -= new EventHandler (Widget_MouseEnter); + widget.MouseMove -= new MouseEventHandler (Widget_MouseMove); + widget.MouseLeave -= new EventHandler (Widget_MouseLeave); + widget.MouseDown -= new MouseEventHandler (Widget_MouseDown); + } + private void UnhookFormEvents () + { + if (hooked_form == null) + return; + + hooked_form.Deactivate -= new EventHandler (Form_Deactivate); + hooked_form.Closed -= new EventHandler (Form_Closed); + hooked_form.Resize -= new EventHandler (Form_Resize); + + hooked_form = null; + } + + + private void Form_Resize (object sender, EventArgs e) + { + Form f = (Form)sender; + + if (f.WindowState == FormWindowState.Minimized) + tooltip_window.Visible = false; + } + + private void Form_Closed (object sender, EventArgs e) + { + tooltip_window.Visible = false; + } + + private void Form_Deactivate (object sender, EventArgs e) + { + tooltip_window.Visible = false; + } + + internal void Present (Widget Widget, string text) + { + tooltip_window.Present (Widget, text); + } + + private void Widget_MouseEnter (object sender, EventArgs e) + { + ShowTooltip (sender as Widget); + } + + private void ShowTooltip (Widget Widget) + { + last_Widget = Widget; + + // Whatever we're displaying right now, we don't want it anymore + tooltip_window.Visible = false; + timer.Stop(); + state = TipState.Initial; + + if (!is_active) + return; + + // ShowAlways Widgets whether the Widgets in non-active forms + // can display its tooltips, even if they are not current active Widget. + if (!show_always && Widget.FindForm () != Form.ActiveForm) + return; + + string text = (string)tooltip_strings[Widget]; + if (text != null && text.Length > 0) { + if (active_Widget == null) { + timer.Interval = Math.Max (initial_delay, 1); + } else { + timer.Interval = Math.Max (re_show_delay, 1); + } + + active_Widget = Widget; + timer.Start (); + } + } + + private void timer_Tick(object sender, EventArgs e) { + timer.Stop(); + + switch (state) { + case TipState.Initial: + if (active_Widget == null) + return; + tooltip_window.Present (active_Widget, (string)tooltip_strings[active_Widget]); + state = TipState.Show; + timer.Interval = autopop_delay; + timer.Start(); + break; + + case TipState.Show: + tooltip_window.Visible = false; + state = TipState.Down; + break; + + default: + throw new Exception ("Timer shouldn't be running in state: " + state); + } + } + + private void tooltip_window_Popup (object sender, PopupEventArgs e) + { + e.ToolTipSize = ThemeEngine.Current.ToolTipSize (tooltip_window, tooltip_window.Text); + OnPopup (e); + } + + private void tooltip_window_Draw (object sender, DrawToolTipEventArgs e) + { + if (OwnerDraw) + OnDraw (e); + else + ThemeEngine.Current.DrawToolTip (e.Graphics, e.Bounds, tooltip_window); + } + + private bool MouseInWidget (Widget Widget, bool fuzzy) { + Point m; + Point c; + Size cw; + + if (Widget == null) { + return false; + } + + m = Widget.MousePosition; + c = new Point(Widget.Bounds.X, Widget.Bounds.Y); + if (Widget.Parent != null) { + c = Widget.Parent.PointToScreen(c); + } + cw = Widget.ClientSize; + + + Rectangle rect = new Rectangle (c, cw); + + // + // We won't get mouse move events on all platforms with the exact same + // frequency, so cheat a bit. + if (fuzzy) + rect.Inflate (2, 2); + + return rect.Contains (m); + } + + private void Widget_MouseLeave(object sender, EventArgs e) + { + timer.Stop (); + + active_Widget = null; + tooltip_window.Visible = false; + + if (last_Widget == sender) + last_Widget = null; + } + + + void Widget_MouseDown (object sender, MouseEventArgs e) + { + timer.Stop(); + + active_Widget = null; + tooltip_window.Visible = false; + + if (last_Widget == sender) + last_Widget = null; + } + + private void Widget_MouseMove(object sender, MouseEventArgs e) { + if (state != TipState.Down) { + timer.Stop(); + timer.Start(); + } + } + + internal void OnDraw (DrawToolTipEventArgs e) + { + DrawToolTipEventHandler eh = (DrawToolTipEventHandler)(Events[DrawEvent]); + if (eh != null) + eh (this, e); + } + + internal void OnPopup (PopupEventArgs e) + { + PopupEventHandler eh = (PopupEventHandler) (Events [PopupEvent]); + if (eh != null) + eh (this, e); + } + + internal void OnUnPopup (PopupEventArgs e) + { + PopupEventHandler eh = (PopupEventHandler) (Events [UnPopupEvent]); + if (eh != null) + eh (this, e); + } + + internal bool Visible { + get { return tooltip_window.Visible; } + } + #endregion // Private Methods + + #region Events + static object PopupEvent = new object (); + static object DrawEvent = new object (); + + public event PopupEventHandler Popup { + add { Events.AddHandler (PopupEvent, value); } + remove { Events.RemoveHandler (PopupEvent, value); } + } + + public event DrawToolTipEventHandler Draw { + add { Events.AddHandler (DrawEvent, value); } + remove { Events.RemoveHandler (DrawEvent, value); } + } + #endregion + } +} diff --git a/source/ShiftUI/Internal/ToolTipIcon.cs b/source/ShiftUI/Internal/ToolTipIcon.cs new file mode 100644 index 0000000..2adcca8 --- /dev/null +++ b/source/ShiftUI/Internal/ToolTipIcon.cs @@ -0,0 +1,39 @@ +// +// ToolTipIcon.cs +// +// 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) 2006 Novell, Inc. +// +// Authors: +// Jonathan Pobst ([email protected]) +// + + +namespace ShiftUI +{ + public enum ToolTipIcon + { + None = 0, + Info = 1, + Warning = 2, + Error = 3 + } +} diff --git a/source/ShiftUI/Internal/ToolWindowManager.cs b/source/ShiftUI/Internal/ToolWindowManager.cs new file mode 100644 index 0000000..ba080d7 --- /dev/null +++ b/source/ShiftUI/Internal/ToolWindowManager.cs @@ -0,0 +1,47 @@ +// 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) 2007 Novell, Inc. (http://www.novell.com) +// +// Authors: +// Rolf Bjarne Kvinge ([email protected]) +// +// + + +using System; +using System.Drawing; +using System.Runtime.InteropServices; + +namespace ShiftUI +{ + internal class ToolWindowManager : InternalWindowManager + { + public ToolWindowManager (Form form) + : base (form) + { + + } + + public override void SetWindowState (FormWindowState old_state, FormWindowState window_state) + { + // Do nothing here. + } + } +} diff --git a/source/ShiftUI/Internal/TreeNodeCollection.cs b/source/ShiftUI/Internal/TreeNodeCollection.cs new file mode 100644 index 0000000..5323579 --- /dev/null +++ b/source/ShiftUI/Internal/TreeNodeCollection.cs @@ -0,0 +1,611 @@ +// 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) 2004-2006 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) + + +using System; +using System.Collections; +using System.ComponentModel; +using System.Globalization; +using System.Collections.Generic; + +namespace ShiftUI { + //[Editor("ShiftUI.Design.TreeNodeCollectionEditor, " + Consts.AssemblySystem_Design, typeof(System.Drawing.Design.UITypeEditor))] + public class TreeNodeCollection : IList, ICollection, IEnumerable { + + private static readonly int OrigSize = 50; + + private TreeNode owner; + private int count; + private TreeNode [] nodes; + + private TreeNodeCollection () + { + } + + internal TreeNodeCollection (TreeNode owner) + { + this.owner = owner; + nodes = new TreeNode [OrigSize]; + } + + [Browsable(false)] + public int Count { + get { return count; } + } + + public bool IsReadOnly { + get { return false; } + } + + bool ICollection.IsSynchronized { + get { return false; } + } + + object ICollection.SyncRoot { + get { return this; } + } + + bool IList.IsFixedSize { + get { return false; } + } + + object IList.this [int index] { + get { + return this [index]; + } + set { + if (!(value is TreeNode)) + throw new ArgumentException ("Parameter must be of type TreeNode.", "value"); + this [index] = (TreeNode) value; + } + } + + public virtual TreeNode this [int index] { + get { + if (index < 0 || index >= Count) + throw new ArgumentOutOfRangeException ("index"); + return nodes [index]; + } + set { + if (index < 0 || index >= Count) + throw new ArgumentOutOfRangeException ("index"); + SetupNode (value); + nodes [index] = value; + } + } + + public virtual TreeNode this [string key] { + get { + for (int i = 0; i < count; i++) + if (string.Compare (key, nodes[i].Name, true) == 0) + return nodes[i]; + + return null; + } + } + + bool UsingSorting { + get { + TreeView tv = owner == null ? null : owner.TreeView; + return tv != null && (tv.Sorted || tv.TreeViewNodeSorter != null); + } + } + + public virtual TreeNode Add (string text) + { + TreeNode res = new TreeNode (text); + Add (res); + return res; + } + + public virtual int Add (TreeNode node) + { + if (node == null) + throw new ArgumentNullException("node"); + + int index; + TreeView tree_view = null; + + if (owner != null) + tree_view = owner.TreeView; + + if (tree_view != null && UsingSorting) { + index = AddSorted (node); + } else { + if (count >= nodes.Length) + Grow (); + index = count; + count++; + nodes[index] = node; + } + + SetupNode (node); + + // UIA Framework Event: Collection Changed + if (tree_view != null) + tree_view.OnUIACollectionChanged (owner, new CollectionChangeEventArgs (CollectionChangeAction.Add, node)); + return index; + } + + public virtual TreeNode Add (string key, string text) + { + TreeNode node = new TreeNode (text); + node.Name = key; + Add (node); + return node; + } + + public virtual TreeNode Add (string key, string text, int imageIndex) + { + TreeNode node = Add (key, text); + node.ImageIndex = imageIndex; + return node; + } + + public virtual TreeNode Add (string key, string text, string imageKey) + { + TreeNode node = Add (key, text); + node.ImageKey = imageKey; + return node; + + } + + public virtual TreeNode Add (string key, string text, int imageIndex, int selectedImageIndex) + { + TreeNode node = Add (key, text); + node.ImageIndex = imageIndex; + node.SelectedImageIndex = selectedImageIndex; + return node; + } + + public virtual TreeNode Add (string key, string text, string imageKey, string selectedImageKey) + { + TreeNode node = Add (key, text); + node.ImageKey = imageKey; + node.SelectedImageKey = selectedImageKey; + return node; + } + + public virtual void AddRange (TreeNode [] nodes) + { + if (nodes == null) + throw new ArgumentNullException("nodes"); + + // We can't just use Array.Copy because the nodes also + // need to have some properties set when they are added. + for (int i = 0; i < nodes.Length; i++) + Add (nodes [i]); + } + + public virtual void Clear () + { + while (count > 0) + RemoveAt (0, false); + + Array.Clear (nodes, 0, count); + count = 0; + + TreeView tree_view = null; + if (owner != null) { + tree_view = owner.TreeView; + if (tree_view != null) { + tree_view.UpdateBelow (owner); + tree_view.RecalculateVisibleOrder (owner); + tree_view.UpdateScrollBars (false); + } + } + } + + public bool Contains (TreeNode node) + { + return Array.IndexOf (nodes, node, 0, count) != -1; + } + + public virtual bool ContainsKey (string key) + { + for (int i = 0; i < count; i++) { + if (string.Compare (nodes [i].Name, key, true, CultureInfo.InvariantCulture) == 0) + return true; + } + return false; + } + + public void CopyTo (Array dest, int index) + { + Array.Copy (nodes, index, dest, index, count); + } + + public IEnumerator GetEnumerator () + { + return new TreeNodeEnumerator (this); + } + + public int IndexOf (TreeNode node) + { + return Array.IndexOf (nodes, node); + } + + public virtual int IndexOfKey (string key) + { + for (int i = 0; i < count; i++) { + if (string.Compare (nodes [i].Name, key, true, CultureInfo.InvariantCulture) == 0) + return i; + } + return -1; + } + + public virtual TreeNode Insert (int index, string text) + { + TreeNode node = new TreeNode (text); + Insert (index, node); + return node; + } + + public virtual void Insert (int index, TreeNode node) + { + if (count >= nodes.Length) + Grow (); + + Array.Copy (nodes, index, nodes, index + 1, count - index); + nodes [index] = node; + count++; + + // If we can use sorting, it means we have an owner *and* a TreeView + if (UsingSorting) + Sort (owner.TreeView.TreeViewNodeSorter); + + SetupNode (node); + } + + public virtual TreeNode Insert (int index, string key, string text) + { + TreeNode node = new TreeNode (text); + node.Name = key; + Insert (index, node); + return node; + } + + public virtual TreeNode Insert (int index, string key, string text, int imageIndex) + { + TreeNode node = new TreeNode (text); + node.Name = key; + node.ImageIndex = imageIndex; + Insert (index, node); + return node; + } + + public virtual TreeNode Insert (int index, string key, string text, string imageKey) + { + TreeNode node = new TreeNode (text); + node.Name = key; + node.ImageKey = imageKey; + Insert (index, node); + return node; + } + + public virtual TreeNode Insert (int index, string key, string text, int imageIndex, int selectedImageIndex) + { + TreeNode node = new TreeNode (text, imageIndex, selectedImageIndex); + node.Name = key; + Insert (index, node); + return node; + } + + public virtual TreeNode Insert (int index, string key, string text, string imageKey, string selectedImageKey) + { + TreeNode node = new TreeNode (text); + node.Name = key; + node.ImageKey = imageKey; + node.SelectedImageKey = selectedImageKey; + Insert (index, node); + return node; + } + + public void Remove (TreeNode node) + { + if (node == null) + throw new NullReferenceException (); + + int index = IndexOf (node); + if (index != -1) + RemoveAt (index); + } + + public virtual void RemoveAt (int index) + { + RemoveAt (index, true); + } + + private void RemoveAt (int index, bool update) + { + TreeNode removed = nodes [index]; + TreeNode prev = GetPrevNode (removed); + TreeNode new_selected = null; + bool re_set_selected = false; + bool visible = removed.IsVisible; + + TreeView tree_view = null; + if (owner != null) + tree_view = owner.TreeView; + + if (tree_view != null) { + tree_view.RecalculateVisibleOrder (prev); + + if (removed == tree_view.SelectedNode) { + if (removed.IsExpanded) + removed.Collapse(); // Fix Xamarin Bugzilla 5010. + re_set_selected = true; + OpenTreeNodeEnumerator oe = new OpenTreeNodeEnumerator (removed); + if (oe.MoveNext () && oe.MoveNext ()) { + new_selected = oe.CurrentNode; + } else { + oe = new OpenTreeNodeEnumerator (removed); + oe.MovePrevious (); + new_selected = oe.CurrentNode == removed ? null : oe.CurrentNode; + } + } + } + + Array.Copy (nodes, index + 1, nodes, index, count - index - 1); + count--; + + nodes[count] = null; + + if (nodes.Length > OrigSize && nodes.Length > (count * 2)) + Shrink (); + + if (tree_view != null && re_set_selected) { + tree_view.SelectedNode = new_selected; + } + + TreeNode parent = removed.parent; + removed.parent = null; + + if (update && tree_view != null && visible) { + tree_view.RecalculateVisibleOrder (prev); + tree_view.UpdateScrollBars (false); + tree_view.UpdateBelow (parent); + } + + // UIA Framework Event: Collection Changed + if (tree_view != null) + tree_view.OnUIACollectionChanged (owner, new CollectionChangeEventArgs (CollectionChangeAction.Remove, removed)); + } + + public virtual void RemoveByKey (string key) + { + TreeNode node = this[key]; + + if (node != null) + Remove (node); + } + + private TreeNode GetPrevNode (TreeNode node) + { + OpenTreeNodeEnumerator one = new OpenTreeNodeEnumerator (node); + + if (one.MovePrevious () && one.MovePrevious ()) + return one.CurrentNode; + return null; + } + + private void SetupNode (TreeNode node) + { + // We used to remove this from the previous parent, but .Net + // skips this step (even if setting the owner field). + //node.Remove (); + + node.parent = owner; + + TreeView tree_view = null; + if (owner != null) + tree_view = owner.TreeView; + + if (tree_view != null) { + // We may need to invalidate this entire node collection if sorted. + TreeNode prev = UsingSorting ? owner : GetPrevNode (node); + + if (tree_view.IsHandleCreated && node.ArePreviousNodesExpanded) + tree_view.RecalculateVisibleOrder (prev); + if (owner == tree_view.root_node || node.Parent.IsVisible && node.Parent.IsExpanded) + tree_view.UpdateScrollBars (false); + + tree_view.UpdateBelow (owner); + } + } + + int IList.Add (object node) + { + return Add ((TreeNode) node); + } + + bool IList.Contains (object node) + { + return Contains ((TreeNode) node); + } + + int IList.IndexOf (object node) + { + return IndexOf ((TreeNode) node); + } + + void IList.Insert (int index, object node) + { + Insert (index, (TreeNode) node); + } + + void IList.Remove (object node) + { + Remove ((TreeNode) node); + } + + private int AddSorted (TreeNode node) + { + if (count >= nodes.Length) + Grow (); + + TreeView tree_view = owner.TreeView; + if (tree_view.TreeViewNodeSorter != null) { // Custom sorting + nodes [count++] = node; + Sort (tree_view.TreeViewNodeSorter); + return count - 1; + } + + CompareInfo compare = Application.CurrentCulture.CompareInfo; + int index = 0; + bool found = false; + for (int i = 0; i < count; i++) { + index = i; + int comp = compare.Compare (node.Text, nodes [i].Text); + if (comp < 0) { + found = true; + break; + } + } + + // Stick it at the end + if (!found) + index = count; + + // Move the nodes up and adjust their indices + for (int i = count - 1; i >= index; i--) { + nodes [i + 1] = nodes [i]; + } + count++; + nodes [index] = node; + + return index; + } + + // Would be nice to do this without running through the collection twice + internal void Sort (IComparer sorter) { + Array.Sort (nodes, 0, count, sorter == null ? new TreeNodeComparer (Application.CurrentCulture.CompareInfo) : sorter); + + for (int i = 0; i < count; i++) { + nodes [i].Nodes.Sort (sorter); + } + + // Sorted may have been set to false even if TreeViewNodeSorter is being used. + TreeView tv = owner == null ? null : owner.TreeView; + if (tv != null) + tv.sorted = true; + } + + private void Grow () + { + TreeNode [] nn = new TreeNode [nodes.Length + 50]; + Array.Copy (nodes, nn, nodes.Length); + nodes = nn; + } + + private void Shrink () + { + int len = (count + 1 > OrigSize ? count + 1 : OrigSize); + TreeNode [] nn = new TreeNode [len]; + Array.Copy (nodes, nn, count); + nodes = nn; + } + + public TreeNode[] Find (string key, bool searchAllChildren) + { + List<TreeNode> results = new List<TreeNode> (0); + Find (key, searchAllChildren, this, results); + + return results.ToArray (); + } + + private static void Find (string key, bool searchAllChildren, TreeNodeCollection nodes, List<TreeNode> results) + { + for (int i = 0; i < nodes.Count; i++) { + TreeNode thisNode = nodes [i]; + + if (string.Compare (thisNode.Name, key, true, CultureInfo.InvariantCulture) == 0) + results.Add (thisNode); + + } + // Need to match the Microsoft order. + + if (searchAllChildren){ + for (int i = 0; i < nodes.Count; i++){ + TreeNodeCollection childNodes = nodes [i].Nodes; + if (childNodes.Count > 0) { + Find (key, searchAllChildren, childNodes, results); + } + } + } + } + + internal class TreeNodeEnumerator : IEnumerator { + + private TreeNodeCollection collection; + private int index = -1; + + public TreeNodeEnumerator (TreeNodeCollection collection) + { + this.collection = collection; + } + + public object Current { + get { + if (index == -1) + return null; + return collection [index]; + } + } + + public bool MoveNext () + { + if (index + 1 >= collection.Count) + return false; + index++; + return true; + } + + public void Reset () + { + index = -1; + } + } + + private class TreeNodeComparer : IComparer { + + private CompareInfo compare; + + public TreeNodeComparer (CompareInfo compare) + { + this.compare = compare; + } + + public int Compare (object x, object y) + { + TreeNode l = (TreeNode) x; + TreeNode r = (TreeNode) y; + int res = compare.Compare (l.Text, r.Text); + + return (res == 0 ? l.Index - r.Index : res); + } + } + } +} + diff --git a/source/ShiftUI/Internal/TreeNodeConverter.cs b/source/ShiftUI/Internal/TreeNodeConverter.cs new file mode 100644 index 0000000..d9682b4 --- /dev/null +++ b/source/ShiftUI/Internal/TreeNodeConverter.cs @@ -0,0 +1,55 @@ +// 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]) +// +// + +// NOT COMPLETE + +using System.ComponentModel; +using System.Globalization; +using System; + +namespace ShiftUI { + public class TreeNodeConverter : TypeConverter { + + #region Public Instance Methods + public override bool CanConvertTo (ITypeDescriptorContext context, Type destinationType) + { + if (destinationType == typeof (string)) + return true; + return base.CanConvertTo (context, destinationType); + } + + public override object ConvertTo (ITypeDescriptorContext context, CultureInfo culture, + object value, Type destinationType) + { + // Regardless of the type of object passed in this does a ToString + if (destinationType == typeof (string) && value != null) + return value.ToString (); + return base.ConvertTo (context, culture, value, destinationType); + } + + #endregion // Public Instance Methods + } +} diff --git a/source/ShiftUI/Internal/TreeViewHitTestInfo.cs b/source/ShiftUI/Internal/TreeViewHitTestInfo.cs new file mode 100644 index 0000000..7e5c19a --- /dev/null +++ b/source/ShiftUI/Internal/TreeViewHitTestInfo.cs @@ -0,0 +1,51 @@ +// +// TreeViewHitTestLocations.cs +// +// 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) 2007 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) +// + + +namespace ShiftUI { + + public class TreeViewHitTestInfo { + + private TreeNode node; + private TreeViewHitTestLocations location; + + public TreeViewHitTestInfo (TreeNode hitNode, TreeViewHitTestLocations hitLocation) + { + this.node = hitNode; + this.location = hitLocation; + } + + public TreeNode Node { + get { return node; } + } + + public TreeViewHitTestLocations Location { + get { return location; } + } + } +} diff --git a/source/ShiftUI/Internal/TreeViewImageIndexConverter.cs b/source/ShiftUI/Internal/TreeViewImageIndexConverter.cs new file mode 100644 index 0000000..f66b205 --- /dev/null +++ b/source/ShiftUI/Internal/TreeViewImageIndexConverter.cs @@ -0,0 +1,89 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) + + +using System; +using System.Drawing; +using System.Collections; +using System.ComponentModel; + + +namespace ShiftUI { + + public class TreeViewImageIndexConverter : ImageIndexConverter { + + public TreeViewImageIndexConverter () + { + } + + #region Protected Properties + protected override bool IncludeNoneAsStandardValue { + get { return false; } + } + #endregion + + #region Public Methods + public override object ConvertFrom (System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) + { + string indexStr; + + if (value != null && value is string) { + indexStr = (string)value; + + if (indexStr.Equals ("(default)", StringComparison.InvariantCultureIgnoreCase)) + return -1; + else if (indexStr.Equals ("(none)", StringComparison.InvariantCultureIgnoreCase)) + return -2; + + return Int32.Parse (indexStr); + } else + return base.ConvertFrom (context, culture, value); + } + + public override object ConvertTo (System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) + { + if (destinationType == typeof (string)) { + if (value == null) + return string.Empty; + else if (value is int && (int)value == -1) + return "(default)"; + else if (value is int && (int)value == -2) + return "(none)"; + else if (value is string && ((string)value).Length == 0) + return string.Empty; + else + return value.ToString (); + } else + return base.ConvertTo (context, culture, value, destinationType); + } + + public override StandardValuesCollection GetStandardValues (System.ComponentModel.ITypeDescriptorContext context) + { + int[] stdVal = new int[] { -1, -2 }; + return new TypeConverter.StandardValuesCollection (stdVal); + } + #endregion + } +} + diff --git a/source/ShiftUI/Internal/TreeViewImageKeyConverter.cs b/source/ShiftUI/Internal/TreeViewImageKeyConverter.cs new file mode 100644 index 0000000..78ff1d5 --- /dev/null +++ b/source/ShiftUI/Internal/TreeViewImageKeyConverter.cs @@ -0,0 +1,51 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Jonathan Pobst [email protected] +// + +using System.Drawing; +using System.ComponentModel; +using System.Collections; +using System.Diagnostics; +using System.Globalization; +using System.Runtime.InteropServices; +using System; + +namespace ShiftUI +{ + public class TreeViewImageKeyConverter : ImageKeyConverter + { + #region Constructors + public TreeViewImageKeyConverter () { } + #endregion Constructors + + #region Public Methods + // XXX - Can't find the difference from the base method + public override object ConvertTo (ITypeDescriptorContext context, CultureInfo culture, + object value, Type destinationType) + { + return base.ConvertTo (context, culture, value, destinationType); + } + #endregion Public Methods + } +} diff --git a/source/ShiftUI/Internal/VScrollProperties.cs b/source/ShiftUI/Internal/VScrollProperties.cs new file mode 100644 index 0000000..e790787 --- /dev/null +++ b/source/ShiftUI/Internal/VScrollProperties.cs @@ -0,0 +1,33 @@ +// 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. +// +// Authors: +// Olivier Dufour [email protected] +// + +namespace ShiftUI +{ + public class VScrollProperties : ScrollProperties + { + public VScrollProperties (ScrollableWidget container) : base (container) + { + scroll_bar = container.vscrollbar; + } + } +} diff --git a/source/ShiftUI/Internal/Win32DnD.cs b/source/ShiftUI/Internal/Win32DnD.cs new file mode 100644 index 0000000..24cf2da --- /dev/null +++ b/source/ShiftUI/Internal/Win32DnD.cs @@ -0,0 +1,1081 @@ +// 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]) +// Srikanth Madikeri ([email protected]) - Win32 Drop files. +// + +// NOT COMPLETE + +using System; +using System.Collections; +using System.Drawing; +using System.Reflection; +using System.Reflection.Emit; +using System.Runtime.InteropServices; +using System.Runtime.Serialization; +using System.Text; + +namespace ShiftUI { + internal class Win32DnD { + #region Local Variables + private const uint DATADIR_GET = 1; + private const uint S_OK = 0x00000000; + private const uint S_FALSE = 0x00000001; + private const uint DRAGDROP_S_DROP = 0x00040100; + private const uint DRAGDROP_S_CANCEL = 0x00040101; + private const uint DRAGDROP_S_USEDEFAULTCURSORS = 0x00040102; + private const uint E_NOTIMPL = unchecked((uint)0x80004001); + private const uint E_NOINTERFACE = unchecked((uint)0x80004002); + private const uint E_FAIL = unchecked((uint)0x80004005); + private const uint OLE_E_ADVISENOTSUPPORTED = unchecked((uint)0x80040003); + private const uint DV_E_FORMATETC = unchecked((uint)0x80040064); + + // To call function pointers + //private static object[] GetDataArgs; + + // IDataObject Delegates + private static QueryInterfaceDelegate DOQueryInterface; + private static AddRefDelegate DOAddRef; + private static ReleaseDelegate DORelease; + private static GetDataDelegate GetData; + private static GetDataHereDelegate GetDataHere; + private static QueryGetDataDelegate QueryGetData; + private static GetCanonicalFormatEtcDelegate GetCanonicalFormatEtc; + private static SetDataDelegate SetData; + private static EnumFormatEtcDelegate EnumFormatEtc; + private static DAdviseDelegate DAdvise; + private static DUnadviseDelegate DUnadvise; + private static EnumDAdviseDelegate EnumDAdvise; + + // IDropSource Delegates + private static QueryInterfaceDelegate DSQueryInterface; + private static AddRefDelegate DSAddRef; + private static ReleaseDelegate DSRelease; + private static QueryContinueDragDelegate QueryContinueDrag; + private static GiveFeedbackDelegate GiveFeedback; + + // IDropTarget Delegates + private static QueryInterfaceDelegate DTQueryInterface; + private static AddRefDelegate DTAddRef; + private static ReleaseDelegate DTRelease; + private static DragEnterDelegate DragEnter; + private static DragOverDelegate DragOver; + private static DragLeaveDelegate DragLeave; + private static DropDelegate Drop; + + private static DragEventArgs DragDropEventArgs; + private static GiveFeedbackEventArgs DragFeedbackEventArgs; + private static QueryContinueDragEventArgs DragContinueEventArgs; + private static ArrayList DragFormats; + private static FORMATETC[] DragFormatArray; + private static ArrayList DragMediums; + #endregion // Local Variables + + #region Delegate Definitions + // IUnknown + internal delegate uint QueryInterfaceDelegate(IntPtr @this, ref Guid riid, IntPtr ppvObject); + internal delegate uint AddRefDelegate(IntPtr @this); + internal delegate uint ReleaseDelegate(IntPtr @this); + + // IDataObject + internal delegate uint GetDataDelegate(IntPtr @this, ref FORMATETC pformatetcIn, IntPtr pmedium); + internal delegate uint GetDataHereDelegate(IntPtr @this, ref FORMATETC pformatetc, ref STGMEDIUM pmedium); + internal delegate uint QueryGetDataDelegate(IntPtr @this, ref FORMATETC pformatetc); + internal delegate uint GetCanonicalFormatEtcDelegate(IntPtr @this, ref FORMATETC pformatetcIn, IntPtr pformatetcOut); + internal delegate uint SetDataDelegate(IntPtr @this, ref FORMATETC pformatetc, ref STGMEDIUM pmedium, bool release); + internal delegate uint EnumFormatEtcDelegate(IntPtr @this, uint direction, IntPtr ppenumFormatEtc); + internal delegate uint DAdviseDelegate(IntPtr @this, ref FORMATETC pformatetc, uint advf, IntPtr pAdvSink, ref uint pdwConnection); + internal delegate uint DUnadviseDelegate(IntPtr @this, uint pdwConnection); + internal delegate uint EnumDAdviseDelegate(IntPtr @this, IntPtr ppenumAdvise); + + // IDropSource + internal delegate uint QueryContinueDragDelegate(IntPtr @this, bool fEscapePressed, uint grfkeyState); + internal delegate uint GiveFeedbackDelegate(IntPtr @this, uint pdwEffect); + + // IDropTarget + internal delegate uint DragEnterDelegate(IntPtr @this, IntPtr pDataObj, uint grfkeyState, IntPtr pt_x, IntPtr pt_y, IntPtr pdwEffect); + internal delegate uint DragOverDelegate(IntPtr @this, uint grfkeyState, IntPtr pt_x, IntPtr pt_y, IntPtr pdwEffect); + internal delegate uint DragLeaveDelegate(IntPtr @this); + internal delegate uint DropDelegate(IntPtr @this, IntPtr pDataObj, uint grfkeyState, IntPtr pt_x, IntPtr pt_y, IntPtr pdwEffect); + #endregion // Delegate Definitions + + [StructLayout(LayoutKind.Sequential)] + internal struct FORMATETC { + [MarshalAs(UnmanagedType.U2)] + internal ClipboardFormats cfFormat; + internal IntPtr ptd; + internal DVASPECT dwAspect; + internal int lindex; + internal TYMED tymed; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct STGMEDIUM { + internal TYMED tymed; + internal IntPtr hHandle; + internal IntPtr pUnkForRelease; + } + + [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] + internal struct DROPFILES { + internal uint pFiles; + internal uint pt_x; + internal uint pt_y; + internal bool fNC; + internal bool fWide; + internal string pText; + } + + internal enum DVASPECT { + DVASPECT_CONTENT = 1, + DVASPECT_THUMBNAIL = 2, + DVASPECT_ICON = 4, + DVASPECT_DOCPRINT = 8 + } + + internal enum TYMED { + TYMED_HGLOBAL = 1, + TYMED_FILE = 2, + TYMED_ISTREAM = 4, + TYMED_ISTORAGE = 8, + TYMED_GDI = 16, + TYMED_MFPICT = 32, + TYMED_ENHMF = 64, + TYMED_NULL = 0 + } + + private static readonly Guid IID_IUnknown = new Guid("00000000-0000-0000-C000-000000000046"); + private static readonly Guid IID_IDataObject = new Guid("0000010e-0000-0000-C000-000000000046"); + private static readonly Guid IID_IDropSource = new Guid("00000121-0000-0000-C000-000000000046"); + private static readonly Guid IID_IDropTarget = new Guid("00000122-0000-0000-C000-000000000046"); + + static Win32DnD() + { + // Required for all other OLE functions to work + Win32OleInitialize(IntPtr.Zero); + + // We reuse those + DragDropEventArgs = new DragEventArgs(new DataObject(DataFormats.FileDrop, new string[0]), 0, 0, 0, DragDropEffects.None, DragDropEffects.None); + DragFeedbackEventArgs = new GiveFeedbackEventArgs(DragDropEffects.None, true); + DragContinueEventArgs = new QueryContinueDragEventArgs(0, false, DragAction.Continue); + DragFormats = new ArrayList(); + DragFormatArray = new FORMATETC[0]; + DragMediums = new ArrayList(); + + // Set up delegates + // IDataObject + DOQueryInterface = new QueryInterfaceDelegate(ComIDataObject.QueryInterface); + DOAddRef = new AddRefDelegate(ComIDataObject.AddRef); + DORelease = new ReleaseDelegate(ComIDataObject.Release); + GetData = new GetDataDelegate(ComIDataObject.GetData); + GetDataHere = new GetDataHereDelegate(ComIDataObject.GetDataHere); + QueryGetData = new QueryGetDataDelegate(ComIDataObject.QueryGetData); + GetCanonicalFormatEtc = new GetCanonicalFormatEtcDelegate(ComIDataObject.GetCanonicalFormatEtc); + SetData = new SetDataDelegate(ComIDataObject.SetData); + EnumFormatEtc = new EnumFormatEtcDelegate(ComIDataObject.EnumFormatEtc); + DAdvise = new DAdviseDelegate(ComIDataObject.DAdvise); + DUnadvise = new DUnadviseDelegate(ComIDataObject.DUnadvise); + EnumDAdvise = new EnumDAdviseDelegate(ComIDataObject.EnumDAdvise); + + // IDropSource + DSQueryInterface = new QueryInterfaceDelegate(ComIDropSource.QueryInterface); + DSAddRef = new AddRefDelegate(ComIDropSource.AddRef); + DSRelease = new ReleaseDelegate(ComIDropSource.Release); + QueryContinueDrag = new QueryContinueDragDelegate(ComIDropSource.QueryContinueDrag); + GiveFeedback = new GiveFeedbackDelegate(ComIDropSource.GiveFeedback); + + // IDropTarget + DTQueryInterface = new QueryInterfaceDelegate(ComIDropTarget.QueryInterface); + DTAddRef = new AddRefDelegate(ComIDropTarget.AddRef); + DTRelease = new ReleaseDelegate(ComIDropTarget.Release); + DragEnter = new DragEnterDelegate(ComIDropTarget.DragEnter); + DragOver = new DragOverDelegate(ComIDropTarget.DragOver); + DragLeave = new DragLeaveDelegate(ComIDropTarget.DragLeave); + Drop = new DropDelegate(ComIDropTarget.Drop); + } + + internal class ComIDataObject { + [StructLayout(LayoutKind.Sequential)] + internal struct DataObjectStruct { + internal IntPtr vtbl; + internal QueryInterfaceDelegate QueryInterface; + internal AddRefDelegate AddRef; + internal ReleaseDelegate Release; + internal GetDataDelegate GetData; + internal GetDataHereDelegate GetDataHere; + internal QueryGetDataDelegate QueryGetData; + internal GetCanonicalFormatEtcDelegate GetCanonicalFormatEtc; + internal SetDataDelegate SetData; + internal EnumFormatEtcDelegate EnumFormatEtc; + internal DAdviseDelegate DAdvise; + internal DUnadviseDelegate DUnadvise; + internal EnumDAdviseDelegate EnumDAdvise; + } + + internal static IntPtr GetUnmanaged() { + DataObjectStruct data_object; + IntPtr data_object_ptr; + long offset; + + data_object = new DataObjectStruct(); + + data_object.QueryInterface = Win32DnD.DOQueryInterface; + data_object.AddRef = Win32DnD.DOAddRef; + data_object.Release = Win32DnD.DORelease; + data_object.GetData = Win32DnD.GetData; + data_object.GetDataHere = Win32DnD.GetDataHere; + data_object.QueryGetData = Win32DnD.QueryGetData; + data_object.GetCanonicalFormatEtc = Win32DnD.GetCanonicalFormatEtc; + data_object.SetData = Win32DnD.SetData; + data_object.EnumFormatEtc = Win32DnD.EnumFormatEtc; + data_object.DAdvise = Win32DnD.DAdvise; + data_object.DUnadvise = Win32DnD.DUnadvise; + data_object.EnumDAdvise = Win32DnD.EnumDAdvise; + + data_object_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(DataObjectStruct))); + Marshal.StructureToPtr(data_object, data_object_ptr, false); + + // Update vtbl pointer + offset = data_object_ptr.ToInt64(); + offset += Marshal.SizeOf(typeof(IntPtr)); + Marshal.WriteIntPtr(data_object_ptr, new IntPtr(offset)); + + return data_object_ptr; + } + + internal static void ReleaseUnmanaged(IntPtr data_object_ptr) { + Marshal.FreeHGlobal(data_object_ptr); + } + + internal static uint QueryInterface(IntPtr @this, ref Guid riid, IntPtr ppvObject) { + try { + if (IID_IUnknown.Equals(riid) || IID_IDataObject.Equals(riid)) { + Marshal.WriteIntPtr(ppvObject, @this); + return S_OK; + } + } + + catch (Exception e) { + Console.WriteLine("Got exception {0}", e.Message); + } + + Marshal.WriteIntPtr(ppvObject, IntPtr.Zero); + return E_NOINTERFACE; + } + + internal static uint AddRef(IntPtr @this) { + // We only use this for DnD, try and fake it + return 1; + } + + internal static uint Release(IntPtr @this) { + // We only use this for DnD, try and fake it + return 0; + } + + internal static STGMEDIUM medium = new STGMEDIUM(); + internal static uint GetData(IntPtr this_, ref FORMATETC pformatetcIn, IntPtr pmedium) { + int index; + + index = FindFormat(pformatetcIn); + if (index != -1) { + medium.tymed = TYMED.TYMED_HGLOBAL; + medium.hHandle = XplatUIWin32.DupGlobalMem(((STGMEDIUM)DragMediums[index]).hHandle); + medium.pUnkForRelease = IntPtr.Zero; + try { + Marshal.StructureToPtr(medium, pmedium, false); + } + catch (Exception e) { + Console.WriteLine("Error: {0}", e.Message); + } + return S_OK; + } + + return DV_E_FORMATETC; + } + + internal static uint GetDataHere(IntPtr @this, ref FORMATETC pformatetc, ref STGMEDIUM pmedium) { + return DV_E_FORMATETC; + } + + internal static uint QueryGetData(IntPtr @this, ref FORMATETC pformatetc) { + if (FindFormat(pformatetc) != -1) { + return S_OK; + } + return DV_E_FORMATETC; + } + + internal static uint GetCanonicalFormatEtc(IntPtr @this, ref FORMATETC pformatetcIn, IntPtr pformatetcOut) { + Marshal.WriteIntPtr(pformatetcOut, Marshal.SizeOf(typeof(IntPtr)), IntPtr.Zero); + return E_NOTIMPL; + } + + internal static uint SetData(IntPtr this_, ref FORMATETC pformatetc, ref STGMEDIUM pmedium, bool release) { + return E_NOTIMPL; + } + + internal static uint EnumFormatEtc(IntPtr this_, uint direction, IntPtr ppenumFormatEtc) { + if (direction == DATADIR_GET) { + IntPtr ppenum_ptr; + + ppenum_ptr = IntPtr.Zero; + DragFormatArray = new FORMATETC[DragFormats.Count]; + + for (int i = 0; i < DragFormats.Count; i++) { + DragFormatArray[i] = (FORMATETC)DragFormats[i]; + } + Win32SHCreateStdEnumFmtEtc((uint)DragFormatArray.Length, DragFormatArray, ref ppenum_ptr); + Marshal.WriteIntPtr(ppenumFormatEtc, ppenum_ptr); + return S_OK; + } + return E_NOTIMPL; + } + + internal static uint DAdvise(IntPtr this_, ref FORMATETC pformatetc, uint advf, IntPtr pAdvSink, ref uint pdwConnection) { + return OLE_E_ADVISENOTSUPPORTED; + } + + internal static uint DUnadvise(IntPtr this_, uint pdwConnection) { + return OLE_E_ADVISENOTSUPPORTED; + } + + internal static uint EnumDAdvise(IntPtr this_, IntPtr ppenumAdvise) { + return OLE_E_ADVISENOTSUPPORTED; + } + } + + internal class ComIDataObjectUnmanaged { + [StructLayout(LayoutKind.Sequential)] + internal struct IDataObjectUnmanaged { + internal IntPtr QueryInterface; + internal IntPtr AddRef; + internal IntPtr Release; + internal IntPtr GetData; + internal IntPtr GetDataHere; + internal IntPtr QueryGetData; + internal IntPtr GetCanonicalFormatEtc; + internal IntPtr SetData; + internal IntPtr EnumFormatEtc; + internal IntPtr DAdvise; + internal IntPtr DUnadvise; + internal IntPtr EnumDAdvise; + } + + private static bool Initialized; + private static MethodInfo GetDataMethod; + //private static MethodInfo GetDataHereMethod; + private static MethodInfo QueryGetDataMethod; + //private static MethodInfo GetCanonicalFormatEtcMethod; + //private static MethodInfo SetDataMethod; + //private static MethodInfo EnumFormatEtcMethod; + //private static MethodInfo DAdviseMethod; + //private static MethodInfo DUnadviseMethod; + //private static MethodInfo EnumDAdviseMethod; + private static object[] MethodArguments; + + private IDataObjectUnmanaged vtbl; + private IntPtr @this; + + internal ComIDataObjectUnmanaged(IntPtr data_object_ptr) { + if (!Initialized) { + Initialize(); + } + + vtbl = new IDataObjectUnmanaged(); + @this = data_object_ptr; + try { + vtbl = (IDataObjectUnmanaged)Marshal.PtrToStructure(Marshal.ReadIntPtr(data_object_ptr), typeof(IDataObjectUnmanaged)); + } + + catch (Exception e) { + Console.WriteLine("Exception {0}", e.Message); + } + } + + private static void Initialize() { + AssemblyName assembly; + AssemblyBuilder assembly_builder; + + if (Initialized) { + return; + } + + assembly = new AssemblyName(); + assembly.Name = "XplatUIWin32.FuncPtrInterface"; + assembly_builder = AppDomain.CurrentDomain.DefineDynamicAssembly(assembly, AssemblyBuilderAccess.Run); + + MethodArguments = new object[6]; + GetDataMethod = CreateFuncPtrInterface(assembly_builder, "GetData", typeof(uint), 3); + //GetDataHereMethod = CreateFuncPtrInterface(assembly_builder, "GetDataHere", typeof(uint), 3); + QueryGetDataMethod = CreateFuncPtrInterface(assembly_builder, "QueryGetData", typeof(uint), 2); + //GetCanonicalFormatEtcMethod = CreateFuncPtrInterface(assembly_builder, "GetCanonicalFormatEtc", typeof(uint), 3); + //SetDataMethod = CreateFuncPtrInterface(assembly_builder, "SetData", typeof(uint), 4); + //EnumFormatEtcMethod = CreateFuncPtrInterface(assembly_builder, "EnumFormatEtc", typeof(uint), 3); + //DAdviseMethod = CreateFuncPtrInterface(assembly_builder, "DAdvise", typeof(uint), 5); + //DUnadviseMethod = CreateFuncPtrInterface(assembly_builder, "DUnadvise", typeof(uint), 2); + //EnumDAdviseMethod = CreateFuncPtrInterface(assembly_builder, "EnumDAdvise", typeof(uint), 2); + + Initialized = true; + } + + internal uint QueryInterface(Guid riid, IntPtr ppvObject) { + uint ret; + IntPtr riid_ptr; + + riid_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Guid))); + Marshal.StructureToPtr(riid, riid_ptr, false); + + MethodArguments[0] = vtbl.QueryInterface; + MethodArguments[1] = this.@this; + MethodArguments[2] = riid_ptr; + MethodArguments[3] = ppvObject; + + try { + ret = (uint)GetDataMethod.Invoke(null, MethodArguments); + } + + catch (Exception e) { + Console.WriteLine("Caught exception {0}", e.Message); + ret = E_FAIL; + } + + Marshal.FreeHGlobal(riid_ptr); + + return ret; + } + + internal uint AddRef() { + // We only use this for DnD, try and fake it + return 1; + } + + internal uint Release() { + // We only use this for DnD, try and fake it + return 0; + } + + internal uint GetData(FORMATETC pformatetcIn, ref STGMEDIUM pmedium) { + uint ret; + IntPtr pformatetcIn_ptr; + IntPtr pmedium_ptr; + + pformatetcIn_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(FORMATETC))); + Marshal.StructureToPtr(pformatetcIn, pformatetcIn_ptr, false); + + pmedium_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(STGMEDIUM))); + + MethodArguments[0] = vtbl.GetData; + MethodArguments[1] = this.@this; + MethodArguments[2] = pformatetcIn_ptr; + MethodArguments[3] = pmedium_ptr; + + try { + ret = (uint)GetDataMethod.Invoke(null, MethodArguments); + Marshal.PtrToStructure(pmedium_ptr, pmedium); + } + + catch (Exception e) { + Console.WriteLine("Caught exception {0}", e.Message); + ret = E_FAIL; + } + + Marshal.FreeHGlobal(pformatetcIn_ptr); + Marshal.FreeHGlobal(pmedium_ptr); + + return ret; + } + + internal uint GetDataHere(FORMATETC pformatetc, ref STGMEDIUM pmedium) { + return E_NOTIMPL; + } + + internal uint QueryGetData(FORMATETC pformatetc) { + uint ret; + IntPtr pformatetc_ptr; + + pformatetc_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(FORMATETC))); + Marshal.StructureToPtr(pformatetc, pformatetc_ptr, false); + + MethodArguments[0] = vtbl.GetData; + MethodArguments[1] = this.@this; + MethodArguments[2] = pformatetc_ptr; + + try { + ret = (uint)QueryGetDataMethod.Invoke(null, MethodArguments); + } + + catch (Exception e) { + Console.WriteLine("Caught exception {0}", e.Message); + ret = E_FAIL; + } + + Marshal.FreeHGlobal(pformatetc_ptr); + + return ret; + } + + internal uint GetCanonicalFormatEtc(FORMATETC pformatetcIn, ref FORMATETC pformatetcOut) { + return E_NOTIMPL; + } + + internal uint SetData(FORMATETC pformatetc, STGMEDIUM pmedium, bool release) { + return E_NOTIMPL; + } + + internal uint EnumFormatEtc(uint direction, IntPtr ppenumFormatEtc) { + return E_NOTIMPL; + } + + internal uint DAdvise(FORMATETC pformatetc, uint advf, IntPtr pAdvSink, ref uint pdwConnection) { + return OLE_E_ADVISENOTSUPPORTED; + } + + internal uint DUnadvise(uint pdwConnection) { + return OLE_E_ADVISENOTSUPPORTED; + } + + internal uint EnumDAdvise(IntPtr ppenumAdvise) { + return OLE_E_ADVISENOTSUPPORTED; + } + } + + + internal class ComIDropSource { + [StructLayout(LayoutKind.Sequential)] + internal struct IDropSource { + internal IntPtr vtbl; + internal IntPtr Window; + internal QueryInterfaceDelegate QueryInterface; + internal AddRefDelegate AddRef; + internal ReleaseDelegate Release; + internal QueryContinueDragDelegate QueryContinueDrag; + internal GiveFeedbackDelegate GiveFeedback; + } + + internal static IntPtr GetUnmanaged(IntPtr Window) { + IDropSource drop_source; + IntPtr drop_source_ptr; + long offset; + + drop_source = new IDropSource(); + drop_source.QueryInterface = Win32DnD.DSQueryInterface; + drop_source.AddRef = Win32DnD.DSAddRef; + drop_source.Release = Win32DnD.DSRelease; + drop_source.QueryContinueDrag = Win32DnD.QueryContinueDrag; + drop_source.GiveFeedback = Win32DnD.GiveFeedback; + drop_source.Window = Window; + + drop_source_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(drop_source)); + Marshal.StructureToPtr(drop_source, drop_source_ptr, false); + + // Update vtbl pointer + offset = drop_source_ptr.ToInt64(); + offset += 2 * Marshal.SizeOf(typeof(IntPtr)); + Marshal.WriteIntPtr(drop_source_ptr, new IntPtr(offset)); + + return drop_source_ptr; + } + + internal static void ReleaseUnmanaged(IntPtr drop_source_ptr) { + Marshal.FreeHGlobal(drop_source_ptr); + } + + internal static uint QueryInterface(IntPtr @this, ref Guid riid, IntPtr ppvObject) { + try { + if (IID_IUnknown.Equals(riid) || IID_IDropSource.Equals(riid)) { + Marshal.WriteIntPtr(ppvObject, @this); + return S_OK; + } + } + + catch (Exception e) { + Console.WriteLine("Got exception {0}", e.Message); + } + + Marshal.WriteIntPtr(ppvObject, IntPtr.Zero); + return E_NOINTERFACE; + } + + internal static uint AddRef(IntPtr @this) { + // We only use this for DnD, try and fake it + return 1; + } + + internal static uint Release(IntPtr @this) { + // We only use this for DnD, try and fake it + return 0; + } + + internal static uint QueryContinueDrag(IntPtr @this, bool fEscapePressed, uint grfkeyState) { + IntPtr window; + + window = Marshal.ReadIntPtr(@this, Marshal.SizeOf(typeof(IntPtr))); + + // LAMESPEC? - according to MSDN, when the any mousebutton is *pressed* it defaults to Drop. + // According to COM customary behaviour it's the other way round; which is what we do here + if (fEscapePressed) { + DragContinueEventArgs.drag_action = DragAction.Cancel; + } else if ((grfkeyState & (1+2+16)) == 0) { // Left, middle and right mouse button not pressed + DragContinueEventArgs.drag_action = DragAction.Drop; + } else { + DragContinueEventArgs.drag_action = DragAction.Continue; + } + + DragContinueEventArgs.escape_pressed = fEscapePressed; + DragContinueEventArgs.key_state = (int)grfkeyState; + + Widget.FromHandle(window).DndContinueDrag(DragContinueEventArgs); + + if (DragContinueEventArgs.drag_action == DragAction.Cancel) { + return DRAGDROP_S_CANCEL; + } else if (DragContinueEventArgs.drag_action == DragAction.Drop) { + return DRAGDROP_S_DROP; + } + return S_OK; + } + + internal static uint GiveFeedback(IntPtr @this, uint pdwEffect) { + IntPtr window; + + window = Marshal.ReadIntPtr(@this, Marshal.SizeOf(typeof(IntPtr))); + + DragFeedbackEventArgs.effect = (DragDropEffects)pdwEffect; + DragFeedbackEventArgs.use_default_cursors = true; + + Widget.FromHandle(window).DndFeedback(DragFeedbackEventArgs); + + if (DragFeedbackEventArgs.use_default_cursors) { + return DRAGDROP_S_USEDEFAULTCURSORS; + } + return S_OK; + } + } + + internal class ComIDropTarget { + [StructLayout(LayoutKind.Sequential)] + internal struct IDropTarget { + internal IntPtr vtbl; + internal IntPtr Window; + internal QueryInterfaceDelegate QueryInterface; + internal AddRefDelegate AddRef; + internal ReleaseDelegate Release; + + internal DragEnterDelegate DragEnter; + internal DragOverDelegate DragOver; + internal DragLeaveDelegate DragLeave; + internal DropDelegate Drop; + } + + internal static IntPtr GetUnmanaged(IntPtr Window) { + IDropTarget drop_target; + IntPtr drop_target_ptr; + long offset; + + drop_target = new IDropTarget(); + drop_target.QueryInterface = Win32DnD.DTQueryInterface; + drop_target.AddRef = Win32DnD.DTAddRef; + drop_target.Release = Win32DnD.DTRelease; + drop_target.DragEnter = Win32DnD.DragEnter; + drop_target.DragOver = Win32DnD.DragOver; + drop_target.DragLeave = Win32DnD.DragLeave; + drop_target.Drop = Win32DnD.Drop; + drop_target.Window = Window; + + drop_target_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(drop_target)); + Marshal.StructureToPtr(drop_target, drop_target_ptr, false); + + // Update vtbl pointer + offset = drop_target_ptr.ToInt64(); + offset += 2 * Marshal.SizeOf(typeof(IntPtr)); + Marshal.WriteIntPtr(drop_target_ptr, new IntPtr(offset)); + + return drop_target_ptr; + } + + internal static void ReleaseUnmanaged(IntPtr drop_target_ptr) { + Marshal.FreeHGlobal(drop_target_ptr); + } + + internal static uint QueryInterface(IntPtr @this, ref Guid riid, IntPtr ppvObject) { + try { + if (IID_IUnknown.Equals(riid) || IID_IDropTarget.Equals(riid)) { + Marshal.WriteIntPtr(ppvObject, @this); + return S_OK; + } + } + + catch (Exception e) { + Console.WriteLine("Got exception {0}", e.Message); + } + + Marshal.WriteIntPtr(ppvObject, IntPtr.Zero); + return E_NOINTERFACE; + } + + internal static uint AddRef(IntPtr @this) { + // We only use this for DnD, try and fake it + return 1; + } + + internal static uint Release(IntPtr @this) { + // We only use this for DnD, try and fake it + return 0; + } + + internal static uint DragEnter(IntPtr @this, IntPtr pDataObj, uint grfkeyState, IntPtr pt_x, IntPtr pt_y, IntPtr pdwEffect) { + IntPtr window; + + window = Marshal.ReadIntPtr(@this, Marshal.SizeOf(typeof(IntPtr))); + + DragDropEventArgs.x = pt_x.ToInt32(); + DragDropEventArgs.y = pt_y.ToInt32(); + DragDropEventArgs.allowed_effect = (DragDropEffects)Marshal.ReadIntPtr(pdwEffect).ToInt32(); + DragDropEventArgs.current_effect = DragDropEventArgs.AllowedEffect; + DragDropEventArgs.keystate = (int)grfkeyState; + + Widget.FromHandle(window).DndEnter(DragDropEventArgs); + + Marshal.WriteInt32(pdwEffect, (int)DragDropEventArgs.Effect); + + return S_OK; + } + + internal static uint DragOver(IntPtr @this, uint grfkeyState, IntPtr pt_x, IntPtr pt_y, IntPtr pdwEffect) { + IntPtr window; + + window = Marshal.ReadIntPtr(@this, Marshal.SizeOf(typeof(IntPtr))); + + DragDropEventArgs.x = pt_x.ToInt32(); + DragDropEventArgs.y = pt_y.ToInt32(); + DragDropEventArgs.allowed_effect = (DragDropEffects)Marshal.ReadIntPtr(pdwEffect).ToInt32(); + DragDropEventArgs.current_effect = DragDropEventArgs.AllowedEffect; + DragDropEventArgs.keystate = (int)grfkeyState; + + Widget.FromHandle(window).DndOver(DragDropEventArgs); + + Marshal.WriteInt32(pdwEffect, (int)DragDropEventArgs.Effect); + + return S_OK; + } + + internal static uint DragLeave(IntPtr @this) { + IntPtr window; + + window = Marshal.ReadIntPtr(@this, Marshal.SizeOf(typeof(IntPtr))); + + Widget.FromHandle(window).DndLeave(EventArgs.Empty); + + return S_OK; + } + + internal static uint Drop(IntPtr @this, IntPtr pDataObj, uint grfkeyState, IntPtr pt_x, IntPtr pt_y, IntPtr pdwEffect) + { + IntPtr window; + + window = Marshal.ReadIntPtr (@this, Marshal.SizeOf (typeof (IntPtr))); + + DragDropEventArgs.x = pt_x.ToInt32 (); + DragDropEventArgs.y = pt_y.ToInt32 (); + DragDropEventArgs.allowed_effect = (DragDropEffects) Marshal.ReadIntPtr (pdwEffect).ToInt32(); + DragDropEventArgs.current_effect = DragDropEventArgs.AllowedEffect; + DragDropEventArgs.keystate = (int) grfkeyState; + + Widget control = Widget.FromHandle (window); + if (control != null) { + control.DndDrop (DragDropEventArgs); + return S_FALSE; + } + + Marshal.WriteInt32 (pdwEffect, (int) DragDropEventArgs.Effect); + + return S_OK; + } + } + + internal static bool HandleWMDropFiles(ref MSG msg) { + IntPtr hDrop; + int count; + StringBuilder sb; + string[] dropfiles; + + hDrop = msg.wParam; + count = Win32DragQueryFile(hDrop, -1, IntPtr.Zero, 0); + + dropfiles = new string[count]; + + sb = new StringBuilder(256); + for (int i = 0; i < count; i++) { + Win32DragQueryFile(hDrop, i, sb, sb.Capacity); + dropfiles[i] = sb.ToString(); + } + + DragDropEventArgs.Data.SetData(DataFormats.FileDrop, dropfiles); + + Widget.FromHandle(msg.hwnd).DndDrop(DragDropEventArgs); + + return true; + } + + private static bool AddFormatAndMedium(ClipboardFormats cfFormat, object data) { + STGMEDIUM medium; + FORMATETC format; + IntPtr hmem; + IntPtr hmem_ptr; + byte[] b; + + switch(cfFormat) { + case ClipboardFormats.CF_TEXT: { + b = XplatUIWin32.StringToAnsi ((string)data); + hmem = XplatUIWin32.CopyToMoveableMemory (b); + break; + } + + case ClipboardFormats.CF_UNICODETEXT: { + b = XplatUIWin32.StringToUnicode ((string)data); + hmem = XplatUIWin32.CopyToMoveableMemory (b); + break; + } + + case ClipboardFormats.CF_HDROP: { + IEnumerator e; + StringBuilder sb; + long hmem_string_ptr; + IntPtr string_buffer; + int string_buffer_size; + + sb = new StringBuilder(); + + // Make sure object is enumerable; otherwise + if ((data is string) || !(data is IEnumerable)) { + sb.Append(data.ToString()); + sb.Append('\0'); + sb.Append('\0'); + } else { + e = ((IEnumerable)data).GetEnumerator(); + while (e.MoveNext()) { + sb.Append(e.Current.ToString()); + sb.Append('\0'); + } + sb.Append('\0'); + } + + string_buffer = Marshal.StringToHGlobalUni(sb.ToString()); + string_buffer_size = (int)XplatUIWin32.Win32GlobalSize(string_buffer); + + // Write DROPFILES structure + hmem = XplatUIWin32.Win32GlobalAlloc(XplatUIWin32.GAllocFlags.GMEM_MOVEABLE | XplatUIWin32.GAllocFlags.GMEM_DDESHARE, 0x14 + string_buffer_size); + hmem_ptr = XplatUIWin32.Win32GlobalLock(hmem); + Marshal.WriteInt32(hmem_ptr, 0x14); // pFiles + Marshal.WriteInt32(hmem_ptr, 1 * Marshal.SizeOf(typeof(uint)), 0); // point.x + Marshal.WriteInt32(hmem_ptr, 2 * Marshal.SizeOf(typeof(uint)), 0); // point.y + Marshal.WriteInt32(hmem_ptr, 3 * Marshal.SizeOf(typeof(uint)), 0); // fNc + Marshal.WriteInt32(hmem_ptr, 4 * Marshal.SizeOf(typeof(uint)), 1); // fWide + + hmem_string_ptr = (long)hmem_ptr; + hmem_string_ptr += 0x14; + + XplatUIWin32.Win32CopyMemory(new IntPtr(hmem_string_ptr), string_buffer, string_buffer_size); + Marshal.FreeHGlobal(string_buffer); + XplatUIWin32.Win32GlobalUnlock(hmem_ptr); + + break; + } + + case ClipboardFormats.CF_DIB: { + b = XplatUIWin32.ImageToDIB((Image)data); + hmem = XplatUIWin32.CopyToMoveableMemory (b); + break; + } + + default: { + hmem = IntPtr.Zero; + break; + } + } + + if (hmem != IntPtr.Zero) { + medium = new STGMEDIUM(); + medium.tymed = TYMED.TYMED_HGLOBAL; + medium.hHandle = hmem; + medium.pUnkForRelease = IntPtr.Zero; + DragMediums.Add(medium); + + format = new FORMATETC(); + format.ptd = IntPtr.Zero; + format.dwAspect = DVASPECT.DVASPECT_CONTENT; + format.lindex = -1; + format.tymed = TYMED.TYMED_HGLOBAL; + format.cfFormat = cfFormat; + DragFormats.Add(format); + + return true; + } + + return false; + } + + private static int FindFormat(FORMATETC pformatetc) { + for (int i = 0; i < DragFormats.Count; i++) { + if ((((FORMATETC)DragFormats[i]).cfFormat == pformatetc.cfFormat) && + (((FORMATETC)DragFormats[i]).dwAspect == pformatetc.dwAspect) && + ((((FORMATETC)DragFormats[i]).tymed & pformatetc.tymed)) != 0) { + return i; + } + } + return -1; + } + + private static void BuildFormats(object data) { + + DragFormats.Clear(); + DragMediums.Clear(); + + // Build our formats based on object data + if (data is String) { + AddFormatAndMedium(ClipboardFormats.CF_TEXT, data); + AddFormatAndMedium(ClipboardFormats.CF_UNICODETEXT, data); + AddFormatAndMedium(ClipboardFormats.CF_HDROP, data); + } else if (data is Bitmap) { + AddFormatAndMedium(ClipboardFormats.CF_DIB, data); + } else if (data is ICollection) { + // FIXME - test with .Net and found how this is handled + AddFormatAndMedium(ClipboardFormats.CF_HDROP, data); + } else if (data is ISerializable) { + // FIXME - test with .Net and found how this is handled + } + } + + internal static DragDropEffects StartDrag(IntPtr Window, object data, DragDropEffects allowed) { + IntPtr result; + IntPtr data_object; + IntPtr drop_source; + + BuildFormats(data); + + data_object = ComIDataObject.GetUnmanaged(); + drop_source = ComIDropSource.GetUnmanaged(Window); + + result = (IntPtr)DragDropEffects.None; + + Win32DoDragDrop(data_object, drop_source, (IntPtr)allowed, ref result); + + // Cleanup again + ComIDataObject.ReleaseUnmanaged(data_object); + ComIDropSource.ReleaseUnmanaged(drop_source); + DragFormats.Clear(); + DragFormatArray = null; + DragMediums.Clear(); + + return (DragDropEffects)result.ToInt32(); + } + + internal static bool UnregisterDropTarget(IntPtr Window) { + Win32RevokeDragDrop(Window); + return true; + } + + internal static bool RegisterDropTarget(IntPtr Window) { + Hwnd hwnd; + IntPtr drop_target; + uint result; + + hwnd = Hwnd.ObjectFromWindow(Window); + if (hwnd == null) { + return false; + } + + drop_target = ComIDropTarget.GetUnmanaged(Window); + hwnd.marshal_free_list.Add(drop_target); + result = Win32RegisterDragDrop(Window, drop_target); + + if (result != S_OK) { + return false; + } + return true; + } + + // Thanks, Martin + static MethodInfo CreateFuncPtrInterface(AssemblyBuilder assembly, string MethodName, Type ret_type, int param_count) { + ModuleBuilder mb; + TypeBuilder tb; + Type[] il_param_types; + Type[] param_types; + + mb = assembly.DefineDynamicModule("XplatUIWin32.FuncInterface" + MethodName); + tb = mb.DefineType ("XplatUIWin32.FuncInterface" + MethodName, TypeAttributes.Public); + + param_types = new Type[param_count]; + il_param_types = new Type[param_count + 1]; + + il_param_types[param_count] = typeof(IntPtr); + for (int i = 0; i < param_count; i++) { + param_types[i] = typeof(IntPtr); + il_param_types[i] = typeof(IntPtr); + } + + MethodBuilder method = tb.DefineMethod ( + MethodName, MethodAttributes.Static | MethodAttributes.Public, + ret_type, il_param_types); + + ILGenerator ig = method.GetILGenerator (); + if (param_count > 5) ig.Emit (OpCodes.Ldarg_S, 6); + if (param_count > 4) ig.Emit (OpCodes.Ldarg_S, 5); + if (param_count > 3) ig.Emit (OpCodes.Ldarg_S, 4); + if (param_count > 2) ig.Emit (OpCodes.Ldarg_3); + if (param_count > 1) ig.Emit (OpCodes.Ldarg_2); + if (param_count > 0) ig.Emit (OpCodes.Ldarg_1); + ig.Emit (OpCodes.Ldarg_0); + ig.EmitCalli (OpCodes.Calli, CallingConvention.StdCall, ret_type, param_types); + ig.Emit (OpCodes.Ret); + + Type t = tb.CreateType (); + MethodInfo m = t.GetMethod (MethodName); + + return m; + } + + [DllImport ("ole32.dll", EntryPoint="RegisterDragDrop", CallingConvention=CallingConvention.StdCall)] + private extern static uint Win32RegisterDragDrop(IntPtr Window, IntPtr pDropTarget); + + [DllImport ("ole32.dll", EntryPoint="RevokeDragDrop", CallingConvention=CallingConvention.StdCall)] + private extern static int Win32RevokeDragDrop(IntPtr Window); + + [DllImport ("ole32.dll", EntryPoint="DoDragDrop", CallingConvention=CallingConvention.StdCall)] + private extern static uint Win32DoDragDrop(IntPtr pDataObject, IntPtr pDropSource, IntPtr dwOKEffect, ref IntPtr pdwEffect); + + //[DllImport ("shell32.dll", EntryPoint="DragAcceptFiles", CallingConvention=CallingConvention.StdCall)] + //private extern static int Win32DragAcceptFiles(IntPtr Window, bool fAccept); + + [DllImport ("ole32.dll", EntryPoint="OleInitialize", CallingConvention=CallingConvention.StdCall)] + private extern static int Win32OleInitialize(IntPtr pvReserved); + + [DllImport ("shell32.dll", EntryPoint="DragQueryFileW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + private extern static int Win32DragQueryFile(IntPtr hDrop, int iFile, IntPtr lpszFile, int cch); + + [DllImport ("shell32.dll", EntryPoint="DragQueryFileW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + private extern static int Win32DragQueryFile(IntPtr hDrop, int iFile, StringBuilder lpszFile, int cch); + + [DllImport ("shell32.dll", EntryPoint="SHCreateStdEnumFmtEtc", CallingConvention=CallingConvention.StdCall)] + private extern static uint Win32SHCreateStdEnumFmtEtc(uint cfmt, FORMATETC[] afmt, ref IntPtr ppenumFormatEtc); + } +} diff --git a/source/ShiftUI/Internal/WindowHandler.cs b/source/ShiftUI/Internal/WindowHandler.cs new file mode 100644 index 0000000..cb59ca4 --- /dev/null +++ b/source/ShiftUI/Internal/WindowHandler.cs @@ -0,0 +1,235 @@ +// 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) 2007 Novell, Inc. +// +// Authors: +// Geoff Norton <[email protected]> +// +// + +using System; +using System.Drawing; +using ShiftUI; +using System.Runtime.InteropServices; + +namespace ShiftUI.CarbonInternal { + internal class WindowHandler : EventHandlerBase, IEventHandler { + internal const uint kEventWindowUpdate = 1; + internal const uint kEventWindowDrawContent = 2; + internal const uint kEventWindowActivated = 5; + internal const uint kEventWindowDeactivated = 6; + internal const uint kEventWindowGetClickActivation = 7; + internal const uint kEventWindowShowing = 22; + internal const uint kEventWindowHiding = 23; + internal const uint kEventWindowShown = 24; + internal const uint kEventWindowHidden = 25; + internal const uint kEventWindowCollapsing = 86; + internal const uint kEventWindowExpanding = 87; + internal const uint kEventWindowZoomed = 76; + internal const uint kEventWindowBoundsChanging = 26; + internal const uint kEventWindowBoundsChanged = 27; + internal const uint kEventWindowResizeStarted = 28; + internal const uint kEventWindowResizeCompleted = 29; + internal const uint kEventWindowDragStarted = 30; + internal const uint kEventWindowDragCompleted = 31; + internal const uint kEventWindowTransitionStarted = 88; + internal const uint kEventWindowTransitionCompleted = 89; + internal const uint kEventWindowClickDragRgn = 32; + internal const uint kEventWindowClickResizeRgn = 33; + internal const uint kEventWindowClickCollapseRgn = 34; + internal const uint kEventWindowClickCloseRgn = 35; + internal const uint kEventWindowClickZoomRgn = 36; + internal const uint kEventWindowClickContentRgn = 37; + internal const uint kEventWindowClickProxyIconRgn = 38; + internal const uint kEventWindowClickToolbarButtonRgn = 41; + internal const uint kEventWindowClickStructureRgn = 42; + internal const uint kEventWindowCursorChange = 40; + internal const uint kEventWindowCollapse = 66; + internal const uint kEventWindowCollapsed = 67; + internal const uint kEventWindowCollapseAll = 68; + internal const uint kEventWindowExpand = 69; + internal const uint kEventWindowExpanded = 70; + internal const uint kEventWindowExpandAll = 71; + internal const uint kEventWindowClose = 72; + internal const uint kEventWindowClosed = 73; + internal const uint kEventWindowCloseAll = 74; + internal const uint kEventWindowZoom = 75; + internal const uint kEventWindowZoomAll = 77; + internal const uint kEventWindowContextualMenuSelect = 78; + internal const uint kEventWindowPathSelect = 79; + internal const uint kEventWindowGetIdealSize = 80; + internal const uint kEventWindowGetMinimumSize = 81; + internal const uint kEventWindowGetMaximumSize = 82; + internal const uint kEventWindowConstrain = 83; + internal const uint kEventWindowHandleContentClick = 85; + internal const uint kEventWindowGetDockTileMenu = 90; + internal const uint kEventWindowHandleActivate = 91; + internal const uint kEventWindowHandleDeactivate = 92; + internal const uint kEventWindowProxyBeginDrag = 128; + internal const uint kEventWindowProxyEndDrag = 129; + internal const uint kEventWindowToolbarSwitchMode = 150; + internal const uint kEventWindowFocusAcquired = 200; + internal const uint kEventWindowFocusRelinquish = 201; + internal const uint kEventWindowFocusContent = 202; + internal const uint kEventWindowFocusToolbar = 203; + internal const uint kEventWindowDrawerOpening = 220; + internal const uint kEventWindowDrawerOpened = 221; + internal const uint kEventWindowDrawerClosing = 222; + internal const uint kEventWindowDrawerClosed = 223; + internal const uint kEventWindowDrawFrame = 1000; + internal const uint kEventWindowDrawPart = 1001; + internal const uint kEventWindowGetRegion = 1002; + internal const uint kEventWindowHitTest = 1003; + internal const uint kEventWindowInit = 1004; + internal const uint kEventWindowDispose = 1005; + internal const uint kEventWindowDragHilite = 1006; + internal const uint kEventWindowModified = 1007; + internal const uint kEventWindowSetupProxyDragImage = 1008; + internal const uint kEventWindowStateChanged = 1009; + internal const uint kEventWindowMeasureTitle = 1010; + internal const uint kEventWindowDrawGrowBox = 1011; + internal const uint kEventWindowGetGrowImageRegion = 1012; + internal const uint kEventWindowPaint = 1013; + + internal WindowHandler (XplatUICarbon driver) : base (driver) {} + + public bool ProcessEvent (IntPtr callref, IntPtr eventref, IntPtr handle, uint kind, ref MSG msg) { + IntPtr window = Driver.HandleToWindow (handle); + Hwnd hwnd = Hwnd.ObjectFromHandle (window); + if (window != IntPtr.Zero) { + switch (kind) { + case kEventWindowActivated: { + Widget c = Widget.FromHandle (hwnd.client_window); + if (c != null) { + Form form = c.FindForm (); + if (form != null && !form.IsDisposed) { + Driver.SendMessage (form.Handle, Msg.WM_ACTIVATE, (IntPtr) WindowActiveFlags.WA_ACTIVE, IntPtr.Zero); + XplatUICarbon.ActiveWindow = hwnd.client_window; + } + } + + foreach (IntPtr utility_window in XplatUICarbon.UtilityWindows) { + if (utility_window != handle && !XplatUICarbon.IsWindowVisible (utility_window)) + XplatUICarbon.ShowWindow (utility_window); + } + break; + } + case kEventWindowExpanding: + foreach (IntPtr utility_window in XplatUICarbon.UtilityWindows) { + if (utility_window != handle && !XplatUICarbon.IsWindowVisible (utility_window)) + XplatUICarbon.ShowWindow (utility_window); + } + msg.hwnd = hwnd.Handle; + msg.message = Msg.WM_ENTERSIZEMOVE; + return true; + case kEventWindowExpanded: + NativeWindow.WndProc (hwnd.Handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + msg.hwnd = hwnd.Handle; + msg.message = Msg.WM_EXITSIZEMOVE; + return true; + case kEventWindowDeactivated: { + Widget c = Widget.FromHandle (hwnd.client_window); + if (c != null) { + Form form = c.FindForm (); + if (form != null && XplatUICarbon.UnactiveWindow != form.Handle) { + Driver.SendMessage (form.Handle, Msg.WM_ACTIVATE, (IntPtr) WindowActiveFlags.WA_INACTIVE, IntPtr.Zero); + XplatUICarbon.ActiveWindow = IntPtr.Zero; + } + } + foreach (IntPtr utility_window in XplatUICarbon.UtilityWindows) { + if (utility_window != handle && XplatUICarbon.IsWindowVisible (utility_window)) + XplatUICarbon.HideWindow (utility_window); + } + break; + } + case kEventWindowCollapsing: + foreach (IntPtr utility_window in XplatUICarbon.UtilityWindows) { + if (utility_window != handle && XplatUICarbon.IsWindowVisible (utility_window)) + XplatUICarbon.HideWindow (utility_window); + } + msg.hwnd = hwnd.Handle; + msg.message = Msg.WM_ENTERSIZEMOVE; + return true; + case kEventWindowCollapsed: + NativeWindow.WndProc (hwnd.Handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + msg.hwnd = hwnd.Handle; + msg.message = Msg.WM_EXITSIZEMOVE; + return true; + case kEventWindowClose: + NativeWindow.WndProc (hwnd.Handle, Msg.WM_CLOSE, IntPtr.Zero, IntPtr.Zero); + return false; + case kEventWindowShown: { + msg.message = Msg.WM_SHOWWINDOW; + msg.lParam = (IntPtr) 1; + msg.wParam = (IntPtr) 0; + msg.hwnd = hwnd.Handle; + + return true; + } + case kEventWindowResizeStarted: { + msg.message = Msg.WM_ENTERSIZEMOVE; + msg.hwnd = hwnd.Handle; + return true; + } + case kEventWindowResizeCompleted: { + msg.message = Msg.WM_EXITSIZEMOVE; + msg.hwnd = hwnd.Handle; + + return true; + } + case kEventWindowBoundsChanged: { + Rect window_bounds = new Rect (); + HIRect view_bounds = new HIRect (); + Size size; + + GetWindowBounds (handle, 33, ref window_bounds); + + view_bounds.size.width = window_bounds.right - window_bounds.left; + view_bounds.size.height = window_bounds.bottom - window_bounds.top; + + HIViewSetFrame (hwnd.WholeWindow, ref view_bounds); + + size = XplatUICarbon.TranslateQuartzWindowSizeToWindowSize (Widget.FromHandle (hwnd.Handle).GetCreateParams (), (int)view_bounds.size.width, (int)view_bounds.size.height); + + hwnd.X = (int) window_bounds.left; + hwnd.Y = (int) window_bounds.top; + hwnd.Width = (int) size.Width; + hwnd.Height = (int) size.Height; + + Driver.PerformNCCalc (hwnd); + + msg.hwnd = hwnd.Handle; + msg.message = Msg.WM_WINDOWPOSCHANGED; + Driver.SetCaretPos (XplatUICarbon.Caret.Hwnd, XplatUICarbon.Caret.X, XplatUICarbon.Caret.Y); + + return true; + } + } + } + return false; + } + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int GetWindowBounds (IntPtr handle, uint region, ref Rect bounds); + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int HIViewSetFrame (IntPtr handle, ref HIRect bounds); + } +} diff --git a/source/ShiftUI/Internal/WindowsFormsSynchronizationContext.cs b/source/ShiftUI/Internal/WindowsFormsSynchronizationContext.cs new file mode 100644 index 0000000..ec8ab1c --- /dev/null +++ b/source/ShiftUI/Internal/WindowsFormsSynchronizationContext.cs @@ -0,0 +1,94 @@ +// 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) 2007 Novell, Inc. +// + +using System; +using System.Threading; +using System.ComponentModel; + + +// Some implementation details: +// http://msdn.microsoft.com/msdnmag/issues/06/06/NETMatters/default.aspx +namespace ShiftUI +{ + public sealed class WindowsFormsSynchronizationContext : SynchronizationContext, IDisposable + { + private static bool auto_installed; + private static Widget invoke_control; + private static SynchronizationContext previous_context; + + #region Public Constructor + public WindowsFormsSynchronizationContext () + { + } + + static WindowsFormsSynchronizationContext () + { + try { + invoke_control = new Widget (); + invoke_control.CreateWidget (); + auto_installed = true; + previous_context = SynchronizationContext.Current; + } + catch (Exception ex) { + Console.WriteLine (ex.Message); + } + } + #endregion + + #region Public Properties + //[EditorBrowsable (EditorBrowsableState.Advanced)] + public static bool AutoInstall { + get { return auto_installed; } + set { auto_installed = value; } + } + #endregion + + #region Public Methods + public override SynchronizationContext CreateCopy () + { + return base.CreateCopy (); + } + + public void Dispose () + { + } + + public override void Post (SendOrPostCallback d, object state) + { + invoke_control.BeginInvoke (d, new object[] { state }); + } + + public override void Send (SendOrPostCallback d, object state) + { + invoke_control.Invoke (d, new object[] { state }); + } + + public static void Uninstall () + { + if (previous_context == null) + previous_context = new SynchronizationContext (); + + SynchronizationContext.SetSynchronizationContext (previous_context); + } + #endregion + } +} diff --git a/source/ShiftUI/Internal/X11Atoms.cs b/source/ShiftUI/Internal/X11Atoms.cs new file mode 100644 index 0000000..ec0232c --- /dev/null +++ b/source/ShiftUI/Internal/X11Atoms.cs @@ -0,0 +1,329 @@ +// 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) 2006 Novell, Inc. (http://www.novell.com) +// +// + +using System; +using ShiftUI; + +namespace ShiftUI.X11Internal { + + internal class X11Atoms { + + // Our atoms + public readonly IntPtr AnyPropertyType = (IntPtr)0; + public readonly IntPtr XA_PRIMARY = (IntPtr)1; + public readonly IntPtr XA_SECONDARY = (IntPtr)2; + public readonly IntPtr XA_ARC = (IntPtr)3; + public readonly IntPtr XA_ATOM = (IntPtr)4; + public readonly IntPtr XA_BITMAP = (IntPtr)5; + public readonly IntPtr XA_CARDINAL = (IntPtr)6; + public readonly IntPtr XA_COLORMAP = (IntPtr)7; + public readonly IntPtr XA_CURSOR = (IntPtr)8; + public readonly IntPtr XA_CUT_BUFFER0 = (IntPtr)9; + public readonly IntPtr XA_CUT_BUFFER1 = (IntPtr)10; + public readonly IntPtr XA_CUT_BUFFER2 = (IntPtr)11; + public readonly IntPtr XA_CUT_BUFFER3 = (IntPtr)12; + public readonly IntPtr XA_CUT_BUFFER4 = (IntPtr)13; + public readonly IntPtr XA_CUT_BUFFER5 = (IntPtr)14; + public readonly IntPtr XA_CUT_BUFFER6 = (IntPtr)15; + public readonly IntPtr XA_CUT_BUFFER7 = (IntPtr)16; + public readonly IntPtr XA_DRAWABLE = (IntPtr)17; + public readonly IntPtr XA_FONT = (IntPtr)18; + public readonly IntPtr XA_INTEGER = (IntPtr)19; + public readonly IntPtr XA_PIXMAP = (IntPtr)20; + public readonly IntPtr XA_POINT = (IntPtr)21; + public readonly IntPtr XA_RECTANGLE = (IntPtr)22; + public readonly IntPtr XA_RESOURCE_MANAGER = (IntPtr)23; + public readonly IntPtr XA_RGB_COLOR_MAP = (IntPtr)24; + public readonly IntPtr XA_RGB_BEST_MAP = (IntPtr)25; + public readonly IntPtr XA_RGB_BLUE_MAP = (IntPtr)26; + public readonly IntPtr XA_RGB_DEFAULT_MAP = (IntPtr)27; + public readonly IntPtr XA_RGB_GRAY_MAP = (IntPtr)28; + public readonly IntPtr XA_RGB_GREEN_MAP = (IntPtr)29; + public readonly IntPtr XA_RGB_RED_MAP = (IntPtr)30; + public readonly IntPtr XA_STRING = (IntPtr)31; + public readonly IntPtr XA_VISUALID = (IntPtr)32; + public readonly IntPtr XA_WINDOW = (IntPtr)33; + public readonly IntPtr XA_WM_COMMAND = (IntPtr)34; + public readonly IntPtr XA_WM_HINTS = (IntPtr)35; + public readonly IntPtr XA_WM_CLIENT_MACHINE = (IntPtr)36; + public readonly IntPtr XA_WM_ICON_NAME = (IntPtr)37; + public readonly IntPtr XA_WM_ICON_SIZE = (IntPtr)38; + public readonly IntPtr XA_WM_NAME = (IntPtr)39; + public readonly IntPtr XA_WM_NORMAL_HINTS = (IntPtr)40; + public readonly IntPtr XA_WM_SIZE_HINTS = (IntPtr)41; + public readonly IntPtr XA_WM_ZOOM_HINTS = (IntPtr)42; + public readonly IntPtr XA_MIN_SPACE = (IntPtr)43; + public readonly IntPtr XA_NORM_SPACE = (IntPtr)44; + public readonly IntPtr XA_MAX_SPACE = (IntPtr)45; + public readonly IntPtr XA_END_SPACE = (IntPtr)46; + public readonly IntPtr XA_SUPERSCRIPT_X = (IntPtr)47; + public readonly IntPtr XA_SUPERSCRIPT_Y = (IntPtr)48; + public readonly IntPtr XA_SUBSCRIPT_X = (IntPtr)49; + public readonly IntPtr XA_SUBSCRIPT_Y = (IntPtr)50; + public readonly IntPtr XA_UNDERLINE_POSITION = (IntPtr)51; + public readonly IntPtr XA_UNDERLINE_THICKNESS = (IntPtr)52; + public readonly IntPtr XA_STRIKEOUT_ASCENT = (IntPtr)53; + public readonly IntPtr XA_STRIKEOUT_DESCENT = (IntPtr)54; + public readonly IntPtr XA_ITALIC_ANGLE = (IntPtr)55; + public readonly IntPtr XA_X_HEIGHT = (IntPtr)56; + public readonly IntPtr XA_QUAD_WIDTH = (IntPtr)57; + public readonly IntPtr XA_WEIGHT = (IntPtr)58; + public readonly IntPtr XA_POINT_SIZE = (IntPtr)59; + public readonly IntPtr XA_RESOLUTION = (IntPtr)60; + public readonly IntPtr XA_COPYRIGHT = (IntPtr)61; + public readonly IntPtr XA_NOTICE = (IntPtr)62; + public readonly IntPtr XA_FONT_NAME = (IntPtr)63; + public readonly IntPtr XA_FAMILY_NAME = (IntPtr)64; + public readonly IntPtr XA_FULL_NAME = (IntPtr)65; + public readonly IntPtr XA_CAP_HEIGHT = (IntPtr)66; + public readonly IntPtr XA_WM_CLASS = (IntPtr)67; + public readonly IntPtr XA_WM_TRANSIENT_FOR = (IntPtr)68; + + public readonly IntPtr WM_PROTOCOLS; + public readonly IntPtr WM_DELETE_WINDOW; + public readonly IntPtr WM_TAKE_FOCUS; + public readonly IntPtr _NET_SUPPORTED; + public readonly IntPtr _NET_CLIENT_LIST; + public readonly IntPtr _NET_NUMBER_OF_DESKTOPS; + public readonly IntPtr _NET_DESKTOP_GEOMETRY; + public readonly IntPtr _NET_DESKTOP_VIEWPORT; + public readonly IntPtr _NET_CURRENT_DESKTOP; + public readonly IntPtr _NET_DESKTOP_NAMES; + public readonly IntPtr _NET_ACTIVE_WINDOW; + public readonly IntPtr _NET_WORKAREA; + public readonly IntPtr _NET_SUPPORTING_WM_CHECK; + public readonly IntPtr _NET_VIRTUAL_ROOTS; + public readonly IntPtr _NET_DESKTOP_LAYOUT; + public readonly IntPtr _NET_SHOWING_DESKTOP; + public readonly IntPtr _NET_CLOSE_WINDOW; + public readonly IntPtr _NET_MOVERESIZE_WINDOW; + public readonly IntPtr _NET_WM_MOVERESIZE; + public readonly IntPtr _NET_RESTACK_WINDOW; + public readonly IntPtr _NET_REQUEST_FRAME_EXTENTS; + public readonly IntPtr _NET_WM_NAME; + public readonly IntPtr _NET_WM_VISIBLE_NAME; + public readonly IntPtr _NET_WM_ICON_NAME; + public readonly IntPtr _NET_WM_VISIBLE_ICON_NAME; + public readonly IntPtr _NET_WM_DESKTOP; + public readonly IntPtr _NET_WM_WINDOW_TYPE; + public readonly IntPtr _NET_WM_STATE; + public readonly IntPtr _NET_WM_ALLOWED_ACTIONS; + public readonly IntPtr _NET_WM_STRUT; + public readonly IntPtr _NET_WM_STRUT_PARTIAL; + public readonly IntPtr _NET_WM_ICON_GEOMETRY; + public readonly IntPtr _NET_WM_ICON; + public readonly IntPtr _NET_WM_PID; + public readonly IntPtr _NET_WM_HANDLED_ICONS; + public readonly IntPtr _NET_WM_USER_TIME; + public readonly IntPtr _NET_FRAME_EXTENTS; + public readonly IntPtr _NET_WM_PING; + public readonly IntPtr _NET_WM_SYNC_REQUEST; + public readonly IntPtr _NET_SYSTEM_TRAY_S; + public readonly IntPtr _NET_SYSTEM_TRAY_ORIENTATION; + public readonly IntPtr _NET_SYSTEM_TRAY_OPCODE; + public readonly IntPtr _NET_WM_STATE_MAXIMIZED_HORZ; + public readonly IntPtr _NET_WM_STATE_MAXIMIZED_VERT; + public readonly IntPtr _XEMBED; + public readonly IntPtr _XEMBED_INFO; + public readonly IntPtr _MOTIF_WM_HINTS; + public readonly IntPtr _NET_WM_STATE_SKIP_TASKBAR; + public readonly IntPtr _NET_WM_STATE_ABOVE; + public readonly IntPtr _NET_WM_STATE_MODAL; + public readonly IntPtr _NET_WM_STATE_HIDDEN; + public readonly IntPtr _NET_WM_CONTEXT_HELP; + public readonly IntPtr _NET_WM_WINDOW_OPACITY; + public readonly IntPtr _NET_WM_WINDOW_TYPE_DESKTOP; + public readonly IntPtr _NET_WM_WINDOW_TYPE_DOCK; + public readonly IntPtr _NET_WM_WINDOW_TYPE_TOOLBAR; + public readonly IntPtr _NET_WM_WINDOW_TYPE_MENU; + public readonly IntPtr _NET_WM_WINDOW_TYPE_UTILITY; + public readonly IntPtr _NET_WM_WINDOW_TYPE_SPLASH; + public readonly IntPtr _NET_WM_WINDOW_TYPE_DIALOG; + public readonly IntPtr _NET_WM_WINDOW_TYPE_NORMAL; + public readonly IntPtr CLIPBOARD; + public readonly IntPtr PRIMARY; + public readonly IntPtr DIB; + public readonly IntPtr OEMTEXT; + public readonly IntPtr UNICODETEXT; + public readonly IntPtr TARGETS; + public readonly IntPtr PostAtom; + public readonly IntPtr AsyncAtom; + + + public X11Atoms (X11Display display) { + + // make sure this array stays in sync with the statements below + string [] atom_names = new string[] { + "WM_PROTOCOLS", + "WM_DELETE_WINDOW", + "WM_TAKE_FOCUS", + "_NET_SUPPORTED", + "_NET_CLIENT_LIST", + "_NET_NUMBER_OF_DESKTOPS", + "_NET_DESKTOP_GEOMETRY", + "_NET_DESKTOP_VIEWPORT", + "_NET_CURRENT_DESKTOP", + "_NET_DESKTOP_NAMES", + "_NET_ACTIVE_WINDOW", + "_NET_WORKAREA", + "_NET_SUPPORTING_WM_CHECK", + "_NET_VIRTUAL_ROOTS", + "_NET_DESKTOP_LAYOUT", + "_NET_SHOWING_DESKTOP", + "_NET_CLOSE_WINDOW", + "_NET_MOVERESIZE_WINDOW", + "_NET_WM_MOVERESIZE", + "_NET_RESTACK_WINDOW", + "_NET_REQUEST_FRAME_EXTENTS", + "_NET_WM_NAME", + "_NET_WM_VISIBLE_NAME", + "_NET_WM_ICON_NAME", + "_NET_WM_VISIBLE_ICON_NAME", + "_NET_WM_DESKTOP", + "_NET_WM_WINDOW_TYPE", + "_NET_WM_STATE", + "_NET_WM_ALLOWED_ACTIONS", + "_NET_WM_STRUT", + "_NET_WM_STRUT_PARTIAL", + "_NET_WM_ICON_GEOMETRY", + "_NET_WM_ICON", + "_NET_WM_PID", + "_NET_WM_HANDLED_ICONS", + "_NET_WM_USER_TIME", + "_NET_FRAME_EXTENTS", + "_NET_WM_PING", + "_NET_WM_SYNC_REQUEST", + "_NET_SYSTEM_TRAY_OPCODE", + "_NET_SYSTEM_TRAY_ORIENTATION", + "_NET_WM_STATE_MAXIMIZED_HORZ", + "_NET_WM_STATE_MAXIMIZED_VERT", + "_NET_WM_STATE_HIDDEN", + "_XEMBED", + "_XEMBED_INFO", + "_MOTIF_WM_HINTS", + "_NET_WM_STATE_SKIP_TASKBAR", + "_NET_WM_STATE_ABOVE", + "_NET_WM_STATE_MODAL", + "_NET_WM_CONTEXT_HELP", + "_NET_WM_WINDOW_OPACITY", + "_NET_WM_WINDOW_TYPE_DESKTOP", + "_NET_WM_WINDOW_TYPE_DOCK", + "_NET_WM_WINDOW_TYPE_TOOLBAR", + "_NET_WM_WINDOW_TYPE_MENU", + "_NET_WM_WINDOW_TYPE_UTILITY", + "_NET_WM_WINDOW_TYPE_DIALOG", + "_NET_WM_WINDOW_TYPE_SPLASH", + "_NET_WM_WINDOW_TYPE_NORMAL", + "CLIPBOARD", + "PRIMARY", + "COMPOUND_TEXT", + "UTF8_STRING", + "TARGETS", + "_SWF_AsyncAtom", + "_SWF_PostMessageAtom", + "_SWF_HoverAtom" }; + + IntPtr[] atoms = new IntPtr [atom_names.Length];; + + Xlib.XInternAtoms (display.Handle, atom_names, atom_names.Length, false, atoms); + + int off = 0; + WM_PROTOCOLS = atoms [off++]; + WM_DELETE_WINDOW = atoms [off++]; + WM_TAKE_FOCUS = atoms [off++]; + _NET_SUPPORTED = atoms [off++]; + _NET_CLIENT_LIST = atoms [off++]; + _NET_NUMBER_OF_DESKTOPS = atoms [off++]; + _NET_DESKTOP_GEOMETRY = atoms [off++]; + _NET_DESKTOP_VIEWPORT = atoms [off++]; + _NET_CURRENT_DESKTOP = atoms [off++]; + _NET_DESKTOP_NAMES = atoms [off++]; + _NET_ACTIVE_WINDOW = atoms [off++]; + _NET_WORKAREA = atoms [off++]; + _NET_SUPPORTING_WM_CHECK = atoms [off++]; + _NET_VIRTUAL_ROOTS = atoms [off++]; + _NET_DESKTOP_LAYOUT = atoms [off++]; + _NET_SHOWING_DESKTOP = atoms [off++]; + _NET_CLOSE_WINDOW = atoms [off++]; + _NET_MOVERESIZE_WINDOW = atoms [off++]; + _NET_WM_MOVERESIZE = atoms [off++]; + _NET_RESTACK_WINDOW = atoms [off++]; + _NET_REQUEST_FRAME_EXTENTS = atoms [off++]; + _NET_WM_NAME = atoms [off++]; + _NET_WM_VISIBLE_NAME = atoms [off++]; + _NET_WM_ICON_NAME = atoms [off++]; + _NET_WM_VISIBLE_ICON_NAME = atoms [off++]; + _NET_WM_DESKTOP = atoms [off++]; + _NET_WM_WINDOW_TYPE = atoms [off++]; + _NET_WM_STATE = atoms [off++]; + _NET_WM_ALLOWED_ACTIONS = atoms [off++]; + _NET_WM_STRUT = atoms [off++]; + _NET_WM_STRUT_PARTIAL = atoms [off++]; + _NET_WM_ICON_GEOMETRY = atoms [off++]; + _NET_WM_ICON = atoms [off++]; + _NET_WM_PID = atoms [off++]; + _NET_WM_HANDLED_ICONS = atoms [off++]; + _NET_WM_USER_TIME = atoms [off++]; + _NET_FRAME_EXTENTS = atoms [off++]; + _NET_WM_PING = atoms [off++]; + _NET_WM_SYNC_REQUEST = atoms [off++]; + _NET_SYSTEM_TRAY_OPCODE = atoms [off++]; + _NET_SYSTEM_TRAY_ORIENTATION = atoms [off++]; + _NET_WM_STATE_MAXIMIZED_HORZ = atoms [off++]; + _NET_WM_STATE_MAXIMIZED_VERT = atoms [off++]; + _NET_WM_STATE_HIDDEN = atoms [off++]; + _XEMBED = atoms [off++]; + _XEMBED_INFO = atoms [off++]; + _MOTIF_WM_HINTS = atoms [off++]; + _NET_WM_STATE_SKIP_TASKBAR = atoms [off++]; + _NET_WM_STATE_ABOVE = atoms [off++]; + _NET_WM_STATE_MODAL = atoms [off++]; + _NET_WM_CONTEXT_HELP = atoms [off++]; + _NET_WM_WINDOW_OPACITY = atoms [off++]; + _NET_WM_WINDOW_TYPE_DESKTOP = atoms [off++]; + _NET_WM_WINDOW_TYPE_DOCK = atoms [off++]; + _NET_WM_WINDOW_TYPE_TOOLBAR = atoms [off++]; + _NET_WM_WINDOW_TYPE_MENU = atoms [off++]; + _NET_WM_WINDOW_TYPE_UTILITY = atoms [off++]; + _NET_WM_WINDOW_TYPE_DIALOG = atoms [off++]; + _NET_WM_WINDOW_TYPE_SPLASH = atoms [off++]; + _NET_WM_WINDOW_TYPE_NORMAL = atoms [off++]; + CLIPBOARD = atoms [off++]; + PRIMARY = atoms [off++]; + OEMTEXT = atoms [off++]; + UNICODETEXT = atoms [off++]; + TARGETS = atoms [off++]; + AsyncAtom = atoms [off++]; + PostAtom = atoms [off++]; + display.HoverState.Atom = atoms [off++]; + + DIB = XA_PIXMAP; + + // XXX multi screen stuff here + _NET_SYSTEM_TRAY_S = Xlib.XInternAtom (display.Handle, "_NET_SYSTEM_TRAY_S" + display.DefaultScreen.ToString(), false); + } + + } + +} + diff --git a/source/ShiftUI/Internal/X11Clipboard.cs b/source/ShiftUI/Internal/X11Clipboard.cs new file mode 100644 index 0000000..b951cc3 --- /dev/null +++ b/source/ShiftUI/Internal/X11Clipboard.cs @@ -0,0 +1,105 @@ +// 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) 2009 Novell, Inc. +// +// Authors: +// Carlos Alberto Cortez ([email protected]) +// + +using System; +using System.Drawing; +using System.Collections; +using System.Collections.Specialized; + +namespace ShiftUI { + + internal class ClipboardData { + ListDictionary source_data; // Source in its different formats, if any + string plain_text_source; // Cached source as plain-text string + Image image_source; // Cached source as image + + internal object Item; // Object on the clipboard + internal ArrayList Formats; // list of formats available in the clipboard + internal bool Retrieving; // true if we are requesting an item + internal bool Enumerating; // true if we are enumerating through all known types + internal XplatUI.ObjectToClipboard Converter; + + public ClipboardData () + { + source_data = new ListDictionary (); + } + + public void ClearSources () + { + source_data.Clear (); + plain_text_source = null; + image_source = null; + } + + public void AddSource (int type, object source) + { + // Try to detect plain text, based on the old behaviour of XplatUIX11, which usually assigns + // -1 as the type when a string is stored in the Clipboard + if (source is string && (type == DataFormats.GetFormat (DataFormats.Text).Id || type == -1)) + plain_text_source = source as string; + else if (source is Image) + image_source = source as Image; + + source_data [type] = source; + } + + public object GetSource (int type) + { + return source_data [type]; + } + + public string GetPlainText () + { + return plain_text_source; + } + + public string GetRtfText () + { + DataFormats.Format format = DataFormats.GetFormat (DataFormats.Rtf); + if (format == null) + return null; // FIXME - is RTF not supported on any system? + + return (string)GetSource (format.Id); + } + + public Image GetImage () + { + return image_source; + } + + public bool IsSourceText { + get { + return plain_text_source != null; + } + } + + public bool IsSourceImage { + get { + return image_source != null; + } + } + } +} + diff --git a/source/ShiftUI/Internal/X11DesktopColors.cs b/source/ShiftUI/Internal/X11DesktopColors.cs new file mode 100644 index 0000000..d3cdd26 --- /dev/null +++ b/source/ShiftUI/Internal/X11DesktopColors.cs @@ -0,0 +1,298 @@ +// 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 Dennis Bartok ([email protected]) +// Alexander Olk ([email protected]) +// +// + +using System.Drawing; +using System.Runtime.InteropServices; +using System.IO; +using System; + +namespace ShiftUI { + internal class X11DesktopColors { + #region Structs & Enums + [StructLayout(LayoutKind.Sequential)] + internal struct GdkColorStruct { + internal int pixel; + internal short red; + internal short green; + internal short blue; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct GObjectStruct { + public IntPtr Instance; + public IntPtr ref_count; + public IntPtr data; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct GtkStyleStruct { + internal GObjectStruct obj; + [MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=5)] + internal GdkColorStruct[] fg; + [MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=5)] + internal GdkColorStruct[] bg; + [MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=5)] + internal GdkColorStruct[] light; + [MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=5)] + internal GdkColorStruct[] dark; + [MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=5)] + internal GdkColorStruct[] mid; + [MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=5)] + internal GdkColorStruct[] text; + [MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=5)] + internal GdkColorStruct[] baseclr; + [MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=5)] + internal GdkColorStruct[] text_aa; /* Halfway between text/base */ + + internal GdkColorStruct black; + internal GdkColorStruct white; + + /* TODO: There is more stuff that we will add when we need it*/ + } + + private enum Desktop { + Gtk, + KDE, + Unknown + } + #endregion // Structs & Enums + + #region Local Variables + static private Desktop desktop; + #endregion // Local Variables + + #region Constructors + static X11DesktopColors() { + FindDesktopEnvironment(); + + switch(desktop) { + case Desktop.Gtk: { + //IntPtr dispmgr; + //IntPtr gdkdisplay; + IntPtr widget; + IntPtr style_ptr; + GtkStyleStruct style; + + try { + GtkInit(); + //dispmgr = gdk_display_manager_get (); + //gdkdisplay = gdk_display_manager_get_default_display (dispmgr); + + widget = gtk_invisible_new (); + gtk_widget_ensure_style (widget); + style_ptr = gtk_widget_get_style (widget); + + style = (GtkStyleStruct) Marshal.PtrToStructure (style_ptr, typeof (GtkStyleStruct)); + + ThemeEngine.Current.ColorControl = ColorFromGdkColor (style.bg[0]); + ThemeEngine.Current.ColorControlText = ColorFromGdkColor (style.fg[0]); + ThemeEngine.Current.ColorControlDark = ColorFromGdkColor (style.dark[0]); + ThemeEngine.Current.ColorControlLight = ColorFromGdkColor (style.light[0]); + ThemeEngine.Current.ColorControlLightLight = WidgetPaint.Light (ThemeEngine.Current.ColorControlLight); + ThemeEngine.Current.ColorControlDarkDark = WidgetPaint.Dark (ThemeEngine.Current.ColorControlDark); + + // We don't want WidgetLight to disappear on a white background! + if (ThemeEngine.Current.ColorControlLight.ToArgb () == Color.White.ToArgb ()) { + ThemeEngine.Current.ColorControlLight = Color.FromArgb (255, 227, 227, 227); + } + widget = gtk_menu_new (); + gtk_widget_ensure_style (widget); + style_ptr = gtk_widget_get_style (widget); + + style = (GtkStyleStruct) Marshal.PtrToStructure (style_ptr, typeof (GtkStyleStruct)); + + ThemeEngine.Current.ColorMenu = ColorFromGdkColor (style.bg [0]); + ThemeEngine.Current.ColorMenuText = ColorFromGdkColor (style.text [0]); + } + + catch (DllNotFoundException) { + Console.Error.WriteLine("Gtk not found (missing LD_LIBRARY_PATH to libgtk-x11-2.0.so.0?), using built-in colorscheme"); + } + + catch { + Console.Error.WriteLine("Gtk colorscheme read failure, using built-in colorscheme"); + } + break; + } + + case Desktop.KDE: { + if (! ReadKDEColorsheme() ) + Console.Error.WriteLine("KDE colorscheme read failure, using built-in colorscheme"); + break; + } + + default: { + break; + } + } + } + + static void GtkInit () + { + gtk_init_check (IntPtr.Zero, IntPtr.Zero); + } + #endregion // Constructors + + #region Properties + static void FindDesktopEnvironment() { + desktop = Desktop.Gtk; + string session = Environment.GetEnvironmentVariable("DESKTOP_SESSION"); + + if ( session != null ) { + session = session.ToUpper( ); + + if ( session == "DEFAULT" ) { + string helper = Environment.GetEnvironmentVariable("KDE_FULL_SESSION"); + + if ( helper != null ) + desktop = Desktop.KDE; + } else + if ( session.StartsWith("KDE") ) + desktop = Desktop.KDE; + } + } + #endregion // Properties + + #region Methods + static internal void Initialize() { + // Do nothing; all is done in our static ctor + } + + private static Color ColorFromGdkColor (GdkColorStruct gtkcolor) { + return Color.FromArgb (255, + (gtkcolor.red >> 8) & 0xff, + (gtkcolor.green >> 8) & 0xff, + (gtkcolor.blue >> 8) & 0xff ); + } + + private static bool ReadKDEColorsheme() { + string full_kdegloabals_filename = Environment.GetFolderPath(Environment.SpecialFolder.Personal) + + "/" + + ".kde/share/config/kdeglobals"; + + if (!File.Exists(full_kdegloabals_filename)) + return false; + + StreamReader sr = new StreamReader(full_kdegloabals_filename); + + string line = sr.ReadLine(); + + Color tmp_color; + + while (line != null) { + line = line.Trim(); + + if (line.StartsWith( "background=")) { + tmp_color = GetColorFromKDEString(line); + + if (tmp_color != Color.Empty) { + ThemeEngine.Current.ColorControl = tmp_color; + ThemeEngine.Current.ColorMenu = tmp_color; + } + } else + if (line.StartsWith( "foreground=")) { + tmp_color = GetColorFromKDEString(line); + + if (tmp_color != Color.Empty) { + ThemeEngine.Current.ColorControlText = tmp_color; + ThemeEngine.Current.ColorMenuText = tmp_color; + } + } else + if (line.StartsWith("selectBackground")) { + tmp_color = GetColorFromKDEString(line); + + if (tmp_color != Color.Empty) { + ThemeEngine.Current.ColorHighlight = tmp_color; + } + } else + if (line.StartsWith("selectForeground")) { + tmp_color = GetColorFromKDEString(line); + + if (tmp_color != Color.Empty) { + ThemeEngine.Current.ColorHighlightText = tmp_color; + } + } + + line = sr.ReadLine(); + } + + sr.Close(); + + return true; + } + + private static Color GetColorFromKDEString(string line) { + string[] split = line.Split(new char[] {'='}); + + if (split.Length > 0) { + line = split[1]; + + split = line.Split(new char[] {','}); + + if (split.Length == 3) { + int r = System.Convert.ToInt32(split[0]); + int g = System.Convert.ToInt32(split[1]); + int b = System.Convert.ToInt32(split[2]); + + return Color.FromArgb(r, g, b); + } + } + + return Color.Empty; + } + #endregion // Methods + + #region DllImports + const string libgdk = "libgdk-x11-2.0.so.0"; + const string libgtk = "libgtk-x11-2.0.so.0"; + + [DllImport(libgtk)] + static extern bool gtk_init_check (IntPtr argc, IntPtr argv); + + [DllImport(libgdk)] + internal static extern IntPtr gdk_display_manager_get (); + + [DllImport(libgdk)] + internal static extern IntPtr gdk_display_manager_get_default_display (IntPtr display_manager); + + [DllImport(libgtk)] + static extern IntPtr gtk_invisible_new (); + + [DllImport(libgtk)] + static extern IntPtr gtk_menu_new (); + + //[DllImport(libgtk)] + //static extern IntPtr gtk_menu_item_new_with_label (string label); + + [DllImport(libgtk)] + static extern void gtk_widget_ensure_style (IntPtr raw); + + [DllImport(libgtk)] + static extern IntPtr gtk_widget_get_style (IntPtr raw); + #endregion // DllImports + } +} diff --git a/source/ShiftUI/Internal/X11Display.cs b/source/ShiftUI/Internal/X11Display.cs new file mode 100644 index 0000000..221e5f1 --- /dev/null +++ b/source/ShiftUI/Internal/X11Display.cs @@ -0,0 +1,2693 @@ +// 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) 2006 Novell, Inc. (http://www.novell.com) +// +// +using System; +using System.Collections; +using System.Diagnostics; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Drawing.Imaging; +using System.IO; +using System.Net; +using System.Net.Sockets; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; +using ShiftUI; +// Only do the poll when building with mono for now +#if __MonoCS__ +//using Mono.Unix.Native; +#endif + +namespace ShiftUI.X11Internal { + + internal class X11Display { + + IntPtr display; /* our X handle */ + + // XXX internal because X11Hwnd needs them + internal IntPtr CustomVisual; // Visual for window creation + internal IntPtr CustomColormap; // Colormap for window creation + + X11Keyboard Keyboard; + internal X11Dnd Dnd; // XXX X11Hwnd needs it to enable Dnd + bool detectable_key_auto_repeat; + + X11Atoms atoms; + X11RootHwnd root_hwnd; + X11Hwnd foster_hwnd; + + // Clipboard + IntPtr ClipMagic; + + // Focus tracking + internal X11Hwnd ActiveWindow; + X11Hwnd FocusWindow; + + // Modality support + Stack ModalWindows; // Stack of our modal windows + + // Caret + CaretStruct Caret; + + // mouse hover message generation + // XXX internal because X11Atoms needs to access it.. + internal HoverStruct HoverState; + + // double click message generation + ClickStruct ClickPending; + int DoubleClickInterval; // msec; max interval between clicks to count as double click + + // Support for mouse grab + GrabStruct Grab; + + // Cursors + IntPtr LastCursorWindow; // The last window we set the cursor on + IntPtr LastCursorHandle; // The handle that was last set on LastCursorWindow + IntPtr OverrideCursorHandle; // The cursor that is set to override any other cursors + + // State + Point MousePosition; // Last position of mouse, in screen coords + MouseButtons MouseState; // Last state of mouse buttons + + XErrorHandler ErrorHandler; // Error handler delegate + bool ErrorExceptions; // Throw exceptions on X errors + + Thread event_thread; // the background thread that just watches our X socket + +#if __MonoCS__ + Pollfd[] pollfds; +#endif + + public X11Display (IntPtr display) + { + if (display == IntPtr.Zero) { + throw new ArgumentNullException("Display", + "Could not open display (X-Server required. Check your DISPLAY environment variable)"); + } + + this.display = display; + + // Debugging support + if (Environment.GetEnvironmentVariable ("MONO_XSYNC") != null) { + Xlib.XSynchronize (display, true); + } + + if (Environment.GetEnvironmentVariable ("MONO_XEXCEPTIONS") != null) { + ErrorExceptions = true; + } + + atoms = new X11Atoms (this); + + DoubleClickInterval = 500; + + HoverState.Interval = 500; + HoverState.Timer = new Timer(); + HoverState.Timer.Enabled = false; + HoverState.Timer.Interval = HoverState.Interval; + HoverState.Timer.Tick += new EventHandler(MouseHover); + HoverState.Size = new Size(4, 4); + HoverState.X = -1; + HoverState.Y = -1; + + ActiveWindow = null; + FocusWindow = null; + ModalWindows = new Stack(3); + + MouseState = MouseButtons.None; + MousePosition = new Point(0, 0); + + Caret.Timer = new Timer(); + Caret.Timer.Interval = 500; // FIXME - where should this number come from? + Caret.Timer.Tick += new EventHandler(CaretCallback); + + // XXX multiscreen work here + root_hwnd = new X11RootHwnd (this, Xlib.XRootWindow (display, DefaultScreen)); + + // XXX do we need a per-screen foster parent? + // Create the foster parent + foster_hwnd = new X11Hwnd (this, + Xlib.XCreateSimpleWindow (display, root_hwnd.WholeWindow, + 0, 0, 1, 1, 4, UIntPtr.Zero, UIntPtr.Zero)); + +#if __MonoCS__ + pollfds = new Pollfd [1]; + pollfds [0] = new Pollfd (); + pollfds [0].fd = Xlib.XConnectionNumber (display); + pollfds [0].events = PollEvents.POLLIN; +#endif + + Keyboard = new X11Keyboard(display, foster_hwnd.Handle); + Dnd = new X11Dnd (display, Keyboard); + + ErrorExceptions = false; + + // Handle any upcoming errors + ErrorHandler = new XErrorHandler (HandleError); + Xlib.XSetErrorHandler (ErrorHandler); + + X11DesktopColors.Initialize(); // XXX we need to figure out how to make this display specific? + + // Disable keyboard autorepeat + try { + Xlib.XkbSetDetectableAutoRepeat (display, true, IntPtr.Zero); + detectable_key_auto_repeat = true; + } catch { + Console.Error.WriteLine ("Could not disable keyboard auto repeat, will attempt to disable manually."); + detectable_key_auto_repeat = false; + } + + // we re-set our error handler here, X11DesktopColor stuff might have stolen it (gtk does) + Xlib.XSetErrorHandler (ErrorHandler); + + // create our event thread (just sits on the X socket waiting for events) + event_thread = new Thread (new ThreadStart (XEventThread)); + event_thread.IsBackground = true; + event_thread.Start (); + } + + #region Callbacks + private void MouseHover(object sender, EventArgs e) + { + HoverState.Timer.Enabled = false; + + if (HoverState.Window != IntPtr.Zero) { + X11Hwnd hwnd = (X11Hwnd)Hwnd.GetObjectFromWindow (HoverState.Window); + if (hwnd != null) { + XEvent xevent = new XEvent (); + + xevent.type = XEventName.ClientMessage; + xevent.ClientMessageEvent.display = display; + xevent.ClientMessageEvent.window = HoverState.Window; + xevent.ClientMessageEvent.message_type = HoverState.Atom; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = (IntPtr) (HoverState.Y << 16 | HoverState.X); + + hwnd.Queue.Enqueue (xevent); + } + } + } + + private void CaretCallback (object sender, EventArgs e) + { + if (Caret.Paused) { + return; + } + Caret.On = !Caret.On; + + Xlib.XDrawLine (display, Caret.Hwnd, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height); + } + + internal string WhereString () + { + StackTrace stack; + StackFrame frame; + string newline; + string unknown; + StringBuilder sb; + MethodBase method; + + newline = String.Format("{0}\t {1} ", Environment.NewLine, "at"); + unknown = "<unknown method>"; + sb = new StringBuilder(); + stack = new StackTrace(true); + + for (int i = 0; i < stack.FrameCount; i++) { + frame = stack.GetFrame (i); + sb.Append(newline); + + method = frame.GetMethod(); + if (method != null) { + if (frame.GetFileLineNumber() != 0) + sb.AppendFormat ("{0}.{1} () [{2}:{3}]", + method.DeclaringType.FullName, method.Name, + Path.GetFileName(frame.GetFileName()), frame.GetFileLineNumber()); + else + sb.AppendFormat ("{0}.{1} ()", method.DeclaringType.FullName, method.Name); + } else { + sb.Append(unknown); + } + } + return sb.ToString(); + } + + private int HandleError (IntPtr display, ref XErrorEvent error_event) + { + if (ErrorExceptions) + throw new X11Exception (error_event.display, error_event.resourceid, + error_event.serial, error_event.error_code, + error_event.request_code, error_event.minor_code); + else + Console.WriteLine ("X11 Error encountered: {0}{1}\n", + X11Exception.GetMessage(error_event.display, error_event.resourceid, + error_event.serial, error_event.error_code, + error_event.request_code, error_event.minor_code), + WhereString()); + return 0; + } + #endregion // Callbacks + + private void ShowCaret() + { + if ((Caret.gc == IntPtr.Zero) || Caret.On) { + return; + } + Caret.On = true; + + Xlib.XDrawLine (display, Caret.Window, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height); + } + + private void HideCaret() + { + if ((Caret.gc == IntPtr.Zero) || !Caret.On) { + return; + } + Caret.On = false; + + Xlib.XDrawLine (display, Caret.Window, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height); + } + + public void CaretVisible (IntPtr handle, bool visible) + { + if (Caret.Hwnd == handle) { + if (visible) { + if (!Caret.Visible) { + Caret.Visible = true; + ShowCaret(); + Caret.Timer.Start(); + } + } else { + Caret.Visible = false; + Caret.Timer.Stop(); + HideCaret(); + } + } + } + + public void AudibleAlert () + { + Xlib.XBell (display, 0); + } + + public void Flush () + { + Xlib.XFlush (display); + } + + public void Close () + { + // XXX shut down the event_thread + Xlib.XCloseDisplay (display); + } + + public IntPtr XGetParent(IntPtr handle) + { + IntPtr Root; + IntPtr Parent; + IntPtr Children; + int ChildCount; + + Xlib.XQueryTree (display, handle, out Root, out Parent, out Children, out ChildCount); + + if (Children!=IntPtr.Zero) { + Xlib.XFree(Children); + } + + return Parent; + } + + public bool SystrayAdd(IntPtr handle, string tip, Icon icon, out ToolTip tt) + { + IntPtr SystrayMgrWindow; + + Xlib.XGrabServer (display); + SystrayMgrWindow = Xlib.XGetSelectionOwner (display, Atoms._NET_SYSTEM_TRAY_S); + Xlib.XUngrabServer (display); + + if (SystrayMgrWindow != IntPtr.Zero) { + XSizeHints size_hints; + X11Hwnd hwnd; + + hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); +#if DriverDebug + Console.WriteLine("Adding Systray Whole:{0:X}, Client:{1:X}", + hwnd.WholeWindow.ToInt32(), hwnd.ClientWindow.ToInt32()); +#endif + + // Oh boy. + if (hwnd.ClientWindow != hwnd.WholeWindow) { + Xlib.XDestroyWindow (display, hwnd.ClientWindow); + hwnd.ClientWindow = hwnd.WholeWindow; + + try { + hwnd.Queue.Lock (); + + /* by virtue of the way the tests are ordered when determining if it's PAINT + or NCPAINT, ClientWindow == WholeWindow will always be PAINT. So, if we're + waiting on an nc_expose, drop it and remove the hwnd from the list (unless + there's a pending expose). */ + hwnd.PendingNCExpose = false; + } + finally { + hwnd.Queue.Unlock (); + } + } + + size_hints = new XSizeHints(); + + size_hints.flags = (IntPtr)(XSizeHintsFlags.PMinSize | XSizeHintsFlags.PMaxSize | XSizeHintsFlags.PBaseSize); + + size_hints.min_width = 24; + size_hints.min_height = 24; + size_hints.max_width = 24; + size_hints.max_height = 24; + size_hints.base_width = 24; + size_hints.base_height = 24; + + Xlib.XSetWMNormalHints (display, hwnd.WholeWindow, ref size_hints); + + int[] atoms = new int[2]; + atoms [0] = 1; // Version 1 + atoms [1] = 1; // we want to be mapped + + // This line cost me 3 days... + Xlib.XChangeProperty (display, + hwnd.WholeWindow, Atoms._XEMBED_INFO, Atoms._XEMBED_INFO, 32, + PropertyMode.Replace, atoms, 2); + + // Need to pick some reasonable defaults + tt = new ToolTip(); + tt.AutomaticDelay = 100; + tt.InitialDelay = 250; + tt.ReshowDelay = 250; + tt.ShowAlways = true; + + if ((tip != null) && (tip != string.Empty)) { + tt.SetToolTip(Widget.FromHandle(handle), tip); + tt.Active = true; + } else { + tt.Active = false; + } + + SendNetClientMessage (SystrayMgrWindow, + Atoms._NET_SYSTEM_TRAY_OPCODE, + IntPtr.Zero, + (IntPtr)SystrayRequest.SYSTEM_TRAY_REQUEST_DOCK, + hwnd.WholeWindow); + + return true; + } + + tt = null; + return false; + } + + public bool SystrayChange (IntPtr handle, string tip, Icon icon, ref ToolTip tt) + { + Widget Widget; + + Widget = Widget.FromHandle(handle); + if (Widget != null && tt != null) { + tt.SetToolTip(Widget, tip); + tt.Active = true; + return true; + } else { + return false; + } + } + + public void SystrayRemove(IntPtr handle, ref ToolTip tt) + { +#if GTKSOCKET_SUPPORTS_REPARENTING + X11Hwnd hwnd; + + hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + /* in the XEMBED spec, it mentions 3 ways for a client window to break the protocol with the embedder. + * 1. The embedder can unmap the window and reparent to the root window (we should probably handle this...) + * 2. The client can reparent its window out of the embedder window. + * 3. The client can destroy its window. + * + * this call to SetParent is case 2, but in + * the spec it also mentions that gtk doesn't + * support this at present. Looking at HEAD + * gtksocket-x11.c jives with this statement. + * + * so we can't reparent. we have to destroy. + */ + SetParent(hwnd.WholeWindow, FosterParent); +#else + Widget Widget = Widget.FromHandle(handle); + if (Widget is NotifyIcon.NotifyIconWindow) + ((NotifyIcon.NotifyIconWindow)Widget).InternalRecreateHandle (); +#endif + + // The caller can now re-dock it later... + if (tt != null) { + tt.Dispose(); + tt = null; + } + } + + public void ResetMouseHover (X11Hwnd hovering) + { + HoverState.Timer.Enabled = hovering != null; + HoverState.X = MousePosition.X; + HoverState.Y = MousePosition.Y; + HoverState.Window = hovering == null ? IntPtr.Zero : hovering.Handle; + } + + public void ShowCursor (bool show) + { + ; // FIXME - X11 doesn't 'hide' the cursor. we could create an empty cursor + } + + public void SetModal (X11Hwnd hwnd, bool Modal) + { + if (Modal) { + ModalWindows.Push(hwnd); + } else { + // XXX do we need to pop until the + // hwnd is off the stack? or just the + // most recently pushed hwnd? + if (ModalWindows.Contains(hwnd)) { + ModalWindows.Pop(); + } + + if (ModalWindows.Count > 0) { + X11Hwnd top_hwnd = (X11Hwnd)ModalWindows.Peek(); + top_hwnd.Activate(); + } + } + } + + public TransparencySupport SupportsTransparency () + { + // compiz adds _NET_WM_WINDOW_OPACITY to _NET_SUPPORTED on the root window, check for that + return ((IList)root_hwnd._NET_SUPPORTED).Contains (Atoms._NET_WM_WINDOW_OPACITY) ? TransparencySupport.GetSet : TransparencySupport.None; + } + + public void SendAsyncMethod (AsyncMethodData method) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(method.Handle); + XEvent xevent = new XEvent (); + + xevent.type = XEventName.ClientMessage; + xevent.ClientMessageEvent.display = display; + xevent.ClientMessageEvent.window = method.Handle; + xevent.ClientMessageEvent.message_type = Atoms.AsyncAtom; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = (IntPtr) GCHandle.Alloc (method); + + hwnd.Queue.Enqueue (xevent); + } + + delegate IntPtr WndProcDelegate (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam); + + public IntPtr SendMessage (IntPtr handle, Msg message, IntPtr wParam, IntPtr lParam) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + if (hwnd == null) + return IntPtr.Zero; + + if (hwnd.Queue.Thread != Thread.CurrentThread) { + AsyncMethodResult result; + AsyncMethodData data; + + result = new AsyncMethodResult (); + data = new AsyncMethodData (); + + data.Handle = hwnd.Handle; + data.Method = new WndProcDelegate (NativeWindow.WndProc); + data.Args = new object[] { hwnd.Handle, message, wParam, lParam }; + data.Result = result; + + SendAsyncMethod (data); +#if DriverDebug || DriverDebugThreads + Console.WriteLine ("Sending {0} message across.", message); +#endif + + return IntPtr.Zero; + } + else { + return NativeWindow.WndProc (hwnd.Handle, message, wParam, lParam); + } + } + + public int SendInput (IntPtr handle, Queue keys) { + if (handle == IntPtr.Zero) + return 0; + + int count = keys.Count; + Hwnd hwnd = Hwnd.ObjectFromHandle(handle); + + while (keys.Count > 0) { + + MSG msg = (MSG)keys.Dequeue(); + + XEvent xevent = new XEvent (); + + xevent.type = (msg.message == Msg.WM_KEYUP ? XEventName.KeyRelease : XEventName.KeyPress); + xevent.KeyEvent.display = display; + + if (hwnd != null) { + xevent.KeyEvent.window = hwnd.whole_window; + } else { + xevent.KeyEvent.window = IntPtr.Zero; + } + + xevent.KeyEvent.keycode = Keyboard.ToKeycode((int)msg.wParam); + + hwnd.Queue.EnqueueLocked (xevent); + } + return count; + } + + // FIXME - I think this should just enqueue directly + public bool PostMessage (IntPtr handle, Msg message, IntPtr wparam, IntPtr lparam) + { + XEvent xevent = new XEvent (); + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + xevent.type = XEventName.ClientMessage; + xevent.ClientMessageEvent.display = display; + + if (hwnd != null) { + xevent.ClientMessageEvent.window = hwnd.WholeWindow; + } else { + xevent.ClientMessageEvent.window = IntPtr.Zero; + } + + xevent.ClientMessageEvent.message_type = Atoms.PostAtom; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = handle; + xevent.ClientMessageEvent.ptr2 = (IntPtr) message; + xevent.ClientMessageEvent.ptr3 = wparam; + xevent.ClientMessageEvent.ptr4 = lparam; + + hwnd.Queue.Enqueue (xevent); + + return true; + } + + public void SendNetWMMessage (IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) + { + XEvent xev; + + xev = new XEvent(); + xev.ClientMessageEvent.type = XEventName.ClientMessage; + xev.ClientMessageEvent.send_event = true; + xev.ClientMessageEvent.window = window; + xev.ClientMessageEvent.message_type = message_type; + xev.ClientMessageEvent.format = 32; + xev.ClientMessageEvent.ptr1 = l0; + xev.ClientMessageEvent.ptr2 = l1; + xev.ClientMessageEvent.ptr3 = l2; + + Xlib.XSendEvent (display, root_hwnd.Handle, false, + new IntPtr ((int) (EventMask.SubstructureRedirectMask | EventMask.SubstructureNotifyMask)), ref xev); + } + + public void SendNetClientMessage (IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) + { + XEvent xev; + + xev = new XEvent(); + xev.ClientMessageEvent.type = XEventName.ClientMessage; + xev.ClientMessageEvent.send_event = true; + xev.ClientMessageEvent.window = window; + xev.ClientMessageEvent.message_type = message_type; + xev.ClientMessageEvent.format = 32; + xev.ClientMessageEvent.ptr1 = l0; + xev.ClientMessageEvent.ptr2 = l1; + xev.ClientMessageEvent.ptr3 = l2; + + Xlib.XSendEvent (display, window, false, new IntPtr ((int)EventMask.NoEventMask), ref xev); + } + + public bool TranslateMessage (ref MSG msg) + { + return Keyboard.TranslateMessage (ref msg); + } + + public IntPtr DispatchMessage (ref MSG msg) + { + return NativeWindow.WndProc(msg.hwnd, msg.message, msg.wParam, msg.lParam); + } + + private void QueryPointer (IntPtr w, out IntPtr root, out IntPtr child, + out int root_x, out int root_y, out int child_x, out int child_y, + out int mask) + { + /* this code was written with the help of + glance at gdk. I never would have realized we + needed a loop in order to traverse down in the + hierarchy. I would have assumed you'd get the + most deeply nested child and have to do + XQueryTree to move back up the hierarchy.. + stupid me, of course. */ + IntPtr c; + + // Xlib.XGrabServer (display); + + Xlib.XQueryPointer (display, w, out root, out c, + out root_x, out root_y, out child_x, out child_y, + out mask); + + if (root != w) + c = root; + + IntPtr child_last = IntPtr.Zero; + while (c != IntPtr.Zero) { + child_last = c; + Xlib.XQueryPointer (display, c, out root, out c, + out root_x, out root_y, out child_x, out child_y, + out mask); + } + + // Xlib.XUngrabServer (display); + + child = child_last; + } + + public void SetCursorPos (int x, int y) + { + IntPtr root, child; + int root_x, root_y, child_x, child_y, mask; + + /* we need to do a + * QueryPointer before warping + * because if the warp is on + * the RootWindow, the x/y are + * relative to the current + * mouse position + */ + QueryPointer (RootWindow.Handle, + out root, + out child, + out root_x, out root_y, + out child_x, out child_y, + out mask); + + Xlib.XWarpPointer (display, IntPtr.Zero, IntPtr.Zero, 0, 0, 0, 0, x - root_x, y - root_y); + + Xlib.XFlush (display); + + /* then we need to a + * QueryPointer after warping + * to manually generate a + * motion event for the window + * we move into. + */ + QueryPointer (RootWindow.Handle, + out root, + out child, + out root_x, out root_y, + out child_x, out child_y, + out mask); + + X11Hwnd child_hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(child); + if (child_hwnd == null) + return; + + XEvent xevent = new XEvent (); + + xevent.type = XEventName.MotionNotify; + xevent.MotionEvent.display = display; + xevent.MotionEvent.window = child_hwnd.Handle; + xevent.MotionEvent.root = RootWindow.Handle; + xevent.MotionEvent.x = child_x; + xevent.MotionEvent.y = child_y; + xevent.MotionEvent.x_root = root_x; + xevent.MotionEvent.y_root = root_y; + xevent.MotionEvent.state = mask; + + child_hwnd.Queue.Enqueue (xevent); + } + + public void SetFocus (X11Hwnd new_focus) + { + if (new_focus == FocusWindow) + return; + + X11Hwnd prev_focus = FocusWindow; + FocusWindow = new_focus; + + if (prev_focus != null) + SendMessage (prev_focus.Handle, Msg.WM_KILLFOCUS, + FocusWindow == null ? IntPtr.Zero : FocusWindow.Handle, IntPtr.Zero); + if (FocusWindow != null) + SendMessage (FocusWindow.Handle, Msg.WM_SETFOCUS, + prev_focus == null ? IntPtr.Zero : prev_focus.Handle, IntPtr.Zero); + + //XSetInputFocus(DisplayHandle, Hwnd.ObjectFromHandle(handle).ClientWindow, RevertTo.None, IntPtr.Zero); + } + + public IntPtr DefineCursor (Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot) + { + IntPtr cursor; + Bitmap cursor_bitmap; + Bitmap cursor_mask; + Byte[] cursor_bits; + Byte[] mask_bits; + Color c_pixel; + Color m_pixel; + int width; + int height; + IntPtr cursor_pixmap; + IntPtr mask_pixmap; + XColor fg; + XColor bg; + bool and; + bool xor; + + if (Xlib.XQueryBestCursor (display, RootWindow.Handle, bitmap.Width, bitmap.Height, out width, out height) == 0) { + return IntPtr.Zero; + } + + // Win32 only allows creation cursors of a certain size + if ((bitmap.Width != width) || (bitmap.Width != height)) { + cursor_bitmap = new Bitmap(bitmap, new Size(width, height)); + cursor_mask = new Bitmap(mask, new Size(width, height)); + } else { + cursor_bitmap = bitmap; + cursor_mask = mask; + } + + width = cursor_bitmap.Width; + height = cursor_bitmap.Height; + + cursor_bits = new Byte[(width / 8) * height]; + mask_bits = new Byte[(width / 8) * height]; + + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + c_pixel = cursor_bitmap.GetPixel(x, y); + m_pixel = cursor_mask.GetPixel(x, y); + + and = c_pixel == cursor_pixel; + xor = m_pixel == mask_pixel; + + if (!and && !xor) { + // Black + // cursor_bits[y * width / 8 + x / 8] &= (byte)~((1 << (x % 8))); // The bit already is 0 + mask_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8)); + } else if (and && !xor) { + // White + cursor_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8)); + mask_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8)); +#if notneeded + } else if (and && !xor) { + // Screen + } else if (and && xor) { + // Inverse Screen + + // X11 doesn't know the 'reverse screen' concept, so we'll treat them the same + // we want both to be 0 so nothing to be done + //cursor_bits[y * width / 8 + x / 8] &= (byte)~((1 << (x % 8))); + //mask_bits[y * width / 8 + x / 8] |= (byte)(01 << (x % 8)); +#endif + } + } + } + + cursor_pixmap = Xlib.XCreatePixmapFromBitmapData (display, RootWindow.Handle, + cursor_bits, width, height, (IntPtr)1, (IntPtr)0, 1); + mask_pixmap = Xlib.XCreatePixmapFromBitmapData (display, RootWindow.Handle, + mask_bits, width, height, (IntPtr)1, (IntPtr)0, 1); + fg = new XColor(); + bg = new XColor(); + + fg.pixel = Xlib.XWhitePixel (display, DefaultScreen); + fg.red = (ushort)65535; + fg.green = (ushort)65535; + fg.blue = (ushort)65535; + + bg.pixel = Xlib.XBlackPixel (display, DefaultScreen); + + cursor = Xlib.XCreatePixmapCursor (display, cursor_pixmap, mask_pixmap, ref fg, ref bg, xHotSpot, yHotSpot); + + Xlib.XFreePixmap (display, cursor_pixmap); + Xlib.XFreePixmap (display, mask_pixmap); + + return cursor; + } + + public Bitmap DefineStdCursorBitmap (StdCursor id) + { + CursorFontShape shape; + string name; + IntPtr theme; + int size; + Bitmap bmp = null; + + try { + shape = XplatUIX11.StdCursorToFontShape (id); + name = shape.ToString ().Replace ("XC_", string.Empty); + size = XplatUIX11.XcursorGetDefaultSize (Handle); + theme = XplatUIX11.XcursorGetTheme (Handle); + IntPtr images_ptr = XplatUIX11.XcursorLibraryLoadImages (name, theme, size); +#if debug + Console.WriteLine ("DefineStdCursorBitmap, id={0}, #id={1}, name{2}, size={3}, theme: {4}, images_ptr={5}", id, (int) id, name, size, Marshal.PtrToStringAnsi (theme), images_ptr); +#endif + + if (images_ptr == IntPtr.Zero) { + return null; + } + + XcursorImages images = (XcursorImages)Marshal.PtrToStructure (images_ptr, typeof (XcursorImages)); +#if debug + Console.WriteLine ("DefineStdCursorBitmap, cursor has {0} images", images.nimage); +#endif + + if (images.nimage > 0) { + // We only care about the first image. + XcursorImage image = (XcursorImage)Marshal.PtrToStructure (Marshal.ReadIntPtr (images.images), typeof (XcursorImage)); + +#if debug + Console.WriteLine ("DefineStdCursorBitmap, loaded image <size={0}, height={1}, width={2}, xhot={3}, yhot={4}, pixels={5}", image.size, image.height, image.width, image.xhot, image.yhot, image.pixels); +#endif + // A sanity check + if (image.width <= short.MaxValue && image.height <= short.MaxValue) { + int [] pixels = new int [image.width * image.height]; + Marshal.Copy (image.pixels, pixels, 0, pixels.Length); + bmp = new Bitmap (image.width, image.height); + for (int w = 0; w < image.width; w++) { + for (int h = 0; h < image.height; h++) { + bmp.SetPixel (w, h, Color.FromArgb (pixels [h * image.width + w])); + } + } + } + } + + XplatUIX11.XcursorImagesDestroy (images_ptr); + + } catch (DllNotFoundException ex) { + Console.WriteLine ("Could not load libXcursor: " + ex.Message + " (" + ex.GetType ().Name + ")"); + return null; + } + + return bmp; + } + + public IntPtr DefineStdCursor (StdCursor id) + { + CursorFontShape shape; + + // FIXME - define missing shapes + + switch (id) { + case StdCursor.AppStarting: + shape = CursorFontShape.XC_watch; + break; + + case StdCursor.Arrow: + shape = CursorFontShape.XC_top_left_arrow; + break; + + case StdCursor.Cross: + shape = CursorFontShape.XC_crosshair; + break; + + case StdCursor.Default: + shape = CursorFontShape.XC_top_left_arrow; + break; + + case StdCursor.Hand: + shape = CursorFontShape.XC_hand1; + break; + + case StdCursor.Help: + shape = CursorFontShape.XC_question_arrow; + break; + + case StdCursor.HSplit: + shape = CursorFontShape.XC_sb_v_double_arrow; + break; + + case StdCursor.IBeam: + shape = CursorFontShape.XC_xterm; + break; + + case StdCursor.No: + shape = CursorFontShape.XC_circle; + break; + + case StdCursor.NoMove2D: + shape = CursorFontShape.XC_fleur; + break; + + case StdCursor.NoMoveHoriz: + shape = CursorFontShape.XC_fleur; + break; + + case StdCursor.NoMoveVert: + shape = CursorFontShape.XC_fleur; + break; + + case StdCursor.PanEast: + shape = CursorFontShape.XC_fleur; + break; + + case StdCursor.PanNE: + shape = CursorFontShape.XC_fleur; + break; + + case StdCursor.PanNorth: + shape = CursorFontShape.XC_fleur; + break; + + case StdCursor.PanNW: + shape = CursorFontShape.XC_fleur; + break; + + case StdCursor.PanSE: + shape = CursorFontShape.XC_fleur; + break; + + case StdCursor.PanSouth: + shape = CursorFontShape.XC_fleur; + break; + + case StdCursor.PanSW: + shape = CursorFontShape.XC_fleur; + break; + + case StdCursor.PanWest: + shape = CursorFontShape.XC_sizing; + break; + + case StdCursor.SizeAll: + shape = CursorFontShape.XC_fleur; + break; + + case StdCursor.SizeNESW: + shape = CursorFontShape.XC_top_right_corner; + break; + + case StdCursor.SizeNS: + shape = CursorFontShape.XC_sb_v_double_arrow; + break; + + case StdCursor.SizeNWSE: + shape = CursorFontShape.XC_top_left_corner; + break; + + case StdCursor.SizeWE: + shape = CursorFontShape.XC_sb_h_double_arrow; + break; + + case StdCursor.UpArrow: + shape = CursorFontShape.XC_center_ptr; + break; + + case StdCursor.VSplit: + shape = CursorFontShape.XC_sb_h_double_arrow; + break; + + case StdCursor.WaitCursor: + shape = CursorFontShape.XC_watch; + break; + + default: + return IntPtr.Zero; + } + + return Xlib.XCreateFontCursor (display, shape); + } + + // XXX this should take an X11Hwnd. + public void CreateCaret (IntPtr handle, int width, int height) + { + XGCValues gc_values; + X11Hwnd hwnd; + + hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (Caret.Hwnd != IntPtr.Zero) + DestroyCaret(Caret.Hwnd); + + Caret.Hwnd = handle; + Caret.Window = hwnd.ClientWindow; + Caret.Width = width; + Caret.Height = height; + Caret.Visible = false; + Caret.On = false; + + gc_values = new XGCValues(); + gc_values.line_width = width; + + Caret.gc = Xlib.XCreateGC (display, Caret.Window, new IntPtr ((int)GCFunction.GCLineWidth), ref gc_values); + if (Caret.gc == IntPtr.Zero) { + Caret.Hwnd = IntPtr.Zero; + return; + } + + Xlib.XSetFunction (display, Caret.gc, GXFunction.GXinvert); + } + + + // XXX this should take an X11Hwnd. + public void DestroyCaret (IntPtr handle) + { + if (Caret.Hwnd == handle) { + if (Caret.Visible == true) { + Caret.Timer.Stop (); + } + if (Caret.gc != IntPtr.Zero) { + Xlib.XFreeGC (display, Caret.gc); + Caret.gc = IntPtr.Zero; + } + Caret.Hwnd = IntPtr.Zero; + Caret.Visible = false; + Caret.On = false; + } + } + + public void SetCaretPos (IntPtr handle, int x, int y) + { + if (Caret.Hwnd == handle) { + Caret.Timer.Stop(); + HideCaret(); + + Caret.X = x; + Caret.Y = y; + + if (Caret.Visible == true) { + ShowCaret(); + Caret.Timer.Start(); + } + } + } + + public void DestroyCursor (IntPtr cursor) + { + Xlib.XFreeCursor (display, cursor); + } + + private void AccumulateDestroyedHandles (Widget c, ArrayList list) + { + if (c != null) { + Widget[] Widgets = c.Widgets.GetAllWidgets (); + + if (c.IsHandleCreated && !c.IsDisposed) { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(c.Handle); + +#if DriverDebug || DriverDebugDestroy + Console.WriteLine (" + adding {0} to the list of zombie windows", XplatUI.Window (hwnd.Handle)); + Console.WriteLine (" + parent X window is {0:X}", XGetParent (hwnd.WholeWindow).ToInt32()); +#endif + + list.Add (hwnd); + CleanupCachedWindows (hwnd); + hwnd.zombie = true; + } + + for (int i = 0; i < Widgets.Length; i ++) { + AccumulateDestroyedHandles (Widgets[i], list); + } + } + + } + + void CleanupCachedWindows (X11Hwnd hwnd) + { + if (ActiveWindow == hwnd) { + SendMessage (hwnd.ClientWindow, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_INACTIVE, IntPtr.Zero); + ActiveWindow = null; + } + + if (FocusWindow == hwnd) { + SendMessage (hwnd.ClientWindow, Msg.WM_KILLFOCUS, IntPtr.Zero, IntPtr.Zero); + FocusWindow = null; + } + + if (Grab.Hwnd == hwnd.Handle) { + Grab.Hwnd = IntPtr.Zero; + Grab.Confined = false; + } + + DestroyCaret (hwnd.Handle); + } + + + public void DestroyWindow (X11Hwnd hwnd) + { + CleanupCachedWindows (hwnd); + + hwnd.SendParentNotify (Msg.WM_DESTROY, int.MaxValue, int.MaxValue); + + ArrayList windows = new ArrayList (); + + AccumulateDestroyedHandles (Widget.WidgetNativeWindow.WidgetFromHandle(hwnd.Handle), windows); + + hwnd.DestroyWindow (); + + foreach (X11Hwnd h in windows) { + SendMessage (h.Handle, Msg.WM_DESTROY, IntPtr.Zero, IntPtr.Zero); + } + } + + public X11Hwnd GetActiveWindow () + { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + IntPtr active = IntPtr.Zero; + + Xlib.XGetWindowProperty (display, RootWindow.Handle, + Atoms._NET_ACTIVE_WINDOW, IntPtr.Zero, new IntPtr (1), false, + Atoms.XA_WINDOW, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + + if (((long)nitems > 0) && (prop != IntPtr.Zero)) { + active = (IntPtr)Marshal.ReadInt32(prop); + Xlib.XFree(prop); + } + + return (X11Hwnd)Hwnd.GetObjectFromWindow(active); + } + + public void SetActiveWindow (X11Hwnd new_active_window) + { + if (new_active_window != ActiveWindow) { + if (ActiveWindow != null) + PostMessage (ActiveWindow.Handle, Msg.WM_ACTIVATE, + (IntPtr)WindowActiveFlags.WA_INACTIVE, IntPtr.Zero); + + ActiveWindow = new_active_window; + + if (ActiveWindow != null) + PostMessage (ActiveWindow.Handle, Msg.WM_ACTIVATE, + (IntPtr)WindowActiveFlags.WA_ACTIVE, IntPtr.Zero); + } + + if (ModalWindows.Count > 0) { + // Modality handling, if we are modal and the new active window is one + // of ours but not the modal one, switch back to the modal window + + if (ActiveWindow != null && + NativeWindow.FromHandle (ActiveWindow.Handle) != null) { + if (ActiveWindow != (X11Hwnd)ModalWindows.Peek()) + ((X11Hwnd)ModalWindows.Peek()).Activate (); + } + } + } + + public void GetDisplaySize (out Size size) + { + XWindowAttributes attributes = new XWindowAttributes(); + + // FIXME - use _NET_WM messages instead? + Xlib.XGetWindowAttributes (display, RootWindow.Handle, ref attributes); + + size = new Size(attributes.width, attributes.height); + } + + // XXX this method doesn't really fit well anywhere in the backend + public SizeF GetAutoScaleSize (Font font) + { + Graphics g; + float width; + string magic_string = "The quick brown fox jumped over the lazy dog."; + double magic_number = 44.549996948242189; // XXX my god, where did this number come from? + + g = Graphics.FromHwnd (FosterParent.Handle); + + width = (float) (g.MeasureString (magic_string, font).Width / magic_number); + return new SizeF(width, font.Height); + } + + public void GetCursorPos (X11Hwnd hwnd, out int x, out int y) + { + IntPtr use_handle; + IntPtr root; + IntPtr child; + int root_x; + int root_y; + int win_x; + int win_y; + int keys_buttons; + + if (hwnd != null) + use_handle = hwnd.Handle; + else + use_handle = RootWindow.Handle; + + QueryPointer (use_handle, out root, out child, out root_x, out root_y, out win_x, out win_y, out keys_buttons); + + if (hwnd != null) { + x = win_x; + y = win_y; + } else { + x = root_x; + y = root_y; + } + } + + public IntPtr GetFocus () + { + return FocusWindow.Handle; + } + + public IntPtr GetMousewParam (int Delta) + { + int result = 0; + + if ((MouseState & MouseButtons.Left) != 0) { + result |= (int)MsgButtons.MK_LBUTTON; + } + + if ((MouseState & MouseButtons.Middle) != 0) { + result |= (int)MsgButtons.MK_MBUTTON; + } + + if ((MouseState & MouseButtons.Right) != 0) { + result |= (int)MsgButtons.MK_RBUTTON; + } + + Keys mods = ModifierKeys; + if ((mods & Keys.Widget) != 0) { + result |= (int)MsgButtons.MK_CONTROL; + } + + if ((mods & Keys.Shift) != 0) { + result |= (int)MsgButtons.MK_SHIFT; + } + + result |= Delta << 16; + + return (IntPtr)result; + } + + public void GrabInfo (out IntPtr handle, out bool GrabConfined, out Rectangle GrabArea) + { + handle = Grab.Hwnd; + GrabConfined = Grab.Confined; + GrabArea = Grab.Area; + } + + public void GrabWindow (X11Hwnd hwnd, X11Hwnd confine_to) + { + IntPtr confine_to_window; + + confine_to_window = IntPtr.Zero; + + if (confine_to != null) { + Console.WriteLine (Environment.StackTrace); + + XWindowAttributes attributes = new XWindowAttributes(); + + Xlib.XGetWindowAttributes (display, confine_to.ClientWindow, ref attributes); + + Grab.Area.X = attributes.x; + Grab.Area.Y = attributes.y; + Grab.Area.Width = attributes.width; + Grab.Area.Height = attributes.height; + Grab.Confined = true; + confine_to_window = confine_to.ClientWindow; + } + + Grab.Hwnd = hwnd.ClientWindow; + + Xlib.XGrabPointer (display, hwnd.ClientWindow, false, + EventMask.ButtonPressMask | EventMask.ButtonMotionMask | + EventMask.ButtonReleaseMask | EventMask.PointerMotionMask, + GrabMode.GrabModeAsync, GrabMode.GrabModeAsync, confine_to_window, IntPtr.Zero, IntPtr.Zero); + } + + public void UngrabWindow (X11Hwnd hwnd) + { + Xlib.XUngrabPointer (display, IntPtr.Zero); + Xlib.XFlush (display); + + // XXX make sure hwnd is what should have the grab and throw if not + Grab.Hwnd = IntPtr.Zero; + Grab.Confined = false; + } + +#if notyet + private void TranslatePropertyToClipboard (IntPtr property) + { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + + Clipboard.Item = null; + + Xlib.XGetWindowProperty (display, FosterParent.Handle, + property, IntPtr.Zero, new IntPtr (0x7fffffff), true, + Atoms.AnyPropertyType, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + + if ((long)nitems > 0) { + if (property == Atoms.XA_STRING) { + Clipboard.Item = Marshal.PtrToStringAnsi(prop); + } else if (property == Atoms.XA_BITMAP) { + // FIXME - convert bitmap to image + } else if (property == Atoms.XA_PIXMAP) { + // FIXME - convert pixmap to image + } else if (property == Atoms.OEMTEXT) { + Clipboard.Item = Marshal.PtrToStringAnsi(prop); + } else if (property == Atoms.UNICODETEXT) { + Clipboard.Item = Marshal.PtrToStringAnsi(prop); + } + + Xlib.XFree(prop); + } + } +#endif + + // XXX should we be using @handle instead of Atoms.CLIPBOARD here? + public int[] ClipboardAvailableFormats (IntPtr handle) + { + // XXX deal with the updatemessagequeue stuff +#if true + return new int[0]; +#else + DataFormats.Format f; + int[] result; + + f = DataFormats.Format.List; + + if (Xlib.XGetSelectionOwner (display, Atoms.CLIPBOARD) == IntPtr.Zero) { + return null; + } + + Clipboard.Formats = new ArrayList(); + + while (f != null) { + Xlib.XConvertSelection (display, Atoms.CLIPBOARD, (IntPtr)f.Id, (IntPtr)f.Id, FosterParent.Handle, IntPtr.Zero); + + Clipboard.Enumerating = true; + while (Clipboard.Enumerating) { + UpdateMessageQueue(null); + } + f = f.Next; + } + + result = new int[Clipboard.Formats.Count]; + + for (int i = 0; i < Clipboard.Formats.Count; i++) { + result[i] = ((IntPtr)Clipboard.Formats[i]).ToInt32 (); + } + + Clipboard.Formats = null; + return result; +#endif + } + + public void ClipboardClose (IntPtr handle) + { + if (handle != ClipMagic) { + throw new ArgumentException("handle is not a valid clipboard handle"); + } + return; + } + + public int ClipboardGetID (IntPtr handle, string format) + { + if (handle != ClipMagic) { + throw new ArgumentException("handle is not a valid clipboard handle"); + } + + if (format == "Text" ) return Atoms.XA_STRING.ToInt32(); + else if (format == "Bitmap" ) return Atoms.XA_BITMAP.ToInt32(); + //else if (format == "MetaFilePict" ) return 3; + //else if (format == "SymbolicLink" ) return 4; + //else if (format == "DataInterchangeFormat" ) return 5; + //else if (format == "Tiff" ) return 6; + else if (format == "OEMText" ) return Atoms.OEMTEXT.ToInt32(); + else if (format == "DeviceIndependentBitmap" ) return Atoms.XA_PIXMAP.ToInt32(); + else if (format == "Palette" ) return Atoms.XA_COLORMAP.ToInt32(); // Useless + //else if (format == "PenData" ) return 10; + //else if (format == "RiffAudio" ) return 11; + //else if (format == "WaveAudio" ) return 12; + else if (format == "UnicodeText" ) return Atoms.UNICODETEXT.ToInt32(); + //else if (format == "EnhancedMetafile" ) return 14; + //else if (format == "FileDrop" ) return 15; + //else if (format == "Locale" ) return 16; + + return Xlib.XInternAtom (display, format, false).ToInt32(); + } + + public IntPtr ClipboardOpen (bool primary_selection) + { + if (!primary_selection) + ClipMagic = Atoms.CLIPBOARD; + else + ClipMagic = Atoms.PRIMARY; + + return ClipMagic; + } + + // XXX @converter? + public object ClipboardRetrieve (IntPtr handle, int type, XplatUI.ClipboardToObject converter) + { + // XXX deal with the UpdateMessageQueue stuff +#if true + return null; +#else + Xlib.XConvertSelection (display, handle, (IntPtr)type, (IntPtr)type, FosterParent, IntPtr.Zero); + + Clipboard.Retrieving = true; + while (Clipboard.Retrieving) { + UpdateMessageQueue(null); + } + + return Clipboard.Item; +#endif + } + + public PaintEventArgs PaintEventStart (ref Message m, IntPtr handle, bool client) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (Caret.Visible == true) { + Caret.Paused = true; + HideCaret(); + } + + return hwnd.PaintEventStart (ref m, client); + } + + public void PaintEventEnd (ref Message m, IntPtr handle, bool client) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + hwnd.PaintEventEnd (ref m, client); + + if (Caret.Visible == true) { + ShowCaret(); + Caret.Paused = false; + } + } + + public void SetCursor (IntPtr handle, IntPtr cursor) + { + Hwnd hwnd; + + if (OverrideCursorHandle == IntPtr.Zero) { + if ((LastCursorWindow == handle) && (LastCursorHandle == cursor)) + return; + + LastCursorHandle = cursor; + LastCursorWindow = handle; + + hwnd = Hwnd.ObjectFromHandle(handle); + if (cursor != IntPtr.Zero) + Xlib.XDefineCursor (display, hwnd.whole_window, cursor); + else + Xlib.XUndefineCursor (display, hwnd.whole_window); + Xlib.XFlush (display); + } + else { + hwnd = Hwnd.ObjectFromHandle(handle); + Xlib.XDefineCursor (display, hwnd.whole_window, OverrideCursorHandle); + } + } + + public DragDropEffects StartDrag (IntPtr handle, object data, + DragDropEffects allowed_effects) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle (handle); + + if (hwnd == null) + throw new ArgumentException ("Attempt to begin drag from invalid window handle (" + handle.ToInt32 () + ")."); + + return Dnd.StartDrag (hwnd.ClientWindow, data, allowed_effects); + } + + public X11Atoms Atoms { + get { return atoms; } + } + + public int CurrentTimestamp { + get { + TimeSpan t = (DateTime.UtcNow - new DateTime(1970, 1, 1)); + + return (int) t.TotalSeconds; + } + } + + public Size CursorSize { + get { + int x; + int y; + + if (Xlib.XQueryBestCursor (display, RootWindow.Handle, 32, 32, out x, out y) != 0) { + return new Size (x, y); + } else { + return new Size (16, 16); + } + } + } + + public IntPtr Handle { + get { return display; } + } + + public Size IconSize { + get { + IntPtr list; + XIconSize size; + int count; + + if (Xlib.XGetIconSizes (display, RootWindow.Handle, out list, out count) != 0) { + long current; + int largest; + + current = (long)list; + largest = 0; + + size = new XIconSize(); + + for (int i = 0; i < count; i++) { + size = (XIconSize)Marshal.PtrToStructure((IntPtr)current, size.GetType()); + current += Marshal.SizeOf(size); + + // Look for our preferred size + if (size.min_width == 32) { + Xlib.XFree(list); + return new Size(32, 32); + } + + if (size.max_width == 32) { + Xlib.XFree(list); + return new Size(32, 32); + } + + if (size.min_width < 32 && size.max_width > 32) { + int x; + + // check if we can fit one + x = size.min_width; + while (x < size.max_width) { + x += size.width_inc; + if (x == 32) { + Xlib.XFree(list); + return new Size(32, 32); + } + } + } + + if (largest < size.max_width) { + largest = size.max_width; + } + } + + // We didn't find a match or we wouldn't be here + return new Size(largest, largest); + + } else { + return new Size(32, 32); + } + } + } + + public int KeyboardSpeed { + get { + // + // A lot harder: need to do: + // XkbQueryExtension(0x08051008, 0xbfffdf4c, 0xbfffdf50, 0xbfffdf54, 0xbfffdf58) = 1 + // XkbAllocKeyboard(0x08051008, 0xbfffdf4c, 0xbfffdf50, 0xbfffdf54, 0xbfffdf58) = 0x080517a8 + // XkbGetWidgets(0x08051008, 1, 0x080517a8, 0xbfffdf54, 0xbfffdf58) = 0 + // + // And from that we can tell the repetition rate + // + // Notice, the values must map to: + // [0, 31] which maps to 2.5 to 30 repetitions per second. + // + return 0; + } + } + + public int KeyboardDelay { + get { + // + // Return values must range from 0 to 4, 0 meaning 250ms, + // and 4 meaning 1000 ms. + // + return 1; // ie, 500 ms + } + } + + public int DefaultScreen { + get { return Xlib.XDefaultScreen (display); } + } + + public IntPtr DefaultColormap { + // XXX multiscreen + get { return Xlib.XDefaultColormap (display, DefaultScreen); } + } + + public Keys ModifierKeys { + get { return Keyboard.ModifierKeys; } + } + + public IntPtr OverrideCursor { + get { return OverrideCursorHandle; } + set { + if (Grab.Hwnd != IntPtr.Zero) { + Xlib.XChangeActivePointerGrab (display, + EventMask.ButtonMotionMask | + EventMask.PointerMotionMask | + EventMask.ButtonPressMask | + EventMask.ButtonReleaseMask, + value, IntPtr.Zero); + return; + } + + OverrideCursorHandle = value; + } + } + + public X11RootHwnd RootWindow { + get { return root_hwnd; } + } + + public Size SmallIconSize { + get { + IntPtr list; + XIconSize size; + int count; + + if (Xlib.XGetIconSizes (display, RootWindow.Handle, out list, out count) != 0) { + long current; + int smallest; + + current = (long)list; + smallest = 0; + + size = new XIconSize(); + + for (int i = 0; i < count; i++) { + size = (XIconSize)Marshal.PtrToStructure((IntPtr)current, size.GetType()); + current += Marshal.SizeOf(size); + + // Look for our preferred size + if (size.min_width == 16) { + Xlib.XFree(list); + return new Size(16, 16); + } + + if (size.max_width == 16) { + Xlib.XFree(list); + return new Size(16, 16); + } + + if (size.min_width < 16 && size.max_width > 16) { + int x; + + // check if we can fit one + x = size.min_width; + while (x < size.max_width) { + x += size.width_inc; + if (x == 16) { + Xlib.XFree(list); + return new Size(16, 16); + } + } + } + + if (smallest == 0 || smallest > size.min_width) { + smallest = size.min_width; + } + } + + // We didn't find a match or we wouldn't be here + return new Size(smallest, smallest); + + } else { + return new Size(16, 16); + } + } + } + + public X11Hwnd FosterParent { + get { return foster_hwnd; } + } + + public int MouseHoverTime { + get { return HoverState.Interval; } + } + + public Rectangle VirtualScreen { + get { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + int width; + int height; + + Xlib.XGetWindowProperty (display, RootWindow.Handle, + Atoms._NET_DESKTOP_GEOMETRY, IntPtr.Zero, new IntPtr (256), false, Atoms.XA_CARDINAL, + out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + + if ((long)nitems < 2) + goto failsafe; + + width = Marshal.ReadIntPtr(prop, 0).ToInt32(); + height = Marshal.ReadIntPtr(prop, IntPtr.Size).ToInt32(); + Xlib.XFree(prop); + + return new Rectangle(0, 0, width, height); + + failsafe: + XWindowAttributes attributes = new XWindowAttributes(); + + Xlib.XGetWindowAttributes (display, RootWindow.Handle, ref attributes); + + return new Rectangle(0, 0, attributes.width, attributes.height); + } + } + + public Rectangle WorkingArea { + get { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + int width; + int height; + int current_desktop; + int x; + int y; + + Xlib.XGetWindowProperty (display, RootWindow.Handle, + Atoms._NET_CURRENT_DESKTOP, IntPtr.Zero, new IntPtr(1), false, Atoms.XA_CARDINAL, + out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + + if ((long)nitems < 1) { + goto failsafe; + } + + current_desktop = Marshal.ReadIntPtr(prop, 0).ToInt32(); + Xlib.XFree(prop); + + Xlib.XGetWindowProperty (display, RootWindow.Handle, + Atoms._NET_WORKAREA, IntPtr.Zero, new IntPtr (256), false, Atoms.XA_CARDINAL, + out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + + if ((long)nitems < 4 * current_desktop) { + goto failsafe; + } + + x = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop).ToInt32(); + y = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size).ToInt32(); + width = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size * 2).ToInt32(); + height = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size * 3).ToInt32(); + Xlib.XFree(prop); + + return new Rectangle(x, y, width, height); + + failsafe: + XWindowAttributes attributes = new XWindowAttributes(); + + Xlib.XGetWindowAttributes (display, RootWindow.Handle, ref attributes); + + return new Rectangle(0, 0, attributes.width, attributes.height); + } + } + + private void XEventThread () + { + while (true) { +#if __MonoCS__ + Syscall.poll (pollfds, 1U, -1); + + while (Xlib.XPending (display) > 0) { +#endif + XEvent xevent = new XEvent (); + Xlib.XNextEvent (display, ref xevent); + + // this is kind of a gross place to put this, but we don't know about the + // key repeat state in X11ThreadQueue, nor to we want the queue code calling + // XPeekEvent. + if (!detectable_key_auto_repeat && + xevent.type == XEventName.KeyRelease && + Xlib.XPending (display) > 0) { + + XEvent nextevent = new XEvent (); + Xlib.XPeekEvent (display, ref nextevent); + + if (nextevent.type == XEventName.KeyPress && + nextevent.KeyEvent.keycode == xevent.KeyEvent.keycode && + nextevent.KeyEvent.time == xevent.KeyEvent.time) { + continue; + } + } + + X11Hwnd hwnd = (X11Hwnd)Hwnd.GetObjectFromWindow(xevent.AnyEvent.window); + if (hwnd != null) + hwnd.Queue.Enqueue (xevent); +#if __MonoCS__ + } +#endif + } + } + + private void RedirectMsgToEnabledAncestor (X11Hwnd hwnd, MSG msg, IntPtr window, + ref int event_x, ref int event_y) + { + int x, y; + + IntPtr dummy; + msg.hwnd = hwnd.EnabledHwnd; + Xlib.XTranslateCoordinates (display, window, + Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, + event_x, event_y, + out x, out y, out dummy); + event_x = x; + event_y = y; + msg.lParam = (IntPtr)(MousePosition.Y << 16 | MousePosition.X); + } + + + // This is called from the thread owning the corresponding X11ThreadQueue + [MonoTODO("Implement filtering")] + public bool GetMessage (object queue_id, ref MSG msg, IntPtr handle, int wFilterMin, int wFilterMax) + { + X11ThreadQueue queue = (X11ThreadQueue)queue_id; + XEvent xevent; + bool client; + bool got_xevent = false; + + X11Hwnd hwnd; + + ProcessNextMessage: + do { + got_xevent = queue.Dequeue (out xevent); + + if (!got_xevent) { +#if spew + Console.WriteLine (">"); + Console.Out.Flush (); +#endif + break; + } + +#if spew + Console.Write ("-"); + Console.Out.Flush (); +#endif + + hwnd = (X11Hwnd)Hwnd.GetObjectFromWindow (xevent.AnyEvent.window); + + // Handle messages for windows that are already or are about to be destroyed. + + // we need a special block for this because unless we remove the hwnd from the paint + // queue it will always stay there (since we don't handle the expose), and we'll + // effectively loop infinitely trying to repaint a non-existant window. + if (hwnd != null && hwnd.zombie && xevent.type == XEventName.Expose) { + hwnd.PendingExpose = hwnd.PendingNCExpose = false; + goto ProcessNextMessage; + } + + // We need to make sure we only allow DestroyNotify events through for zombie + // hwnds, since much of the event handling code makes requests using the hwnd's + // ClientWindow, and that'll result in BadWindow errors if there's some lag + // between the XDestroyWindow call and the DestroyNotify event. + if (hwnd == null || hwnd.zombie) { +#if DriverDebug || DriverDebugDestroy + Console.WriteLine("GetMessage(): Got message {0} for non-existent or already destroyed window {1:X}", + xevent.type, xevent.AnyEvent.window.ToInt32()); +#endif + goto ProcessNextMessage; + } + + client = hwnd.ClientWindow == xevent.AnyEvent.window; + + msg.hwnd = hwnd.Handle; + + switch (xevent.type) { + case XEventName.KeyPress: + Keyboard.KeyEvent (FocusWindow.Handle, xevent, ref msg); + return true; + + case XEventName.KeyRelease: + Keyboard.KeyEvent (FocusWindow.Handle, xevent, ref msg); + return true; + + case XEventName.ButtonPress: { + switch(xevent.ButtonEvent.button) { + case 1: + MouseState |= MouseButtons.Left; + if (client) { + msg.message = Msg.WM_LBUTTONDOWN; + } else { + msg.message = Msg.WM_NCLBUTTONDOWN; + hwnd.MenuToScreen (ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + // TODO: For WM_NCLBUTTONDOWN wParam specifies a hit-test value not the virtual keys down + msg.wParam=GetMousewParam(0); + break; + + case 2: + MouseState |= MouseButtons.Middle; + if (client) { + msg.message = Msg.WM_MBUTTONDOWN; + } else { + msg.message = Msg.WM_NCMBUTTONDOWN; + hwnd.MenuToScreen (ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + msg.wParam=GetMousewParam(0); + break; + + case 3: + MouseState |= MouseButtons.Right; + if (client) { + msg.message = Msg.WM_RBUTTONDOWN; + } else { + msg.message = Msg.WM_NCRBUTTONDOWN; + hwnd.MenuToScreen (ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + msg.wParam=GetMousewParam(0); + break; + + case 4: + msg.hwnd = FocusWindow.Handle; + msg.message=Msg.WM_MOUSEWHEEL; + msg.wParam=GetMousewParam(120); + break; + + case 5: + msg.hwnd = FocusWindow.Handle; + msg.message=Msg.WM_MOUSEWHEEL; + msg.wParam=GetMousewParam(-120); + break; + } + + msg.lParam=(IntPtr) (xevent.ButtonEvent.y << 16 | xevent.ButtonEvent.x); + MousePosition.X = xevent.ButtonEvent.x; + MousePosition.Y = xevent.ButtonEvent.y; + + if (!hwnd.Enabled) { + RedirectMsgToEnabledAncestor (hwnd, msg, xevent.AnyEvent.window, + ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + + if (Grab.Hwnd != IntPtr.Zero) + msg.hwnd = Grab.Hwnd; + + if (ClickPending.Pending && + ((((long)xevent.ButtonEvent.time - ClickPending.Time) < DoubleClickInterval) && + (msg.wParam == ClickPending.wParam) && + (msg.lParam == ClickPending.lParam) && + (msg.message == ClickPending.Message))) { + // Looks like a genuine double click, clicked twice on the same spot with the same keys + switch(xevent.ButtonEvent.button) { + case 1: + msg.message = client ? Msg.WM_LBUTTONDBLCLK : Msg.WM_NCLBUTTONDBLCLK; + break; + + case 2: + msg.message = client ? Msg.WM_MBUTTONDBLCLK : Msg.WM_NCMBUTTONDBLCLK; + break; + + case 3: + msg.message = client ? Msg.WM_RBUTTONDBLCLK : Msg.WM_NCRBUTTONDBLCLK; + break; + } + + ClickPending.Pending = false; + + } + else { + ClickPending.Pending = true; + ClickPending.Hwnd = msg.hwnd; + ClickPending.Message = msg.message; + ClickPending.wParam = msg.wParam; + ClickPending.lParam = msg.lParam; + ClickPending.Time = (long)xevent.ButtonEvent.time; + } + + if (msg.message == Msg.WM_LBUTTONDOWN || msg.message == Msg.WM_MBUTTONDOWN || msg.message == Msg.WM_RBUTTONDOWN) { + hwnd.SendParentNotify (msg.message, MousePosition.X, MousePosition.Y); + + // Win32 splurts MouseMove events all over the place, regardless of whether the mouse is actually moving or + // not, especially after mousedown and mouseup. To support apps relying on mousemove events between and after + // mouse clicks to repaint or whatever, we generate a mousemove event here. *sigh* + XEvent motionEvent = new XEvent (); + motionEvent.type = XEventName.MotionNotify; + motionEvent.MotionEvent.display = display; + motionEvent.MotionEvent.window = xevent.ButtonEvent.window; + motionEvent.MotionEvent.x = xevent.ButtonEvent.x; + motionEvent.MotionEvent.y = xevent.ButtonEvent.y; + hwnd.Queue.Enqueue (motionEvent); + } + + return true; + } + + case XEventName.ButtonRelease: + switch(xevent.ButtonEvent.button) { + case 1: + if (client) { + msg.message = Msg.WM_LBUTTONUP; + } else { + msg.message = Msg.WM_NCLBUTTONUP; + hwnd.MenuToScreen (ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + MouseState &= ~MouseButtons.Left; + msg.wParam=GetMousewParam(0); + break; + + case 2: + if (client) { + msg.message = Msg.WM_MBUTTONUP; + } else { + msg.message = Msg.WM_NCMBUTTONUP; + hwnd.MenuToScreen (ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + MouseState &= ~MouseButtons.Middle; + msg.wParam=GetMousewParam(0); + break; + + case 3: + if (client) { + msg.message = Msg.WM_RBUTTONUP; + } else { + msg.message = Msg.WM_NCRBUTTONUP; + hwnd.MenuToScreen (ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + MouseState &= ~MouseButtons.Right; + msg.wParam=GetMousewParam(0); + break; + + case 4: + goto ProcessNextMessage; + + case 5: + goto ProcessNextMessage; + } + + if (!hwnd.Enabled) { + RedirectMsgToEnabledAncestor (hwnd, msg, xevent.AnyEvent.window, + ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + + if (Grab.Hwnd != IntPtr.Zero) + msg.hwnd = Grab.Hwnd; + + msg.lParam=(IntPtr) (xevent.ButtonEvent.y << 16 | xevent.ButtonEvent.x); + MousePosition.X = xevent.ButtonEvent.x; + MousePosition.Y = xevent.ButtonEvent.y; + + // Win32 splurts MouseMove events all over the place, regardless of whether the mouse is actually moving or + // not, especially after mousedown and mouseup. To support apps relying on mousemove events between and after + // mouse clicks to repaint or whatever, we generate a mousemove event here. *sigh* + if (msg.message == Msg.WM_LBUTTONUP || msg.message == Msg.WM_MBUTTONUP || msg.message == Msg.WM_RBUTTONUP) { + XEvent motionEvent = new XEvent (); + motionEvent.type = XEventName.MotionNotify; + motionEvent.MotionEvent.display = display; + motionEvent.MotionEvent.window = xevent.ButtonEvent.window; + motionEvent.MotionEvent.x = xevent.ButtonEvent.x; + motionEvent.MotionEvent.y = xevent.ButtonEvent.y; + hwnd.Queue.Enqueue (motionEvent); + } + return true; + + case XEventName.MotionNotify: + /* XXX move the compression stuff here */ + + if (client) { +#if DriverDebugExtra + Console.WriteLine("GetMessage(): Window {0:X} MotionNotify x={1} y={2}", + client ? hwnd.ClientWindow.ToInt32() : hwnd.WholeWindow.ToInt32(), + xevent.MotionEvent.x, xevent.MotionEvent.y); +#endif + + if (Grab.Hwnd != IntPtr.Zero) + msg.hwnd = Grab.Hwnd; + else + NativeWindow.WndProc(msg.hwnd, Msg.WM_SETCURSOR, msg.hwnd, (IntPtr)HitTest.HTCLIENT); + + msg.message = Msg.WM_MOUSEMOVE; + msg.wParam = GetMousewParam(0); + msg.lParam = (IntPtr) (xevent.MotionEvent.y << 16 | xevent.MotionEvent.x & 0xFFFF); + + if (!hwnd.Enabled) { + RedirectMsgToEnabledAncestor (hwnd, msg, xevent.AnyEvent.window, + ref xevent.MotionEvent.x, ref xevent.MotionEvent.y); + } + + MousePosition.X = xevent.MotionEvent.x; + MousePosition.Y = xevent.MotionEvent.y; + + if ((HoverState.Timer.Enabled) && + (((MousePosition.X + HoverState.Size.Width) < HoverState.X) || + ((MousePosition.X - HoverState.Size.Width) > HoverState.X) || + ((MousePosition.Y + HoverState.Size.Height) < HoverState.Y) || + ((MousePosition.Y - HoverState.Size.Height) > HoverState.Y))) { + + HoverState.Timer.Stop(); + HoverState.Timer.Start(); + HoverState.X = MousePosition.X; + HoverState.Y = MousePosition.Y; + } + } + else { + HitTest ht; + IntPtr dummy; + int screen_x; + int screen_y; + + #if DriverDebugExtra + Console.WriteLine("GetMessage(): non-client area {0:X} MotionNotify x={1} y={2}", + client ? hwnd.ClientWindow.ToInt32() : hwnd.WholeWindow.ToInt32(), + xevent.MotionEvent.x, xevent.MotionEvent.y); + #endif + msg.message = Msg.WM_NCMOUSEMOVE; + + if (!hwnd.Enabled) { + RedirectMsgToEnabledAncestor (hwnd, msg, xevent.AnyEvent.window, + ref xevent.MotionEvent.x, ref xevent.MotionEvent.y); + } + + // The hit test is sent in screen coordinates + Xlib.XTranslateCoordinates (display, xevent.AnyEvent.window, RootWindow.Handle, + xevent.MotionEvent.x, xevent.MotionEvent.y, + out screen_x, out screen_y, out dummy); + + msg.lParam = (IntPtr) (screen_y << 16 | screen_x & 0xFFFF); + ht = (HitTest)NativeWindow.WndProc (hwnd.ClientWindow, Msg.WM_NCHITTEST, + IntPtr.Zero, msg.lParam).ToInt32 (); + NativeWindow.WndProc(hwnd.ClientWindow, Msg.WM_SETCURSOR, msg.hwnd, (IntPtr)ht); + + MousePosition.X = xevent.MotionEvent.x; + MousePosition.Y = xevent.MotionEvent.y; + } + + return true; + + case XEventName.EnterNotify: + if (!hwnd.Enabled) + goto ProcessNextMessage; + + if (xevent.CrossingEvent.mode != NotifyMode.NotifyNormal) + goto ProcessNextMessage; + + msg.message = Msg.WM_MOUSE_ENTER; + HoverState.X = xevent.CrossingEvent.x; + HoverState.Y = xevent.CrossingEvent.y; + HoverState.Timer.Enabled = true; + HoverState.Window = xevent.CrossingEvent.window; + + return true; + + case XEventName.LeaveNotify: + if (!hwnd.Enabled) + goto ProcessNextMessage; + + if ((xevent.CrossingEvent.mode != NotifyMode.NotifyNormal) || + (xevent.CrossingEvent.window != hwnd.ClientWindow)) + goto ProcessNextMessage; + + msg.message=Msg.WM_MOUSELEAVE; + HoverState.Timer.Enabled = false; + HoverState.Window = IntPtr.Zero; + + return true; + + case XEventName.ReparentNotify: + if (hwnd.parent == null) { // Toplevel + if ((xevent.ReparentEvent.parent != IntPtr.Zero) && (xevent.ReparentEvent.window == hwnd.WholeWindow)) { + // We need to adjust x/y + // This sucks ass, part 2 + // Every WM does the reparenting of toplevel windows different, so there's + // no standard way of getting our adjustment considering frames/decorations + // The code below is needed for metacity. KDE doesn't works just fine without this + int dummy_int; + IntPtr dummy_ptr; + int new_x; + int new_y; + int frame_left; + int frame_top; + + hwnd.Reparented = true; + + Xlib.XGetGeometry(display, XGetParent(hwnd.WholeWindow), + out dummy_ptr, out new_x, out new_y, + out dummy_int, out dummy_int, out dummy_int, out dummy_int); + hwnd.FrameExtents(out frame_left, out frame_top); + if ((frame_left != 0) && (frame_top != 0) && (new_x != frame_left) && (new_y != frame_top)) { + hwnd.x = new_x; + hwnd.y = new_y; + hwnd.whacky_wm = true; + } + + if (hwnd.opacity != 0xffffffff) { + IntPtr opacity; + + opacity = (IntPtr)(Int32)hwnd.opacity; + Xlib.XChangeProperty (display, XGetParent(hwnd.WholeWindow), + Atoms._NET_WM_WINDOW_OPACITY, Atoms.XA_CARDINAL, 32, + PropertyMode.Replace, ref opacity, 1); + } + SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, msg.wParam, msg.lParam); + goto ProcessNextMessage; + } else { + hwnd.Reparented = false; + goto ProcessNextMessage; + } + } + goto ProcessNextMessage; + + case XEventName.ConfigureNotify: + hwnd.HandleConfigureNotify (xevent); + goto ProcessNextMessage; + + case XEventName.MapNotify: { + if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { // Ignore events for children (SubstructureNotify) and client areas + hwnd.Mapped = true; + msg.message = Msg.WM_SHOWWINDOW; + msg.wParam = (IntPtr) 1; + // XXX we're missing the lParam.. + break; + } + goto ProcessNextMessage; + } + + case XEventName.UnmapNotify: { + if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { // Ignore events for children (SubstructureNotify) and client areas + hwnd.Mapped = false; + msg.message = Msg.WM_SHOWWINDOW; + msg.wParam = (IntPtr) 0; + // XXX we're missing the lParam.. + break; + } + goto ProcessNextMessage; + } + + case XEventName.FocusIn: + // We received focus. We use X11 focus only to know if the app window does or does not have focus + // We do not track the actual focussed window via it. Instead, this is done via FocusWindow internally + // Receiving focus means we've gotten activated and therefore we need to let the actual FocusWindow know + // about it having focus again + if (xevent.FocusChangeEvent.detail != NotifyDetail.NotifyNonlinear) + goto ProcessNextMessage; + + if (FocusWindow == null) { + Widget c = Widget.FromHandle (hwnd.ClientWindow); + if (c == null) + goto ProcessNextMessage; + Form form = c.FindForm (); + if (form == null) + goto ProcessNextMessage; + X11Hwnd new_active = (X11Hwnd)Hwnd.ObjectFromHandle (form.Handle); + if (ActiveWindow != new_active) { + ActiveWindow = new_active; + SendMessage (ActiveWindow.Handle, Msg.WM_ACTIVATE, (IntPtr) WindowActiveFlags.WA_ACTIVE, IntPtr.Zero); + } + goto ProcessNextMessage; + } + Keyboard.FocusIn(FocusWindow.Handle); + SendMessage(FocusWindow.Handle, Msg.WM_SETFOCUS, IntPtr.Zero, IntPtr.Zero); + goto ProcessNextMessage; + + case XEventName.FocusOut: + // Se the comment for our FocusIn handler + if (xevent.FocusChangeEvent.detail != NotifyDetail.NotifyNonlinear) + goto ProcessNextMessage; + + if (FocusWindow == null) + goto ProcessNextMessage; + + Keyboard.FocusOut(FocusWindow.Handle); + + while (Keyboard.ResetKeyState(FocusWindow.Handle, ref msg)) + SendMessage(FocusWindow.Handle, msg.message, msg.wParam, msg.lParam); + + SendMessage(FocusWindow.Handle, Msg.WM_KILLFOCUS, IntPtr.Zero, IntPtr.Zero); + goto ProcessNextMessage; + + case XEventName.Expose: + if (!hwnd.Mapped) { + hwnd.PendingExpose = hwnd.PendingNCExpose = false; + continue; + } + + msg.hwnd = hwnd.Handle; + + if (client) { +#if DriverDebugExtra + Console.WriteLine("GetMessage(): Window {0:X} Exposed area {1},{2} {3}x{4}", + hwnd.client_window.ToInt32(), + xevent.ExposeEvent.x, xevent.ExposeEvent.y, + xevent.ExposeEvent.width, xevent.ExposeEvent.height); +#endif + msg.message = Msg.WM_PAINT; + } + else { + Graphics g; + + switch (hwnd.border_style) { + case FormBorderStyle.Fixed3D: + g = Graphics.FromHwnd(hwnd.WholeWindow); + WidgetPaint.DrawBorder3D(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), + Border3DStyle.Sunken); + g.Dispose(); + break; + + case FormBorderStyle.FixedSingle: + g = Graphics.FromHwnd(hwnd.WholeWindow); + WidgetPaint.DrawBorder(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), + Color.Black, ButtonBorderStyle.Solid); + g.Dispose(); + break; + } +#if DriverDebugExtra + Console.WriteLine("GetMessage(): Window {0:X} Exposed non-client area {1},{2} {3}x{4}", + hwnd.ClientWindow.ToInt32(), + xevent.ExposeEvent.x, xevent.ExposeEvent.y, + xevent.ExposeEvent.width, xevent.ExposeEvent.height); +#endif + + Rectangle rect = new Rectangle (xevent.ExposeEvent.x, xevent.ExposeEvent.y, + xevent.ExposeEvent.width, xevent.ExposeEvent.height); + Region region = new Region (rect); + IntPtr hrgn = region.GetHrgn (null); // Graphics object isn't needed + msg.message = Msg.WM_NCPAINT; + msg.wParam = hrgn == IntPtr.Zero ? (IntPtr)1 : hrgn; + msg.refobject = region; + } + + return true; + + case XEventName.DestroyNotify: + + // This is a bit tricky, we don't receive our own DestroyNotify, we only get those for our children + hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(xevent.DestroyWindowEvent.window); + + // We may get multiple for the same window, act only one the first (when Hwnd still knows about it) + if ((hwnd != null) && (hwnd.ClientWindow == xevent.DestroyWindowEvent.window)) { + CleanupCachedWindows (hwnd); + + #if DriverDebugDestroy + Console.WriteLine("Received X11 Destroy Notification for {0}", XplatUI.Window(hwnd.ClientWindow)); + #endif + + msg.hwnd = hwnd.ClientWindow; + msg.message=Msg.WM_DESTROY; + hwnd.Dispose(); + } + else + goto ProcessNextMessage; + + return true; + + case XEventName.ClientMessage: + if (Dnd.HandleClientMessage (ref xevent)) + goto ProcessNextMessage; + + if (xevent.ClientMessageEvent.message_type == Atoms.AsyncAtom) { + XplatUIDriverSupport.ExecuteClientMessage((GCHandle)xevent.ClientMessageEvent.ptr1); + goto ProcessNextMessage; + } + + if (xevent.ClientMessageEvent.message_type == HoverState.Atom) { + msg.message = Msg.WM_MOUSEHOVER; + msg.wParam = GetMousewParam(0); + msg.lParam = (IntPtr) (xevent.ClientMessageEvent.ptr1); + return true; + } + + if (xevent.ClientMessageEvent.message_type == Atoms.PostAtom) { + msg.hwnd = xevent.ClientMessageEvent.ptr1; + msg.message = (Msg) xevent.ClientMessageEvent.ptr2.ToInt32 (); + msg.wParam = xevent.ClientMessageEvent.ptr3; + msg.lParam = xevent.ClientMessageEvent.ptr4; + + // if we posted a WM_QUIT message, make sure we return + // false here as well. + if (msg.message == (Msg)Msg.WM_QUIT) + return false; + else + return true; + } + + if (xevent.ClientMessageEvent.message_type == Atoms._XEMBED) { +#if DriverDebugXEmbed + Console.WriteLine("GOT EMBED MESSAGE {0:X}, detail {1:X}", + xevent.ClientMessageEvent.ptr2.ToInt32(), xevent.ClientMessageEvent.ptr3.ToInt32()); +#endif + + if (xevent.ClientMessageEvent.ptr2.ToInt32() == (int)XEmbedMessage.EmbeddedNotify) { + XSizeHints hints = new XSizeHints(); + IntPtr dummy; + + Xlib.XGetWMNormalHints (display, hwnd.WholeWindow, ref hints, out dummy); + + hwnd.width = hints.max_width; + hwnd.height = hints.max_height; + hwnd.ClientRect = Rectangle.Empty; + SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + } + } + + if (xevent.ClientMessageEvent.message_type == Atoms.WM_PROTOCOLS) { + if (xevent.ClientMessageEvent.ptr1 == Atoms.WM_DELETE_WINDOW) { + msg.message = Msg.WM_CLOSE; + return true; + } + + // We should not get this, but I'll leave the code in case we need it in the future + if (xevent.ClientMessageEvent.ptr1 == Atoms.WM_TAKE_FOCUS) { + goto ProcessNextMessage; + } + } + + goto ProcessNextMessage; + + case XEventName.PropertyNotify: + // The Hwnd's themselves handle this + hwnd.PropertyChanged (xevent); + goto ProcessNextMessage; + } + } while (true); + + msg.hwnd= IntPtr.Zero; + msg.message = Msg.WM_ENTERIDLE; + return true; + } + + [MonoTODO("Implement filtering and PM_NOREMOVE")] + public bool PeekMessage (object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags) + { + X11ThreadQueue queue = (X11ThreadQueue) queue_id; + bool pending; + + if ((flags & (uint)PeekMessageFlags.PM_REMOVE) == 0) { + throw new NotImplementedException("PeekMessage PM_NOREMOVE is not implemented yet"); // FIXME - Implement PM_NOREMOVE flag + } + + try { + queue.Lock (); + pending = false; + if (queue.CountUnlocked > 0) + pending = true; + } + catch { + return false; + } + finally { + queue.Unlock (); + } + + queue.CheckTimers (); + + if (!pending) + return false; + + return GetMessage(queue_id, ref msg, hWnd, wFilterMin, wFilterMax); + } + + public void DoEvents (X11ThreadQueue queue) + { + MSG msg = new MSG (); + + if (OverrideCursorHandle != IntPtr.Zero) + OverrideCursorHandle = IntPtr.Zero; + + queue.DispatchIdle = false; + + while (PeekMessage(queue, ref msg, IntPtr.Zero, 0, 0, (uint)PeekMessageFlags.PM_REMOVE)) { + TranslateMessage (ref msg); + DispatchMessage (ref msg); + } + + queue.DispatchIdle = true; + } + + // double buffering support + public void CreateOffscreenDrawable (IntPtr handle, + int width, int height, + out object offscreen_drawable) + { + IntPtr root_out; + int x_out, y_out, width_out, height_out, border_width_out, depth_out; + + Xlib.XGetGeometry (display, handle, + out root_out, + out x_out, out y_out, + out width_out, out height_out, + out border_width_out, out depth_out); + + IntPtr pixmap = Xlib.XCreatePixmap (display, handle, width, height, depth_out); + + offscreen_drawable = pixmap; + } + + public void DestroyOffscreenDrawable (object offscreen_drawable) + { + Xlib.XFreePixmap (display, (IntPtr)offscreen_drawable); + } + + public Graphics GetOffscreenGraphics (object offscreen_drawable) + { + return Graphics.FromHwnd ((IntPtr) offscreen_drawable); + } + + public void BlitFromOffscreen (IntPtr dest_handle, + Graphics dest_dc, + object offscreen_drawable, + Graphics offscreen_dc, + Rectangle r) + { + XGCValues gc_values; + IntPtr gc; + + gc_values = new XGCValues(); + + gc = Xlib.XCreateGC (display, dest_handle, IntPtr.Zero, ref gc_values); + + Xlib.XCopyArea (display, (IntPtr)offscreen_drawable, dest_handle, + gc, r.X, r.Y, r.Width, r.Height, r.X, r.Y); + + Xlib.XFreeGC (display, gc); + } + + + // reversible screen-level drawing + IntPtr GetReversibleScreenGC (Color backColor) + { + XGCValues gc_values; + IntPtr gc; + uint pixel; + + XColor xcolor = new XColor(); + xcolor.red = (ushort)(backColor.R * 257); + xcolor.green = (ushort)(backColor.G * 257); + xcolor.blue = (ushort)(backColor.B * 257); + Xlib.XAllocColor (display, DefaultColormap, ref xcolor); + pixel = (uint)xcolor.pixel.ToInt32(); + + + gc_values = new XGCValues(); + + gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors; + gc_values.foreground = (IntPtr)pixel; + + gc = Xlib.XCreateGC (display, RootWindow.Handle, new IntPtr ((int) (GCFunction.GCSubwindowMode | GCFunction.GCForeground)), ref gc_values); + Xlib.XSetForeground (display, gc, (UIntPtr)pixel); + Xlib.XSetFunction (display, gc, GXFunction.GXxor); + + return gc; + } + + public void DrawReversibleLine (Point start, Point end, Color backColor) + { + if (backColor.GetBrightness() < 0.5) + backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B); + + IntPtr gc = GetReversibleScreenGC (backColor); + + Xlib.XDrawLine (display, RootWindow.Handle, gc, start.X, start.Y, end.X, end.Y); + + Xlib.XFreeGC (display, gc); + } + + public void FillReversibleRectangle (Rectangle rectangle, Color backColor) + { + if (backColor.GetBrightness() < 0.5) + backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B); + + IntPtr gc = GetReversibleScreenGC (backColor); + + if (rectangle.Width < 0) { + rectangle.X += rectangle.Width; + rectangle.Width = -rectangle.Width; + } + if (rectangle.Height < 0) { + rectangle.Y += rectangle.Height; + rectangle.Height = -rectangle.Height; + } + + Xlib.XFillRectangle (display, RootWindow.Handle, gc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height); + + Xlib.XFreeGC (display, gc); + } + + public void DrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style) + { + if (backColor.GetBrightness() < 0.5) + backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B); + + IntPtr gc = GetReversibleScreenGC (backColor); + + if (rectangle.Width < 0) { + rectangle.X += rectangle.Width; + rectangle.Width = -rectangle.Width; + } + if (rectangle.Height < 0) { + rectangle.Y += rectangle.Height; + rectangle.Height = -rectangle.Height; + } + + int line_width = 1; + GCLineStyle line_style = GCLineStyle.LineSolid; + GCCapStyle cap_style = GCCapStyle.CapButt; + GCJoinStyle join_style = GCJoinStyle.JoinMiter; + + switch (style) { + case FrameStyle.Dashed: + line_style = GCLineStyle.LineOnOffDash; + break; + case FrameStyle.Thick: + line_width = 2; + break; + } + + Xlib.XSetLineAttributes (display, gc, line_width, line_style, cap_style, join_style); + + Xlib.XDrawRectangle (display, RootWindow.Handle, gc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height); + + Xlib.XFreeGC (display, gc); + } + } +} diff --git a/source/ShiftUI/Internal/X11Dnd.cs b/source/ShiftUI/Internal/X11Dnd.cs new file mode 100644 index 0000000..82f6568 --- /dev/null +++ b/source/ShiftUI/Internal/X11Dnd.cs @@ -0,0 +1,1421 @@ +// 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. +// +// Authors: +// Jackson Harper ([email protected]) +// +// NOTE: We have some tests in Test/ShiftUI/DragAndDropTest.cs, which I *highly* recommend +// to run after any change made here, since those tests are interactive, and thus are not part of +// the common tests. +// + + +using System; +using System.IO; +using System.Text; +using System.Drawing; +using System.Threading; +using System.Collections; +using System.Runtime.Serialization; +using System.Runtime.InteropServices; +using System.Runtime.Serialization.Formatters.Binary; + +namespace ShiftUI { + + internal class X11Dnd { + + private enum State { + Accepting, + Dragging + } + + private enum DragState { + None, + Beginning, + Dragging, + Entered + } + + private interface IDataConverter { + void GetData (X11Dnd dnd, IDataObject data, ref XEvent xevent); + void SetData (X11Dnd dnd, object data, ref XEvent xevent); + } + + private delegate void MimeConverter (IntPtr dsp, + IDataObject data, ref XEvent xevent); + + private class MimeHandler { + public string Name; + public string [] Aliases; + public IntPtr Type; + public IntPtr NonProtocol; + public IDataConverter Converter; + + public MimeHandler (string name, IDataConverter converter) : this (name, converter, name) + { + } + + public MimeHandler (string name, IDataConverter converter, params string [] aliases) + { + Name = name; + Converter = converter; + Aliases = aliases; + } + + public override string ToString () + { + return "MimeHandler {" + Name + "}"; + } + } + + private MimeHandler [] MimeHandlers = { +// new MimeHandler ("WCF_DIB"), +// new MimeHandler ("image/gif", new MimeConverter (ImageConverter)), +// new MimeHandler ("text/rtf", new MimeConverter (RtfConverter)), +// new MimeHandler ("text/richtext", new MimeConverter (RtfConverter)), + + new MimeHandler ("text/plain", new TextConverter ()), + new MimeHandler ("text/plain", new TextConverter (), "System.String", DataFormats.Text), + new MimeHandler ("text/html", new HtmlConverter (), DataFormats.Html), + new MimeHandler ("text/uri-list", new UriListConverter (), DataFormats.FileDrop), + new MimeHandler ("application/x-mono-serialized-object", + new SerializedObjectConverter ()) + }; + + private class SerializedObjectConverter : IDataConverter { + + public void GetData (X11Dnd dnd, IDataObject data, ref XEvent xevent) + { + MemoryStream stream = dnd.GetData (ref xevent); + BinaryFormatter bf = new BinaryFormatter (); + + if (stream.Length == 0) + return; + + stream.Seek (0, 0); + object obj = bf.Deserialize (stream); + data.SetData (obj); + } + + public void SetData (X11Dnd dnd, object data, ref XEvent xevent) + { + if (data == null) + return; + + MemoryStream stream = new MemoryStream (); + BinaryFormatter bf = new BinaryFormatter (); + + bf.Serialize (stream, data); + + IntPtr buffer = Marshal.AllocHGlobal ((int) stream.Length); + stream.Seek (0, 0); + + for (int i = 0; i < stream.Length; i++) { + Marshal.WriteByte (buffer, i, (byte) stream.ReadByte ()); + } + + dnd.SetProperty (ref xevent, buffer, (int) stream.Length); + } + } + + private class HtmlConverter : IDataConverter { + + public void GetData (X11Dnd dnd, IDataObject data, ref XEvent xevent) + { + string text = dnd.GetText (ref xevent, false); + if (text == null) + return; + data.SetData (DataFormats.Text, text); + data.SetData (DataFormats.UnicodeText, text); + } + + public void SetData (X11Dnd dnd, object data, ref XEvent xevent) + { + IntPtr buffer; + int len; + string str = data as string; + + if (str == null) + return; + + if (xevent.SelectionRequestEvent.target == (IntPtr)Atom.XA_STRING) { + byte [] bytes = Encoding.ASCII.GetBytes (str); + buffer = Marshal.AllocHGlobal (bytes.Length); + len = bytes.Length; + for (int i = 0; i < len; i++) + Marshal.WriteByte (buffer, i, bytes [i]); + } else { + buffer = Marshal.StringToHGlobalAnsi (str); + len = 0; + while (Marshal.ReadByte (buffer, len) != 0) + len++; + } + + dnd.SetProperty (ref xevent, buffer, len); + + Marshal.FreeHGlobal (buffer); + } + } + + private class TextConverter : IDataConverter { + + public void GetData (X11Dnd dnd, IDataObject data, ref XEvent xevent) + { + string text = dnd.GetText (ref xevent, true); + if (text == null) + return; + data.SetData (DataFormats.Text, text); + data.SetData (DataFormats.UnicodeText, text); + } + + public void SetData (X11Dnd dnd, object data, ref XEvent xevent) + { + IntPtr buffer; + int len; + string str = data as string; + + if (str == null) { + IDataObject dobj = data as IDataObject; + if (dobj == null) + return; + str = (string) dobj.GetData ("System.String", true); + } + + if (xevent.SelectionRequestEvent.target == (IntPtr)Atom.XA_STRING) { + byte [] bytes = Encoding.ASCII.GetBytes (str); + buffer = Marshal.AllocHGlobal (bytes.Length); + len = bytes.Length; + for (int i = 0; i < len; i++) + Marshal.WriteByte (buffer, i, bytes [i]); + } else { + buffer = Marshal.StringToHGlobalAnsi (str); + len = 0; + while (Marshal.ReadByte (buffer, len) != 0) + len++; + } + + dnd.SetProperty (ref xevent, buffer, len); + + Marshal.FreeHGlobal (buffer); + } + } + + private class UriListConverter : IDataConverter { + + public void GetData (X11Dnd dnd, IDataObject data, ref XEvent xevent) + { + string text = dnd.GetText (ref xevent, false); + if (text == null) + return; + + // TODO: Do this in a loop instead of just splitting + ArrayList uri_list = new ArrayList (); + string [] lines = text.Split (new char [] { '\r', '\n' }); + foreach (string line in lines) { + // # is a comment line (see RFC 2483) + if (line.StartsWith ("#")) + continue; + try { + Uri uri = new Uri (line); + uri_list.Add (uri.LocalPath); + } catch { } + } + + string [] l = (string []) uri_list.ToArray (typeof (string)); + if (l.Length < 1) + return; + data.SetData (DataFormats.FileDrop, l); + data.SetData ("FileName", l [0]); + data.SetData ("FileNameW", l [0]); + } + + public void SetData (X11Dnd dnd, object data, ref XEvent xevent) + { + string [] uri_list = data as string []; + + if (uri_list == null) { + IDataObject dobj = data as IDataObject; + if (dobj == null) + return; + uri_list = dobj.GetData (DataFormats.FileDrop, true) as string []; + } + + if (uri_list == null) + return; + + StringBuilder res = new StringBuilder (); + foreach (string uri_str in uri_list) { + Uri uri = new Uri (uri_str); + res.Append (uri.ToString ()); + res.Append ("\r\n"); + } + + IntPtr buffer = Marshal.StringToHGlobalAnsi ((string) res.ToString ()); + int len = 0; + while (Marshal.ReadByte (buffer, len) != 0) + len++; + + dnd.SetProperty (ref xevent, buffer, len); + } + } + + private class DragData { + public IntPtr Window; + public DragState State; + public object Data; + public IntPtr Action; + public IntPtr [] SupportedTypes; + public MouseButtons MouseState; + public DragDropEffects AllowedEffects; + public Point CurMousePos; + + public IntPtr LastWindow; + public IntPtr LastTopLevel; + + public bool WillAccept; + + public void Reset () + { + State = DragState.None; + Data = null; + SupportedTypes = null; + WillAccept = false; + } + } + + // This version seems to be the most common + private static readonly IntPtr [] XdndVersion = new IntPtr [] { new IntPtr (4) }; + + private IntPtr display; + private DragData drag_data; + + private IntPtr XdndAware; + private IntPtr XdndSelection; + private IntPtr XdndEnter; + private IntPtr XdndLeave; + private IntPtr XdndPosition; + private IntPtr XdndDrop; + private IntPtr XdndFinished; + private IntPtr XdndStatus; + private IntPtr XdndTypeList; + private IntPtr XdndActionCopy; + private IntPtr XdndActionMove; + private IntPtr XdndActionLink; + //private IntPtr XdndActionPrivate; + private IntPtr XdndActionList; + //private IntPtr XdndActionDescription; + //private IntPtr XdndActionAsk; + + //private State state; + + private int converts_pending; + private bool position_recieved; + private bool status_sent; + private IntPtr target; + private IntPtr source; + private IntPtr toplevel; + private IDataObject data; + + private Widget Widget; + private int pos_x, pos_y; + private DragDropEffects allowed; + private DragEventArgs drag_event; + + private Cursor CursorNo; + private Cursor CursorCopy; + private Cursor CursorMove; + private Cursor CursorLink; + // check out the TODO below + //private IntPtr CurrentCursorHandle; + + private bool tracking = false; + private bool dropped = false; + private int motion_poll; + //private X11Keyboard keyboard; + + public X11Dnd (IntPtr display, X11Keyboard keyboard) + { + this.display = display; + //this.keyboard = keyboard; + + Init (); + } + + public bool InDrag() + { + if (drag_data == null) + return false; + return drag_data.State != DragState.None; + } + + public void SetAllowDrop (Hwnd hwnd, bool allow) + { + int[] atoms; + + if (hwnd.allow_drop == allow) + return; + + atoms = new int[XdndVersion.Length]; + for (int i = 0; i < XdndVersion.Length; i++) { + atoms[i] = XdndVersion[i].ToInt32(); + } + + XplatUIX11.XChangeProperty (display, hwnd.whole_window, XdndAware, + (IntPtr) Atom.XA_ATOM, 32, + PropertyMode.Replace, atoms, allow ? 1 : 0); + hwnd.allow_drop = allow; + } + + public DragDropEffects StartDrag (IntPtr handle, object data, + DragDropEffects allowed_effects) + { + drag_data = new DragData (); + drag_data.Window = handle; + drag_data.State = DragState.Beginning; + drag_data.MouseState = XplatUIX11.MouseState; + drag_data.Data = data; + drag_data.SupportedTypes = DetermineSupportedTypes (data); + drag_data.AllowedEffects = allowed_effects; + drag_data.Action = ActionFromEffect (allowed_effects); + + if (CursorNo == null) { + // Make sure the cursors are created + CursorNo = new Cursor (Properties.Resources.DnDNo); + CursorCopy = new Cursor (Properties.Resources.DnDCopy); + CursorMove = new Cursor (Properties.Resources.DnDMove); + CursorLink = new Cursor (Properties.Resources.DnDLink); + } + + drag_data.LastTopLevel = IntPtr.Zero; + Widget = null; + + ShiftUI.MSG msg = new MSG(); + object queue_id = XplatUI.StartLoop (Thread.CurrentThread); + + Timer timer = new Timer (); + timer.Tick += new EventHandler (DndTickHandler); + timer.Interval = 100; + + int suc; + drag_data.State = DragState.Dragging; + + suc = XplatUIX11.XSetSelectionOwner (display, XdndSelection, + drag_data.Window, IntPtr.Zero); + + if (suc == 0) { + Console.Error.WriteLine ("Could not take ownership of XdndSelection aborting drag."); + drag_data.Reset (); + return DragDropEffects.None; + } + + drag_data.State = DragState.Dragging; + drag_data.CurMousePos = new Point (); + source = toplevel = target = IntPtr.Zero; + dropped = false; + tracking = true; + motion_poll = -1; + timer.Start (); + + // Send Enter to the window initializing the dnd operation - which initializes the data + SendEnter (drag_data.Window, drag_data.Window, drag_data.SupportedTypes); + drag_data.LastTopLevel = toplevel; + + while (tracking && XplatUI.GetMessage (queue_id, ref msg, IntPtr.Zero, 0, 0)) { + + if (msg.message >= Msg.WM_KEYFIRST && msg.message <= Msg.WM_KEYLAST) { + HandleKeyMessage (msg); + } else { + switch (msg.message) { + case Msg.WM_LBUTTONUP: + case Msg.WM_RBUTTONUP: + case Msg.WM_MBUTTONUP: + if (msg.message == Msg.WM_LBUTTONDOWN && drag_data.MouseState != MouseButtons.Left) + break;; + if (msg.message == Msg.WM_RBUTTONDOWN && drag_data.MouseState != MouseButtons.Right) + break; + if (msg.message == Msg.WM_MBUTTONDOWN && drag_data.MouseState != MouseButtons.Middle) + break; + + HandleButtonUpMsg (); + + // We don't want to dispatch button up neither (Match .Net) + // Thus we have to remove capture by ourselves + RemoveCapture (msg.hwnd); + continue; + case Msg.WM_MOUSEMOVE: + motion_poll = 0; + + drag_data.CurMousePos.X = Widget.LowOrder ((int) msg.lParam.ToInt32 ()); + drag_data.CurMousePos.Y = Widget.HighOrder ((int) msg.lParam.ToInt32 ()); + + HandleMouseOver (); + // We don't want to dispatch mouse move + continue; + } + + XplatUI.DispatchMessage (ref msg); + } + } + + timer.Stop (); + + // If the target is a mwf Widget, return until DragEnter/DragLeave has been fired, + // which means the respective -already sent- dnd ClientMessages have been received and handled. + if (Widget != null) + Application.DoEvents (); + + if (!dropped) + return DragDropEffects.None; + if (drag_event != null) + return drag_event.Effect; + + // Fallback. + return DragDropEffects.None; + } + + private void DndTickHandler (object sender, EventArgs e) + { + // This is to make sure we don't get stuck in a loop if another + // app doesn't finish the DND operation + if (dropped) { + Timer t = (Timer) sender; + if (t.Interval == 500) + tracking = false; + else + t.Interval = 500; + } + + + // If motion_poll is -1, there hasn't been motion at all, so don't simulate motion yet. + // Otherwise if more than 100 milliseconds have lapsed, we assume the pointer is not + // in motion anymore, and we simulate the mouse over operation, like .Net does. + if (motion_poll > 1) + HandleMouseOver (); + else if (motion_poll > -1) + motion_poll++; + } + + // This routines helps us to have a DndEnter/DndLeave fallback when there wasn't any mouse movement + // as .Net does + private void DefaultEnterLeave (object user_data) + { + IntPtr toplevel, window; + int x_root, y_root; + + // The window generating the operation could be a different than the one under pointer + GetWindowsUnderPointer (out window, out toplevel, out x_root, out y_root); + Widget source_Widget = Widget.FromHandle (window); + if (source_Widget == null || !source_Widget.AllowDrop) + return; + + // `data' and other members are already available + Point pos = Widget.MousePosition; + DragEventArgs drag_args = new DragEventArgs (data, 0, pos.X, pos.Y, drag_data.AllowedEffects, DragDropEffects.None); + + source_Widget.DndEnter (drag_args); + if ((drag_args.Effect & drag_data.AllowedEffects) != 0) + source_Widget.DndDrop (drag_args); + else + source_Widget.DndLeave (EventArgs.Empty); + } + + public void HandleButtonUpMsg () + { + if (drag_data.State == DragState.Beginning) { + //state = State.Accepting; + } else if (drag_data.State != DragState.None) { + + if (drag_data.WillAccept) { + + if (QueryContinue (false, DragAction.Drop)) + return; + } else { + + if (QueryContinue (false, DragAction.Cancel)) + return; + + // fallback if no movement was detected, as .net does. + if (motion_poll == -1) + DefaultEnterLeave (drag_data.Data); + } + + drag_data.State = DragState.None; + // WE can't reset the drag data yet as it is still + // most likely going to be used by the SelectionRequest + // handlers + } + + return; + } + + private void RemoveCapture (IntPtr handle) + { + Widget c = MwfWindow (handle); + if (c.InternalCapture) + c.InternalCapture = false; + } + + public bool HandleMouseOver () + { + IntPtr toplevel, window; + int x_root, y_root; + + GetWindowsUnderPointer (out window, out toplevel, out x_root, out y_root); + + if (window != drag_data.LastWindow && drag_data.State == DragState.Entered) { + drag_data.State = DragState.Dragging; + + // TODO: Send a Leave if this is an MWF window + + if (toplevel != drag_data.LastTopLevel) + SendLeave (drag_data.LastTopLevel, toplevel); + } + + drag_data.State = DragState.Entered; + if (toplevel != drag_data.LastTopLevel) { + // Entering a new toplevel window + SendEnter (toplevel, drag_data.Window, drag_data.SupportedTypes); + } else { + // Already in a toplevel window, so send a position + SendPosition (toplevel, drag_data.Window, + drag_data.Action, + x_root, y_root, + IntPtr.Zero); + } + + drag_data.LastTopLevel = toplevel; + drag_data.LastWindow = window; + return true; + } + + void GetWindowsUnderPointer (out IntPtr window, out IntPtr toplevel, out int x_root, out int y_root) + { + toplevel = IntPtr.Zero; + window = XplatUIX11.RootWindowHandle; + + IntPtr root, child; + bool dnd_aware = false; + int x_temp, y_temp; + int mask_return; + int x = x_root = drag_data.CurMousePos.X; + int y = y_root = drag_data.CurMousePos.Y; + + while (XplatUIX11.XQueryPointer (display, window, out root, out child, + out x_temp, out y_temp, out x, out y, out mask_return)) { + + if (!dnd_aware) { + dnd_aware = IsWindowDndAware (window); + if (dnd_aware) { + toplevel = window; + x_root = x_temp; + y_root = y_temp; + } + } + + if (child == IntPtr.Zero) + break; + + window = child; + } + } + + public void HandleKeyMessage (MSG msg) + { + if (VirtualKeys.VK_ESCAPE == (VirtualKeys) msg.wParam.ToInt32()) { + QueryContinue (true, DragAction.Cancel); + } + } + + // return true if the event is handled here + public bool HandleClientMessage (ref XEvent xevent) + { + // most common so we check it first + if (xevent.ClientMessageEvent.message_type == XdndPosition) + return Accepting_HandlePositionEvent (ref xevent); + if (xevent.ClientMessageEvent.message_type == XdndEnter) + return Accepting_HandleEnterEvent (ref xevent); + if (xevent.ClientMessageEvent.message_type == XdndDrop) + return Accepting_HandleDropEvent (ref xevent); + if (xevent.ClientMessageEvent.message_type == XdndLeave) + return Accepting_HandleLeaveEvent (ref xevent); + if (xevent.ClientMessageEvent.message_type == XdndStatus) + return HandleStatusEvent (ref xevent); + if (xevent.ClientMessageEvent.message_type == XdndFinished) + return HandleFinishedEvent (ref xevent); + + return false; + } + + public bool HandleSelectionNotifyEvent (ref XEvent xevent) + { + MimeHandler handler = FindHandler ((IntPtr) xevent.SelectionEvent.target); + if (handler == null) + return false; + if (data == null) + data = new DataObject (); + + handler.Converter.GetData (this, data, ref xevent); + + converts_pending--; + if (converts_pending <= 0 && position_recieved) { + drag_event = new DragEventArgs (data, 0, pos_x, pos_y, + allowed, DragDropEffects.None); + Widget.DndEnter (drag_event); + SendStatus (source, drag_event.Effect); + status_sent = true; + } + return true; + } + + public bool HandleSelectionRequestEvent (ref XEvent xevent) + { + if (xevent.SelectionRequestEvent.selection != XdndSelection) + return false; + + MimeHandler handler = FindHandler (xevent.SelectionRequestEvent.target); + if (handler == null) + return false; + + handler.Converter.SetData (this, drag_data.Data, ref xevent); + + return true; + } + + private bool QueryContinue (bool escape, DragAction action) + { + QueryContinueDragEventArgs qce = new QueryContinueDragEventArgs ((int) XplatUI.State.ModifierKeys, + escape, action); + + Widget c = MwfWindow (source); + + if (c == null) { + tracking = false; + return false; + } + + c.DndContinueDrag (qce); + + switch (qce.Action) { + case DragAction.Continue: + return true; + case DragAction.Drop: + SendDrop (drag_data.LastTopLevel, source, IntPtr.Zero); + tracking = false; + return true; + case DragAction.Cancel: + drag_data.Reset (); + c.InternalCapture = false; + break; + } + + SendLeave (drag_data.LastTopLevel, toplevel); + + RestoreDefaultCursor (); + tracking = false; + return false; + } + + private void RestoreDefaultCursor () + { + // Releasing the mouse buttons should automatically restore the default cursor, + // but canceling the operation using QueryContinue should restore it even if the + // mouse buttons are not released yet. + XplatUIX11.XChangeActivePointerGrab (display, + EventMask.ButtonMotionMask | + EventMask.PointerMotionMask | + EventMask.ButtonPressMask | + EventMask.ButtonReleaseMask, + Cursors.Default.Handle, IntPtr.Zero); + + } + + private void GiveFeedback (IntPtr action) + { + GiveFeedbackEventArgs gfe = new GiveFeedbackEventArgs (EffectFromAction (drag_data.Action), true); + + Widget c = MwfWindow (source); + c.DndFeedback (gfe); + + if (gfe.UseDefaultCursors) { + Cursor cursor = CursorNo; + if (drag_data.WillAccept) { + // Same order as on MS + if (action == XdndActionCopy) + cursor = CursorCopy; + else if (action == XdndActionLink) + cursor = CursorLink; + else if (action == XdndActionMove) + cursor = CursorMove; + } + // TODO: Try not to set the cursor so much + //if (cursor.Handle != CurrentCursorHandle) { + XplatUIX11.XChangeActivePointerGrab (display, + EventMask.ButtonMotionMask | + EventMask.PointerMotionMask | + EventMask.ButtonPressMask | + EventMask.ButtonReleaseMask, + cursor.Handle, IntPtr.Zero); + //CurrentCursorHandle = cursor.Handle; + //} + } + } + + private void SetProperty (ref XEvent xevent, IntPtr data, int length) + { + XEvent sel = new XEvent(); + sel.SelectionEvent.type = XEventName.SelectionNotify; + sel.SelectionEvent.send_event = true; + sel.SelectionEvent.display = display; + sel.SelectionEvent.selection = xevent.SelectionRequestEvent.selection; + sel.SelectionEvent.target = xevent.SelectionRequestEvent.target; + sel.SelectionEvent.requestor = xevent.SelectionRequestEvent.requestor; + sel.SelectionEvent.time = xevent.SelectionRequestEvent.time; + sel.SelectionEvent.property = IntPtr.Zero; + + XplatUIX11.XChangeProperty (display, xevent.SelectionRequestEvent.requestor, + xevent.SelectionRequestEvent.property, + xevent.SelectionRequestEvent.target, + 8, PropertyMode.Replace, data, length); + sel.SelectionEvent.property = xevent.SelectionRequestEvent.property; + + XplatUIX11.XSendEvent (display, xevent.SelectionRequestEvent.requestor, false, + (IntPtr)EventMask.NoEventMask, ref sel); + return; + } + + private void Reset () + { + ResetSourceData (); + ResetTargetData (); + } + + private void ResetSourceData () + { + converts_pending = 0; + data = null; + } + + private void ResetTargetData () + { + position_recieved = false; + status_sent = false; + } + + private bool Accepting_HandleEnterEvent (ref XEvent xevent) + { + Reset (); + + source = xevent.ClientMessageEvent.ptr1; + toplevel = xevent.AnyEvent.window; + target = IntPtr.Zero; + + ConvertData (ref xevent); + + return true; + } + + private bool Accepting_HandlePositionEvent (ref XEvent xevent) + { + pos_x = (int) xevent.ClientMessageEvent.ptr3 >> 16; + pos_y = (int) xevent.ClientMessageEvent.ptr3 & 0xFFFF; + + // Copy is implicitly allowed + Widget source_Widget = MwfWindow (source); + if (source_Widget == null) + allowed = EffectsFromX11Source (source, xevent.ClientMessageEvent.ptr5) | DragDropEffects.Copy; + else + allowed = drag_data.AllowedEffects; + + IntPtr parent, child, new_child, last_drop_child; + parent = XplatUIX11.XRootWindow (display, 0); + child = toplevel; + last_drop_child = IntPtr.Zero; + while (true) { + int xd, yd; + new_child = IntPtr.Zero; + + if (!XplatUIX11.XTranslateCoordinates (display, + parent, child, pos_x, pos_y, + out xd, out yd, out new_child)) + break; + if (new_child == IntPtr.Zero) + break; + child = new_child; + + Hwnd h = Hwnd.ObjectFromHandle (child); + if (h != null) { + Widget d = Widget.FromHandle (h.client_window); + if (d != null && d.allow_drop) + last_drop_child = child; + } + } + + if (last_drop_child != IntPtr.Zero) + child = last_drop_child; + + if (target != child) { + // We have moved into a new Widget + // or into a Widget for the first time + Finish (); + } + target = child; + Hwnd hwnd = Hwnd.ObjectFromHandle (target); + if (hwnd == null) + return true; + + Widget c = Widget.FromHandle (hwnd.client_window); + + if (c == null) + return true; + if (!c.allow_drop) { + SendStatus (source, DragDropEffects.None); + Finish (); + return true; + } + + Widget = c; + position_recieved = true; + + if (converts_pending > 0) + return true; + + if (!status_sent) { + drag_event = new DragEventArgs (data, 0, pos_x, pos_y, + allowed, DragDropEffects.None); + Widget.DndEnter (drag_event); + + SendStatus (source, drag_event.Effect); + status_sent = true; + } else { + drag_event.x = pos_x; + drag_event.y = pos_y; + Widget.DndOver (drag_event); + + SendStatus (source, drag_event.Effect); + } + + return true; + } + + private void Finish () + { + if (Widget != null) { + if (drag_event == null) { + if (data == null) + data = new DataObject (); + drag_event = new DragEventArgs (data, + 0, pos_x, pos_y, + allowed, DragDropEffects.None); + } + Widget.DndLeave (drag_event); + Widget = null; + } + ResetTargetData (); + } + + private bool Accepting_HandleDropEvent (ref XEvent xevent) + { + if (Widget != null && drag_event != null) { + drag_event = new DragEventArgs (data, + 0, pos_x, pos_y, + allowed, drag_event.Effect); + Widget.DndDrop (drag_event); + } + SendFinished (); + return true; + } + + private bool Accepting_HandleLeaveEvent (ref XEvent xevent) + { + if (Widget != null && drag_event != null) + Widget.DndLeave (drag_event); + // Reset (); + return true; + } + + private bool HandleStatusEvent (ref XEvent xevent) + { + if (drag_data != null && drag_data.State == DragState.Entered) { + + if (!QueryContinue (false, DragAction.Continue)) + return true; + + drag_data.WillAccept = ((int) xevent.ClientMessageEvent.ptr2 & 0x1) != 0; + + GiveFeedback (xevent.ClientMessageEvent.ptr5); + } + return true; + } + + private bool HandleFinishedEvent (ref XEvent xevent) + { + return true; + } + + private DragDropEffects EffectsFromX11Source (IntPtr source, IntPtr action_atom) + { + DragDropEffects allowed = DragDropEffects.None; + IntPtr type, count, remaining, data = IntPtr.Zero; + int format; + + XplatUIX11.XGetWindowProperty (display, source, XdndActionList, + IntPtr.Zero, new IntPtr (32), false, (IntPtr) Atom.AnyPropertyType, + out type, out format, out count, out remaining, ref data); + + int intptr_size = Marshal.SizeOf (typeof (IntPtr)); + for (int i = 0; i < count.ToInt32 (); i++) { + IntPtr current_atom = Marshal.ReadIntPtr (data, i * intptr_size); + allowed |= EffectFromAction (current_atom); + } + + // if source is not providing the action list, use the + // default action passed in the x11 dnd position message + if (allowed == DragDropEffects.None) + allowed = EffectFromAction (action_atom); + + return allowed; + } + + private DragDropEffects EffectFromAction (IntPtr action) + { + if (action == XdndActionCopy) + return DragDropEffects.Copy; + else if (action == XdndActionMove) + return DragDropEffects.Move; + if (action == XdndActionLink) + return DragDropEffects.Link; + + return DragDropEffects.None; + } + + private IntPtr ActionFromEffect (DragDropEffects effect) + { + IntPtr action = IntPtr.Zero; + + // We can't OR together actions on XDND so sadly the primary + // is the only one shown here + if ((effect & DragDropEffects.Copy) != 0) + action = XdndActionCopy; + else if ((effect & DragDropEffects.Move) != 0) + action = XdndActionMove; + else if ((effect & DragDropEffects.Link) != 0) + action = XdndActionLink; + return action; + } + + private bool ConvertData (ref XEvent xevent) + { + bool match = false; + + Widget mwfWidget = MwfWindow (source); + + /* To take advantage of the mwfWidget, we have to be sure + that the dnd operation is still happening (since messages are asynchronous) */ + if (mwfWidget != null && drag_data != null) { + if (!tracking) + return false; + + IDataObject dragged = drag_data.Data as IDataObject; + if (dragged != null) { + data = dragged; + } else { + if (data == null) + data = new DataObject (); + SetDataWithFormats (drag_data.Data); + } + return true; + } + + foreach (IntPtr atom in SourceSupportedList (ref xevent)) { + MimeHandler handler = FindHandler (atom); + if (handler == null) + continue; + XplatUIX11.XConvertSelection (display, XdndSelection, handler.Type, + handler.NonProtocol, toplevel, IntPtr.Zero /* CurrentTime */); + converts_pending++; + match = true; + } + return match; + } + + private void SetDataWithFormats (object value) + { + if (value is string) { + data.SetData (DataFormats.Text, value); + data.SetData (DataFormats.UnicodeText, value); + } + + data.SetData (value); + } + + private MimeHandler FindHandler (IntPtr atom) + { + if (atom == IntPtr.Zero) + return null; + foreach (MimeHandler handler in MimeHandlers) { + if (handler.Type == atom) + return handler; + } + return null; + } + + private MimeHandler FindHandler (string name) + { + foreach (MimeHandler handler in MimeHandlers) { + foreach (string alias in handler.Aliases) { + if (alias == name) + return handler; + } + } + return null; + } + + private void SendStatus (IntPtr source, DragDropEffects effect) + { + XEvent xevent = new XEvent (); + + xevent.AnyEvent.type = XEventName.ClientMessage; + xevent.AnyEvent.display = display; + xevent.ClientMessageEvent.window = source; + xevent.ClientMessageEvent.message_type = XdndStatus; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = toplevel; + if (effect != DragDropEffects.None && (effect & allowed) != 0) + xevent.ClientMessageEvent.ptr2 = (IntPtr) 1; + + xevent.ClientMessageEvent.ptr5 = ActionFromEffect (effect); + XplatUIX11.XSendEvent (display, source, false, IntPtr.Zero, ref xevent); + } + + private void SendEnter (IntPtr handle, IntPtr from, IntPtr [] supported) + { + XEvent xevent = new XEvent (); + + xevent.AnyEvent.type = XEventName.ClientMessage; + xevent.AnyEvent.display = display; + xevent.ClientMessageEvent.window = handle; + xevent.ClientMessageEvent.message_type = XdndEnter; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = from; + + // (int) xevent.ClientMessageEvent.ptr2 & 0x1) + // int ptr2 = 0x1; + // xevent.ClientMessageEvent.ptr2 = (IntPtr) ptr2; + // (e)->xclient.data.l[1] = ((e)->xclient.data.l[1] & ~(0xFF << 24)) | ((v) << 24) + xevent.ClientMessageEvent.ptr2 = (IntPtr) ((long)XdndVersion [0] << 24); + + if (supported.Length > 0) + xevent.ClientMessageEvent.ptr3 = supported [0]; + if (supported.Length > 1) + xevent.ClientMessageEvent.ptr4 = supported [1]; + if (supported.Length > 2) + xevent.ClientMessageEvent.ptr5 = supported [2]; + + XplatUIX11.XSendEvent (display, handle, false, IntPtr.Zero, ref xevent); + } + + private void SendDrop (IntPtr handle, IntPtr from, IntPtr time) + { + XEvent xevent = new XEvent (); + + xevent.AnyEvent.type = XEventName.ClientMessage; + xevent.AnyEvent.display = display; + xevent.ClientMessageEvent.window = handle; + xevent.ClientMessageEvent.message_type = XdndDrop; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = from; + xevent.ClientMessageEvent.ptr3 = time; + + XplatUIX11.XSendEvent (display, handle, false, IntPtr.Zero, ref xevent); + dropped = true; + } + + private void SendPosition (IntPtr handle, IntPtr from, IntPtr action, int x, int y, IntPtr time) + { + XEvent xevent = new XEvent (); + + xevent.AnyEvent.type = XEventName.ClientMessage; + xevent.AnyEvent.display = display; + xevent.ClientMessageEvent.window = handle; + xevent.ClientMessageEvent.message_type = XdndPosition; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = from; + xevent.ClientMessageEvent.ptr3 = (IntPtr) ((x << 16) | (y & 0xFFFF)); + xevent.ClientMessageEvent.ptr4 = time; + xevent.ClientMessageEvent.ptr5 = action; + + XplatUIX11.XSendEvent (display, handle, false, IntPtr.Zero, ref xevent); + } + + private void SendLeave (IntPtr handle, IntPtr from) + { + XEvent xevent = new XEvent (); + + xevent.AnyEvent.type = XEventName.ClientMessage; + xevent.AnyEvent.display = display; + xevent.ClientMessageEvent.window = handle; + xevent.ClientMessageEvent.message_type = XdndLeave; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = from; + + XplatUIX11.XSendEvent (display, handle, false, IntPtr.Zero, ref xevent); + } + + private void SendFinished () + { + XEvent xevent = new XEvent (); + + xevent.AnyEvent.type = XEventName.ClientMessage; + xevent.AnyEvent.display = display; + xevent.ClientMessageEvent.window = source; + xevent.ClientMessageEvent.message_type = XdndFinished; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = toplevel; + + XplatUIX11.XSendEvent (display, source, false, IntPtr.Zero, ref xevent); + } + + // There is a somewhat decent amount of overhead + // involved in setting up dnd so we do it lazily + // as a lot of applications do not even use it. + private void Init () + { + XdndAware = XplatUIX11.XInternAtom (display, "XdndAware", false); + XdndEnter = XplatUIX11.XInternAtom (display, "XdndEnter", false); + XdndLeave = XplatUIX11.XInternAtom (display, "XdndLeave", false); + XdndPosition = XplatUIX11.XInternAtom (display, "XdndPosition", false); + XdndStatus = XplatUIX11.XInternAtom (display, "XdndStatus", false); + XdndDrop = XplatUIX11.XInternAtom (display, "XdndDrop", false); + XdndSelection = XplatUIX11.XInternAtom (display, "XdndSelection", false); + XdndFinished = XplatUIX11.XInternAtom (display, "XdndFinished", false); + XdndTypeList = XplatUIX11.XInternAtom (display, "XdndTypeList", false); + XdndActionCopy = XplatUIX11.XInternAtom (display, "XdndActionCopy", false); + XdndActionMove = XplatUIX11.XInternAtom (display, "XdndActionMove", false); + XdndActionLink = XplatUIX11.XInternAtom (display, "XdndActionLink", false); + //XdndActionPrivate = XplatUIX11.XInternAtom (display, "XdndActionPrivate", false); + XdndActionList = XplatUIX11.XInternAtom (display, "XdndActionList", false); + //XdndActionDescription = XplatUIX11.XInternAtom (display, "XdndActionDescription", false); + //XdndActionAsk = XplatUIX11.XInternAtom (display, "XdndActionAsk", false); + + foreach (MimeHandler handler in MimeHandlers) { + handler.Type = XplatUIX11.XInternAtom (display, handler.Name, false); + handler.NonProtocol = XplatUIX11.XInternAtom (display, + String.Concat ("MWFNonP+", handler.Name), false); + } + + } + + private IntPtr [] SourceSupportedList (ref XEvent xevent) + { + IntPtr [] res; + + + if (((int) xevent.ClientMessageEvent.ptr2 & 0x1) == 0) { + res = new IntPtr [3]; + res [0] = xevent.ClientMessageEvent.ptr3; + res [1] = xevent.ClientMessageEvent.ptr4; + res [2] = xevent.ClientMessageEvent.ptr5; + } else { + IntPtr type; + int format; + IntPtr count; + IntPtr remaining; + IntPtr data = IntPtr.Zero; + + XplatUIX11.XGetWindowProperty (display, source, XdndTypeList, + IntPtr.Zero, new IntPtr(32), false, (IntPtr) Atom.XA_ATOM, + out type, out format, out count, + out remaining, ref data); + + res = new IntPtr [count.ToInt32()]; + for (int i = 0; i < count.ToInt32(); i++) { + res [i] = (IntPtr) Marshal.ReadInt32 (data, i * + Marshal.SizeOf (typeof (int))); + } + + XplatUIX11.XFree (data); + } + + return res; + } + + private string GetText (ref XEvent xevent, bool unicode) + { + int nread = 0; + IntPtr nitems; + IntPtr bytes_after; + + StringBuilder builder = new StringBuilder (); + do { + IntPtr actual_type; + int actual_fmt; + IntPtr data = IntPtr.Zero; + + if (0 != XplatUIX11.XGetWindowProperty (display, + xevent.AnyEvent.window, + (IntPtr) xevent.SelectionEvent.property, + IntPtr.Zero, new IntPtr(0xffffff), false, + (IntPtr) Atom.AnyPropertyType, out actual_type, + out actual_fmt, out nitems, out bytes_after, + ref data)) { + XplatUIX11.XFree (data); + break; + } + + if (unicode) + builder.Append (Marshal.PtrToStringUni (data)); + else + builder.Append (Marshal.PtrToStringAnsi (data)); + nread += nitems.ToInt32(); + + XplatUIX11.XFree (data); + } while (bytes_after.ToInt32() > 0); + if (nread == 0) + return null; + return builder.ToString (); + } + + private MemoryStream GetData (ref XEvent xevent) + { + int nread = 0; + IntPtr nitems; + IntPtr bytes_after; + + MemoryStream res = new MemoryStream (); + do { + IntPtr actual_type; + int actual_fmt; + IntPtr data = IntPtr.Zero; + + if (0 != XplatUIX11.XGetWindowProperty (display, + xevent.AnyEvent.window, + (IntPtr) xevent.SelectionEvent.property, + IntPtr.Zero, new IntPtr(0xffffff), false, + (IntPtr) Atom.AnyPropertyType, out actual_type, + out actual_fmt, out nitems, out bytes_after, + ref data)) { + XplatUIX11.XFree (data); + break; + } + + for (int i = 0; i < nitems.ToInt32(); i++) + res.WriteByte (Marshal.ReadByte (data, i)); + nread += nitems.ToInt32(); + + XplatUIX11.XFree (data); + } while (bytes_after.ToInt32() > 0); + return res; + } + + private Widget MwfWindow (IntPtr window) + { + Hwnd hwnd = Hwnd.ObjectFromHandle (window); + if (hwnd == null) + return null; + + Widget res = Widget.FromHandle (hwnd.client_window); + + if (res == null) + res = Widget.FromHandle (window); + + return res; + } + + private bool IsWindowDndAware (IntPtr handle) + { + bool res = true; + // Check the version number, we need greater than 3 + IntPtr actual; + int format; + IntPtr count; + IntPtr remaining; + IntPtr data = IntPtr.Zero; + + XplatUIX11.XGetWindowProperty (display, handle, XdndAware, IntPtr.Zero, new IntPtr(0x8000000), false, + (IntPtr) Atom.XA_ATOM, out actual, out format, + out count, out remaining, ref data); + + if (actual != (IntPtr) Atom.XA_ATOM || format != 32 || + count.ToInt32() == 0 || data == IntPtr.Zero) { + if (data != IntPtr.Zero) + XplatUIX11.XFree (data); + return false; + } + + int version = Marshal.ReadInt32 (data, 0); + + if (version < 3) { + Console.Error.WriteLine ("XDND Version too old (" + version + ")."); + XplatUIX11.XFree (data); + return false; + } + + // First type is actually the XDND version + if (count.ToInt32() > 1) { + res = false; + for (int i = 1; i < count.ToInt32(); i++) { + IntPtr type = (IntPtr) Marshal.ReadInt32 (data, i * + Marshal.SizeOf (typeof (int))); + for (int j = 0; j < drag_data.SupportedTypes.Length; j++) { + if (drag_data.SupportedTypes [j] == type) { + res = true; + break; + } + } + } + } + + XplatUIX11.XFree (data); + return res; + } + + private IntPtr [] DetermineSupportedTypes (object data) + { + ArrayList res = new ArrayList (); + + if (data is string) { + MimeHandler handler = FindHandler ("text/plain"); + if (handler != null) + res.Add (handler.Type); + }/* else if (data is Bitmap) + res.Add (data); + + */ + + IDataObject data_object = data as IDataObject; + if (data_object != null) { + foreach (string format in data_object.GetFormats (true)) { + MimeHandler handler = FindHandler (format); + if (handler != null && !res.Contains (handler.Type)) + res.Add (handler.Type); + } + } + + if (data is ISerializable) { + MimeHandler handler = FindHandler ("application/x-mono-serialized-object"); + if (handler != null) + res.Add (handler.Type); + } + + return (IntPtr []) res.ToArray (typeof (IntPtr)); + } + } +} diff --git a/source/ShiftUI/Internal/X11Exception.cs b/source/ShiftUI/Internal/X11Exception.cs new file mode 100644 index 0000000..5d3d47e --- /dev/null +++ b/source/ShiftUI/Internal/X11Exception.cs @@ -0,0 +1,87 @@ +// 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) 2006 Novell, Inc. (http://www.novell.com) +// +// + +using System; +using System.Text; +using System.Threading; +using ShiftUI; + +namespace ShiftUI.X11Internal { + + internal class X11Exception : ApplicationException { + IntPtr Display; + IntPtr ResourceID; + IntPtr Serial; + XRequest RequestCode; + byte ErrorCode; + byte MinorCode; + + public X11Exception (IntPtr Display, IntPtr ResourceID, IntPtr Serial, byte ErrorCode, XRequest RequestCode, byte MinorCode) + { + this.Display = Display; + this.ResourceID = ResourceID; + this.Serial = Serial; + this.RequestCode = RequestCode; + this.ErrorCode = ErrorCode; + this.MinorCode = MinorCode; + } + + public override string Message { + get { + return GetMessage (Display, ResourceID, Serial, ErrorCode, RequestCode, MinorCode); + } + } + + public static string GetMessage (IntPtr Display, IntPtr ResourceID, IntPtr Serial, byte ErrorCode, XRequest RequestCode, byte MinorCode) + { + StringBuilder sb; + string x_error_text; + string error; + string hwnd_text; + string Widget_text; + Hwnd hwnd; + Widget c; + + sb = new StringBuilder(160); + Xlib.XGetErrorText (Display, ErrorCode, sb, sb.Capacity); + x_error_text = sb.ToString(); + hwnd = Hwnd.ObjectFromHandle(ResourceID); + if (hwnd != null) { + hwnd_text = hwnd.ToString(); + c = Widget.FromHandle(hwnd.Handle); + if (c != null) { + Widget_text = c.ToString(); + } else { + Widget_text = String.Format("<handle {0:X} non-existant>", hwnd.Handle); + } + } + else { + hwnd_text = "<null>"; + Widget_text = "<null>"; + } + + error = String.Format("\n Error: {0}\n Request: {1:D} ({2})\n Resource ID: 0x{3:X}\n Serial: {4}\n Hwnd: {5}\n Widget: {6}", x_error_text, RequestCode, RequestCode, ResourceID.ToInt32(), Serial, hwnd_text, Widget_text); + return error; + } + } +} diff --git a/source/ShiftUI/Internal/X11Hwnd.cs b/source/ShiftUI/Internal/X11Hwnd.cs new file mode 100644 index 0000000..0ef248d --- /dev/null +++ b/source/ShiftUI/Internal/X11Hwnd.cs @@ -0,0 +1,1750 @@ +// 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) 2006 Novell, Inc. (http://www.novell.com) +// +// + +using System; +using System.Collections; +using System.Drawing; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; +using ShiftUI; + +namespace ShiftUI.X11Internal { + + internal class X11Hwnd : Hwnd + { + X11Display display; + + bool refetch_window_type = true; + bool refetch_window_opacity = true; + + IntPtr[] wm_state = new IntPtr[0]; + IntPtr[] window_type = new IntPtr[0]; + double trans = 1.0; + + string text; + new X11ThreadQueue queue; + + const EventMask SelectInputMask = (EventMask.ButtonPressMask | + EventMask.ButtonReleaseMask | + EventMask.KeyPressMask | + EventMask.KeyReleaseMask | + EventMask.EnterWindowMask | + EventMask.LeaveWindowMask | + EventMask.ExposureMask | + EventMask.FocusChangeMask | + EventMask.PointerMotionMask | + EventMask.SubstructureNotifyMask); + + public X11Hwnd (X11Display display) + { + this.display = display; + Queue = XplatUIX11_new.GetInstance().ThreadQueue(Thread.CurrentThread); + } + + public X11Hwnd (X11Display display, IntPtr handle) : this (display) + { + if (handle == IntPtr.Zero) + throw new ArgumentNullException ("handle"); + WholeWindow = ClientWindow = handle; + } + + // XXX this needs to be here so we don't have to + // change Hwnd. once we land, remove this and make + // Hwnd.Queue virtual or abstract + public new X11ThreadQueue Queue { + get { return queue; } + set { queue = value; } + } + + public virtual void CreateWindow (CreateParams cp) + { + if (WholeWindow != IntPtr.Zero || ClientWindow != IntPtr.Zero) + throw new Exception ("createwindow called a second time on live X11Hwnd"); + + XSetWindowAttributes Attributes; + int x; + int y; + int width; + int height; + IntPtr ParentHandle; + SetWindowValuemask ValueMask; + + Attributes = new XSetWindowAttributes(); + x = cp.X; + y = cp.Y; + width = cp.Width; + height = cp.Height; + initial_ex_style = (WindowExStyles) cp.ExStyle; + + /* Figure out our parent handle */ + if (cp.Parent != IntPtr.Zero) + // the parent handle is specified in the CreateParams + ParentHandle = Hwnd.ObjectFromHandle(cp.Parent).ClientWindow; + else if (StyleSet (cp.Style, WindowStyles.WS_CHILD)) + // a child Widget with an unassigned parent gets created under the FosterParent + ParentHandle = display.FosterParent.Handle; + else + // for all other cases, the parent is the root window + ParentHandle = display.RootWindow.Handle; + + ValueMask = SetWindowValuemask.BitGravity | SetWindowValuemask.WinGravity; + + Attributes.bit_gravity = Gravity.NorthWestGravity; + Attributes.win_gravity = Gravity.NorthWestGravity; + + // Save what's under the toolwindow + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + Attributes.save_under = true; + ValueMask |= SetWindowValuemask.SaveUnder; + } + + // If we're a popup without caption we override the WM + if (StyleSet (cp.Style, WindowStyles.WS_POPUP) && !StyleSet (cp.Style, WindowStyles.WS_CAPTION)) { + Attributes.override_redirect = true; + ValueMask |= SetWindowValuemask.OverrideRedirect; + } + + // Default position on screen, if window manager doesn't place us somewhere else + if (!StyleSet (cp.Style, WindowStyles.WS_CHILD) + && !StyleSet (cp.Style, WindowStyles.WS_POPUP)) { + if (x<0) x = 50; + if (y<0) y = 50; + } + // minimum width/height + if (width<1) width=1; + if (height<1) height=1; + + X = x; + Y = y; + Width = width; + Height = height; + Parent = Hwnd.ObjectFromHandle (cp.Parent); + + Enabled = !StyleSet (cp.Style, WindowStyles.WS_DISABLED); + + ClientWindow = IntPtr.Zero; + + WholeWindow = Xlib.XCreateWindow (display.Handle, ParentHandle, + X, Y, Width, Height, 0, + (int)CreateWindowArgs.CopyFromParent, (int)CreateWindowArgs.InputOutput, + IntPtr.Zero, new UIntPtr ((uint)ValueMask), ref Attributes); + if (WholeWindow == IntPtr.Zero) + throw new Exception ("Coult not create X11 nc window"); + + ValueMask &= ~(SetWindowValuemask.OverrideRedirect | SetWindowValuemask.SaveUnder); + + if (display.CustomVisual != IntPtr.Zero && display.CustomColormap != IntPtr.Zero) { + ValueMask |= SetWindowValuemask.ColorMap; + Attributes.colormap = display.CustomColormap; + } + + ClientWindow = Xlib.XCreateWindow (display.Handle, WholeWindow, + ClientRect.X, ClientRect.Y, ClientRect.Width, ClientRect.Height, 0, + (int)CreateWindowArgs.CopyFromParent, (int)CreateWindowArgs.InputOutput, + display.CustomVisual, new UIntPtr ((uint)ValueMask), ref Attributes); + + if (ClientWindow == IntPtr.Zero) + throw new Exception("Could not create X11 client window"); + +#if DriverDebug || DriverDebugCreate + Console.WriteLine("Created window {0:X} / {1:X} parent {2:X}, Style {3}, ExStyle {4}", ClientWindow.ToInt32(), WholeWindow.ToInt32(), Parent != null ? Parent.Handle.ToInt32() : 0, (WindowStyles)cp.Style, (WindowExStyles)cp.ExStyle); +#endif + + if (!StyleSet (cp.Style, WindowStyles.WS_CHILD)) { + if ((X != unchecked((int)0x80000000)) && (Y != unchecked((int)0x80000000))) { + XSizeHints hints; + + hints = new XSizeHints(); + hints.x = X; + hints.y = Y; + hints.flags = (IntPtr)(XSizeHintsFlags.USPosition | XSizeHintsFlags.PPosition); + Xlib.XSetWMNormalHints (display.Handle, WholeWindow, ref hints); + } + } + + Xlib.XSelectInput (display.Handle, WholeWindow, new IntPtr ((int)(SelectInputMask | EventMask.StructureNotifyMask))); + if (WholeWindow != ClientWindow) + Xlib.XSelectInput (display.Handle, ClientWindow, new IntPtr ((int)SelectInputMask)); + + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOPMOST)) { + WINDOW_TYPE = display.Atoms._NET_WM_WINDOW_TYPE_NORMAL; + Xlib.XSetTransientForHint (display.Handle, WholeWindow, display.RootWindow.Handle); + } + + SetWMStyles (cp); + + // set the group leader + XWMHints wm_hints = new XWMHints (); + + wm_hints.flags = (IntPtr)(XWMHintsFlags.InputHint | XWMHintsFlags.StateHint | XWMHintsFlags.WindowGroupHint); + wm_hints.input = !StyleSet (cp.Style, WindowStyles.WS_DISABLED); + wm_hints.initial_state = StyleSet (cp.Style, WindowStyles.WS_MINIMIZE) ? XInitialState.IconicState : XInitialState.NormalState; + wm_hints.window_group = ParentHandle == display.RootWindow.Handle ? ParentHandle : WholeWindow; + + Xlib.XSetWMHints (display.Handle, WholeWindow, ref wm_hints ); + + if (StyleSet (cp.Style, WindowStyles.WS_MINIMIZE)) + SetWindowState (FormWindowState.Minimized); + else if (StyleSet (cp.Style, WindowStyles.WS_MAXIMIZE)) + SetWindowState (FormWindowState.Maximized); + + // for now make all windows dnd enabled + display.Dnd.SetAllowDrop (this, true); + + // Set caption/window title + Text = cp.Caption; + + display.SendMessage (Handle, Msg.WM_CREATE, (IntPtr)1, IntPtr.Zero /* XXX unused */); + SendParentNotify (Msg.WM_CREATE, int.MaxValue, int.MaxValue); + + if (StyleSet (cp.Style, WindowStyles.WS_VISIBLE)) { + visible = true; + Map (); + if (!(Widget.FromHandle(Handle) is Form)) + display.SendMessage (Handle, Msg.WM_SHOWWINDOW, (IntPtr)1, IntPtr.Zero); + } + } + + public virtual void DestroyWindow () + { + if (WholeWindow != IntPtr.Zero) { +#if DriverDebug || DriverDebugDestroy + Console.WriteLine ("XDestroyWindow (whole_window = {0:X})", WholeWindow.ToInt32()); +#endif + Xlib.XDestroyWindow (display.Handle, WholeWindow); + } + else if (ClientWindow != IntPtr.Zero) { +#if DriverDebug || DriverDebugDestroy + Console.WriteLine ("XDestroyWindow (client_window = {0:X})", ClientWindow.ToInt32()); +#endif + Xlib.XDestroyWindow (display.Handle, ClientWindow); + } + } + + public void Activate () + { + if (((IList)display.RootWindow._NET_SUPPORTED).Contains (display.Atoms._NET_ACTIVE_WINDOW)) { + display.SendNetWMMessage (WholeWindow, display.Atoms._NET_ACTIVE_WINDOW, (IntPtr)1, IntPtr.Zero, IntPtr.Zero); + } + else { + Xlib.XRaiseWindow (display.Handle, WholeWindow); + } + } + + public void Update () + { + try { + Queue.Lock (); + if (!Visible || !PendingExpose || !Mapped) + return; + + // XXX this SendMessage call should probably not be inside the lock + display.SendMessage (ClientWindow, Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero); + + PendingExpose = false; + } + finally { + Queue.Unlock (); + } + } + + public void MenuToScreen (ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + IntPtr child; + + Xlib.XTranslateCoordinates (display.Handle, + WholeWindow, display.RootWindow.Handle, + x, y, out dest_x_return, out dest_y_return, out child); + + x = dest_x_return; + y = dest_y_return; + } + + public virtual void PropertyChanged (XEvent xevent) + { + if (xevent.PropertyEvent.atom == display.Atoms._NET_WM_WINDOW_TYPE) { + // we need to recache our WINDOW_TYPE on the next query + refetch_window_type = true; + window_type = null; + } + else if (xevent.PropertyEvent.atom == display.Atoms._NET_WM_STATE) { + // we need to recache our WM_STATE on the next query + } + else if (xevent.PropertyEvent.atom == display.Atoms._NET_WM_NAME) { + // update our Text property + } + else if (xevent.PropertyEvent.atom == display.Atoms._NET_WM_WINDOW_OPACITY) { + // we need to recache our _NET_WM_WINDOW_OPACITY on the next query. + refetch_window_opacity = true; + } + // else we don't care about it + + } + + public void SetIcon (Icon icon) + { + if (icon == null) { + Xlib.XDeleteProperty (display.Handle, WholeWindow, display.Atoms._NET_WM_ICON); + } + else { + Bitmap bitmap; + int size; + IntPtr[] data; + int index; + + bitmap = icon.ToBitmap(); + index = 0; + size = bitmap.Width * bitmap.Height + 2; + data = new IntPtr[size]; + + data[index++] = (IntPtr)bitmap.Width; + data[index++] = (IntPtr)bitmap.Height; + + for (int y = 0; y < bitmap.Height; y++) { + for (int x = 0; x < bitmap.Width; x++) { + data[index++] = (IntPtr)bitmap.GetPixel(x, y).ToArgb(); + } + } + + Xlib.XChangeProperty (display.Handle, WholeWindow, + display.Atoms._NET_WM_ICON, display.Atoms.XA_CARDINAL, 32, + PropertyMode.Replace, data, size); + } + } + + public double GetWindowTransparency () + { + if (refetch_window_opacity) { + trans = 1.0; + + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + + IntPtr w = WholeWindow; + if (reparented) + w = display.XGetParent (WholeWindow); + + Xlib.XGetWindowProperty (display.Handle, w, + display.Atoms._NET_WM_WINDOW_OPACITY, IntPtr.Zero, new IntPtr (16), false, + display.Atoms.XA_CARDINAL, + out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + + if (((long)nitems == 1) && (prop != IntPtr.Zero)) { + uint x11_opacity = (uint)Marshal.ReadInt32(prop, 0); + trans = ((double)x11_opacity) / (uint)0xffffffff; + } + + if (prop != IntPtr.Zero) { + Xlib.XFree(prop); + } + } + + return trans; + } + + public void SetWindowTransparency (double transparency, Color key) + { + IntPtr x11_opacity; + + opacity = (uint)(0xffffffff * transparency); + x11_opacity = (IntPtr)((int)opacity); + + IntPtr w = WholeWindow; + if (reparented) + w = display.XGetParent (WholeWindow); + Xlib.XChangeProperty (display.Handle, w, + display.Atoms._NET_WM_WINDOW_OPACITY, display.Atoms.XA_CARDINAL, 32, + PropertyMode.Replace, ref x11_opacity, 1); + } + + public IntPtr DefWndProc (ref Message msg) + { + switch ((Msg)msg.Msg) { + case Msg.WM_PAINT: + Queue.Lock (); + PendingExpose = false; + Queue.Unlock (); + return IntPtr.Zero; + + case Msg.WM_NCPAINT: + Queue.Lock (); + PendingNCExpose = false; + Queue.Unlock (); + return IntPtr.Zero; + + case Msg.WM_CONTEXTMENU: + if (Parent != null) + display.SendMessage (Parent.ClientWindow, Msg.WM_CONTEXTMENU, msg.WParam, msg.LParam); + return IntPtr.Zero; + + case Msg.WM_MOUSEWHEEL: + if (Parent != null) { + display.SendMessage (Parent.ClientWindow, Msg.WM_MOUSEWHEEL, msg.WParam, msg.LParam); + if (msg.Result == IntPtr.Zero) + return IntPtr.Zero; + } + return IntPtr.Zero; + + case Msg.WM_SETCURSOR: + X11Hwnd parent = (X11Hwnd)Parent; + // Pass to parent window first + while ((parent != null) && (msg.Result == IntPtr.Zero)) { + msg.Result = NativeWindow.WndProc (parent.Handle, Msg.WM_SETCURSOR, msg.HWnd, msg.LParam); + parent = (X11Hwnd)Parent; + } + + if (msg.Result == IntPtr.Zero) { + IntPtr handle; + + switch((HitTest)(msg.LParam.ToInt32() & 0xffff)) { + case HitTest.HTBOTTOM: handle = Cursors.SizeNS.handle; break; + case HitTest.HTBORDER: handle = Cursors.SizeNS.handle; break; + case HitTest.HTBOTTOMLEFT: handle = Cursors.SizeNESW.handle; break; + case HitTest.HTBOTTOMRIGHT: handle = Cursors.SizeNWSE.handle; break; + case HitTest.HTERROR: + if ((msg.LParam.ToInt32() >> 16) == (int)Msg.WM_LBUTTONDOWN) + display.AudibleAlert(); + handle = Cursors.Default.handle; + break; + + case HitTest.HTHELP: handle = Cursors.Help.handle; break; + case HitTest.HTLEFT: handle = Cursors.SizeWE.handle; break; + case HitTest.HTRIGHT: handle = Cursors.SizeWE.handle; break; + case HitTest.HTTOP: handle = Cursors.SizeNS.handle; break; + case HitTest.HTTOPLEFT: handle = Cursors.SizeNWSE.handle; break; + case HitTest.HTTOPRIGHT: handle = Cursors.SizeNESW.handle; break; + +#if SameAsDefault + case HitTest.HTGROWBOX: + case HitTest.HTSIZE: + case HitTest.HTZOOM: + case HitTest.HTVSCROLL: + case HitTest.HTSYSMENU: + case HitTest.HTREDUCE: + case HitTest.HTNOWHERE: + case HitTest.HTMAXBUTTON: + case HitTest.HTMINBUTTON: + case HitTest.HTMENU: + case HitTest.HSCROLL: + case HitTest.HTBOTTOM: + case HitTest.HTCAPTION: + case HitTest.HTCLIENT: + case HitTest.HTCLOSE: +#endif + default: handle = Cursors.Default.handle; break; + } + + display.SetCursor (msg.HWnd, handle); + } + return (IntPtr)1; + + default: + return IntPtr.Zero; + } + } + + + public void AddExpose (bool client, int x, int y, int width, int height) + { + // Don't waste time + if ((x > Width) || (y > Height) || ((x + width) <= 0) || ((y + height) <= 0)) + return; + + // Keep the invalid area as small as needed + if ((x + width) > Width) + width = Width - x; + + if ((y + height) > Height) + height = Height - y; + + if (client) { + AddInvalidArea(x, y, width, height); + PendingExpose = true; + } + else { + AddNcInvalidArea (x, y, width, height); + PendingNCExpose = true; + } + } + + public void AddConfigureNotify (XEvent xevent) + { + // We drop configure events for Client windows + if ((xevent.ConfigureEvent.window != WholeWindow) || (xevent.ConfigureEvent.window != xevent.ConfigureEvent.xevent)) + return; + + if (!reparented) { + X = xevent.ConfigureEvent.x; + Y = xevent.ConfigureEvent.y; + } else { + // This sucks ass, part 1 + // Every WM does the ConfigureEvents of toplevel windows different, so there's + // no standard way of getting our adjustment. + // The code below is needed for KDE and FVWM, the 'whacky_wm' part is for metacity + // Several other WMs do their decorations different yet again and we fail to deal + // with that, since I couldn't find any frigging commonality between them. + // The only sane WM seems to be KDE + + if (!xevent.ConfigureEvent.send_event) { + IntPtr dummy_ptr; + + int trans_x; + int trans_y; + + Xlib.XTranslateCoordinates (display.Handle, WholeWindow, display.RootWindow.Handle, + -xevent.ConfigureEvent.x, -xevent.ConfigureEvent.y, + out trans_x, out trans_y, out dummy_ptr); + + X = trans_x; + Y = trans_y; + } else { + // This is a synthetic event, coordinates are in root space + X = xevent.ConfigureEvent.x; + Y = xevent.ConfigureEvent.y; + if (whacky_wm) { + int frame_left; + int frame_top; + + FrameExtents (out frame_left, out frame_top); + X -= frame_left; + Y -= frame_top; + } + } + } + + Width = xevent.ConfigureEvent.width; + Height = xevent.ConfigureEvent.height; + ClientRect = Rectangle.Empty; + + if (!configure_pending) { + Queue.AddConfigure (this); + configure_pending = true; + } + } + + public void HandleMapEvent (XEvent xevent) + { + if (xevent.type == XEventName.MapNotify) { + } + else { + } + } + + public void HandleConfigureNotify (XEvent xevent) + { + configure_pending = false; + + display.SendMessage (Handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + + // We need to adjust our client window to track the resize of whole_window + if (WholeWindow != ClientWindow) + PerformNCCalc (); + } + + public void Invalidate (Rectangle rc, bool clear) + { + if (clear) { + AddExpose (true, X, Y, Width, Height); + } else { + AddExpose (true, rc.X, rc.Y, rc.Width, rc.Height); + } + } + + public void InvalidateNC () + { + AddExpose (false, 0, 0, Width, Height); + } + + // XXX this assumes the queue lock is held + public bool PendingNCExpose { + get { return nc_expose_pending; } + set { + if (nc_expose_pending == value) + return; + nc_expose_pending = value; + + if (nc_expose_pending && !expose_pending) + Queue.AddPaint (this); + else if (!nc_expose_pending && !expose_pending) + Queue.RemovePaint (this); + } + } + + // XXX this assumes the queue lock is held + public bool PendingExpose { + get { return expose_pending; } + set { + if (expose_pending == value) + return; + expose_pending = value; + + if (expose_pending && !nc_expose_pending) + Queue.AddPaint (this); + else if (!expose_pending && !nc_expose_pending) + Queue.RemovePaint (this); + } + } + + public PaintEventArgs PaintEventStart (ref Message m, bool client) + { + PaintEventArgs paint_event; + Graphics dc; + + if (client) { + dc = Graphics.FromHwnd (ClientWindow); + + Region clip_region = new Region (); + clip_region.MakeEmpty(); + + foreach (Rectangle r in ClipRectangles) + clip_region.Union (r); + + if (UserClip != null) + clip_region.Intersect(UserClip); + + dc.Clip = clip_region; + paint_event = new PaintEventArgs(dc, Invalid); + PendingExpose = false; + + ClearInvalidArea(); + + drawing_stack.Push (paint_event); + drawing_stack.Push (dc); + + return paint_event; + } + else { + dc = Graphics.FromHwnd (WholeWindow); + + if (!nc_invalid.IsEmpty) { + dc.SetClip (nc_invalid); + paint_event = new PaintEventArgs(dc, nc_invalid); + } + else { + paint_event = new PaintEventArgs(dc, new Rectangle(0, 0, width, height)); + } + PendingNCExpose = false; + + ClearNcInvalidArea (); + + drawing_stack.Push (paint_event); + drawing_stack.Push (dc); + + return paint_event; + } + } + + public void PaintEventEnd (ref Message m, bool client) + { + Graphics dc = (Graphics)drawing_stack.Pop (); + dc.Flush(); + dc.Dispose(); + + PaintEventArgs pe = (PaintEventArgs)drawing_stack.Pop(); + pe.SetGraphics (null); + pe.Dispose (); + } + + public void DrawReversibleRectangle (Rectangle rect, int line_width) + { + XGCValues gc_values; + IntPtr gc; + + gc_values = new XGCValues (); + + gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors; + gc_values.line_width = line_width; + + // XXX multiscreen support + gc_values.foreground = Xlib.XBlackPixel (display.Handle, display.DefaultScreen); + + // This logic will give us true rubber bands: (libsx, SANE_XOR) + //mask = foreground ^ background; + //XSetForeground(DisplayHandle, gc, 0xffffffff); + //XSetBackground(DisplayHandle, gc, background); + //XSetFunction(DisplayHandle, gc, GXxor); + //XSetPlaneMask(DisplayHandle, gc, mask); + + + gc = Xlib.XCreateGC (display.Handle, ClientWindow, + new IntPtr ((int) (GCFunction.GCSubwindowMode | GCFunction.GCLineWidth | GCFunction.GCForeground)), ref gc_values); + uint foreground; + uint background; + + Widget Widget; + Widget = Widget.FromHandle(Handle); + + XColor xcolor = new XColor(); + + xcolor.red = (ushort)(Widget.ForeColor.R * 257); + xcolor.green = (ushort)(Widget.ForeColor.G * 257); + xcolor.blue = (ushort)(Widget.ForeColor.B * 257); + Xlib.XAllocColor (display.Handle, display.DefaultColormap, ref xcolor); + foreground = (uint)xcolor.pixel.ToInt32(); + + xcolor.red = (ushort)(Widget.BackColor.R * 257); + xcolor.green = (ushort)(Widget.BackColor.G * 257); + xcolor.blue = (ushort)(Widget.BackColor.B * 257); + Xlib.XAllocColor (display.Handle, display.DefaultColormap, ref xcolor); + background = (uint)xcolor.pixel.ToInt32(); + + uint mask = foreground ^ background; + + Xlib.XSetForeground (display.Handle, gc, (UIntPtr)0xffffffff); + Xlib.XSetBackground (display.Handle, gc, (UIntPtr)background); + Xlib.XSetFunction (display.Handle, gc, GXFunction.GXxor); + Xlib.XSetPlaneMask (display.Handle, gc, (IntPtr)mask); + + if ((rect.Width > 0) && (rect.Height > 0)) + Xlib.XDrawRectangle (display.Handle, ClientWindow, gc, rect.Left, rect.Top, rect.Width, rect.Height); + else if (rect.Width > 0) + Xlib.XDrawLine (display.Handle, ClientWindow, gc, rect.X, rect.Y, rect.Right, rect.Y); + else + Xlib.XDrawLine (display.Handle, ClientWindow, gc, rect.X, rect.Y, rect.X, rect.Bottom); + + Xlib.XFreeGC (display.Handle, gc); + } + + private void WaitForMessage (Msg message) + { + MSG msg = new MSG (); + + queue.DispatchIdle = false; + + bool done = false; + do { + if (display.PeekMessage(queue, ref msg, IntPtr.Zero, 0, 0, (uint)PeekMessageFlags.PM_REMOVE)) { + if ((Msg)msg.message == Msg.WM_QUIT) { + // XXX this should live someplace else + XplatUI.PostQuitMessage (0); + done = true; + } + else { + if ((msg.hwnd == Handle) && + ((Msg)msg.message == message || (Msg)msg.message == Msg.WM_DESTROY)) + done = true; + display.TranslateMessage (ref msg); + display.DispatchMessage (ref msg); + } + } + } while (!done); + + queue.DispatchIdle = true; + } + + public void Map () + { + // FIXME why do we set this here and also in the MapNotify event handling? + if (!mapped) { + + Xlib.XMapWindow (display.Handle, WholeWindow); + Xlib.XMapWindow (display.Handle, ClientWindow); + + mapped = true; + + if (Widget.FromHandle(Handle) is Form) + WaitForMessage (Msg.WM_SHOWWINDOW); + } + } + + public void Unmap () + { + // FIXME why do we set this here and also in the UnmapNotify event handling? + if (mapped) { + Xlib.XUnmapWindow (display.Handle, ClientWindow); + Xlib.XUnmapWindow (display.Handle, WholeWindow); + + mapped = false; + + if (Widget.FromHandle(Handle) is Form) + WaitForMessage (Msg.WM_SHOWWINDOW); + } + } + + public void PerformNCCalc () + { + XplatUIWin32.NCCALCSIZE_PARAMS ncp; + IntPtr ptr; + Rectangle rect; + + rect = DefaultClientRect; + + ncp = new XplatUIWin32.NCCALCSIZE_PARAMS (); + ptr = Marshal.AllocHGlobal (Marshal.SizeOf(ncp)); + + ncp.rgrc1.left = rect.Left; + ncp.rgrc1.top = rect.Top; + ncp.rgrc1.right = rect.Right; + ncp.rgrc1.bottom = rect.Bottom; + + Marshal.StructureToPtr (ncp, ptr, true); + NativeWindow.WndProc (ClientWindow, Msg.WM_NCCALCSIZE, (IntPtr)1, ptr); + ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure (ptr, typeof(XplatUIWin32.NCCALCSIZE_PARAMS)); + Marshal.FreeHGlobal(ptr); + + // FIXME - debug this with Menus + + rect = new Rectangle(ncp.rgrc1.left, ncp.rgrc1.top, ncp.rgrc1.right - ncp.rgrc1.left, ncp.rgrc1.bottom - ncp.rgrc1.top); + ClientRect = rect; + + if (Visible) { + if ((rect.Width < 1) || (rect.Height < 1)) + Xlib.XMoveResizeWindow (display.Handle, ClientWindow, -5, -5, 1, 1); + else + Xlib.XMoveResizeWindow (display.Handle, ClientWindow, rect.X, rect.Y, rect.Width, rect.Height); + } + + InvalidateNC (); + } + + public void RequestNCRecalc () + { + PerformNCCalc (); + display.SendMessage (Handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + InvalidateNC (); + } + + [MonoTODO] + public void RequestAdditionalWM_NCMessages (bool hover, bool leave) + { + // Missing messages won't crash anything so just don't generate them for the moment. + // throw new NotImplementedException( ); + } + + public void FrameExtents (out int left, out int top) + { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + + Xlib.XGetWindowProperty (display.Handle, WholeWindow, + display.Atoms._NET_FRAME_EXTENTS, IntPtr.Zero, new IntPtr (16), false, + display.Atoms.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + if (((long)nitems == 4) && (prop != IntPtr.Zero)) { + left = Marshal.ReadIntPtr(prop, 0).ToInt32(); + //right = Marshal.ReadIntPtr(prop, IntPtr.Size).ToInt32(); + top = Marshal.ReadIntPtr(prop, IntPtr.Size * 2).ToInt32(); + //bottom = Marshal.ReadIntPtr(prop, IntPtr.Size * 3).ToInt32(); + } else { + left = 0; + top = 0; + } + + if (prop != IntPtr.Zero) { + Xlib.XFree(prop); + } + } + + static bool StyleSet (int s, WindowStyles ws) + { + return (s & (int)ws) == (int)ws; + } + + static bool ExStyleSet (int ex, WindowExStyles exws) + { + return (ex & (int)exws) == (int)exws; + } + + // XXX this should be a static method on Hwnd so other backends can use it + public static void DeriveStyles(int Style, int ExStyle, out FormBorderStyle border_style, out bool border_static, + out TitleStyle title_style, out int caption_height, out int tool_caption_height) + { + + // Only MDI windows get caption_heights + caption_height = 0; + tool_caption_height = 19; + border_static = false; + + if (StyleSet (Style, WindowStyles.WS_CHILD)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_CLIENTEDGE)) { + border_style = FormBorderStyle.Fixed3D; + } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_STATICEDGE)) { + border_style = FormBorderStyle.Fixed3D; + border_static = true; + } else if (!StyleSet (Style, WindowStyles.WS_BORDER)) { + border_style = FormBorderStyle.None; + } else { + border_style = FormBorderStyle.FixedSingle; + } + title_style = TitleStyle.None; + + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_MDICHILD)) { + caption_height = 26; + + if (StyleSet (Style, WindowStyles.WS_CAPTION)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) + title_style = TitleStyle.Tool; + else + title_style = TitleStyle.Normal; + } + + if (StyleSet (Style, WindowStyles.WS_OVERLAPPEDWINDOW) || + ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) + border_style = (FormBorderStyle) 0xFFFF; + else + border_style = FormBorderStyle.None; + } + } + else { + title_style = TitleStyle.None; + if (StyleSet (Style, WindowStyles.WS_CAPTION)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) + title_style = TitleStyle.Tool; + else + title_style = TitleStyle.Normal; + } + + border_style = FormBorderStyle.None; + + if (StyleSet (Style, WindowStyles.WS_THICKFRAME)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) + border_style = FormBorderStyle.SizableToolWindow; + else + border_style = FormBorderStyle.Sizable; + } else { + if (StyleSet (Style, WindowStyles.WS_CAPTION)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_CLIENTEDGE)) + border_style = FormBorderStyle.Fixed3D; + else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_STATICEDGE)) { + border_style = FormBorderStyle.Fixed3D; + border_static = true; + } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_DLGMODALFRAME)) + border_style = FormBorderStyle.FixedDialog; + else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) + border_style = FormBorderStyle.FixedToolWindow; + else if (StyleSet (Style, WindowStyles.WS_BORDER)) + border_style = FormBorderStyle.FixedSingle; + } else if (StyleSet (Style, WindowStyles.WS_BORDER)) + border_style = FormBorderStyle.FixedSingle; + } + } + } + + public void SetHwndStyles (CreateParams cp) + { + DeriveStyles(cp.Style, cp.ExStyle, out this.border_style, out this.border_static, out this.title_style, out this.caption_height, out this.tool_caption_height); + } + + public void SetWMStyles (CreateParams cp) + { + MotifWmHints mwmHints; + MotifFunctions functions; + MotifDecorations decorations; + IntPtr[] atoms; + int atom_count; + Rectangle client_rect; + + // Child windows don't need WM window styles + if (StyleSet (cp.Style, WindowStyles.WS_CHILDWINDOW)) + return; + + atoms = new IntPtr[8]; + mwmHints = new MotifWmHints(); + functions = 0; + decorations = 0; + + mwmHints.flags = (IntPtr)(MotifFlags.Functions | MotifFlags.Decorations); + mwmHints.functions = (IntPtr)0; + mwmHints.decorations = (IntPtr)0; + + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW) + || !StyleSet (cp.Style, WindowStyles.WS_CAPTION | WindowStyles.WS_BORDER | WindowStyles.WS_DLGFRAME)) { + /* tool windows get no window manager + decorations, and neither do windows + which lack CAPTION/BORDER/DLGFRAME + styles. + */ + + /* just because the window doesn't get any decorations doesn't + mean we should disable the functions. for instance, without + MotifFunctions.Maximize, changing the windowstate to Maximized + is ignored by metacity. */ + functions |= MotifFunctions.Move | MotifFunctions.Resize | MotifFunctions.Minimize | MotifFunctions.Maximize; + } + else { + if (StyleSet (cp.Style, WindowStyles.WS_CAPTION)) { + functions |= MotifFunctions.Move; + decorations |= MotifDecorations.Title | MotifDecorations.Menu; + } + + if (StyleSet (cp.Style, WindowStyles.WS_THICKFRAME)) { + functions |= MotifFunctions.Move | MotifFunctions.Resize; + decorations |= MotifDecorations.Border | MotifDecorations.ResizeH; + } + + if (StyleSet (cp.Style, WindowStyles.WS_MINIMIZEBOX)) { + functions |= MotifFunctions.Minimize; + decorations |= MotifDecorations.Minimize; + } + + if (StyleSet (cp.Style, WindowStyles.WS_MAXIMIZEBOX)) { + functions |= MotifFunctions.Maximize; + decorations |= MotifDecorations.Maximize; + } + + if (StyleSet (cp.Style, WindowStyles.WS_SIZEBOX)) { + functions |= MotifFunctions.Resize; + decorations |= MotifDecorations.ResizeH; + } + + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_DLGMODALFRAME)) { + decorations |= MotifDecorations.Border; + } + + if (StyleSet (cp.Style, WindowStyles.WS_BORDER)) { + decorations |= MotifDecorations.Border; + } + + if (StyleSet (cp.Style, WindowStyles.WS_DLGFRAME)) { + decorations |= MotifDecorations.Border; + } + + if (StyleSet (cp.Style, WindowStyles.WS_SYSMENU)) { + functions |= MotifFunctions.Close; + } + else { + functions &= ~(MotifFunctions.Maximize | MotifFunctions.Minimize | MotifFunctions.Close); + decorations &= ~(MotifDecorations.Menu | MotifDecorations.Maximize | MotifDecorations.Minimize); + if (cp.Caption == "") { + functions &= ~MotifFunctions.Move; + decorations &= ~(MotifDecorations.Title | MotifDecorations.ResizeH); + } + } + } + + if ((functions & MotifFunctions.Resize) == 0) { + fixed_size = true; + SetMinMax (new Rectangle(cp.X, cp.Y, cp.Width, cp.Height), new Size(cp.Width, cp.Height), new Size(cp.Width, cp.Height)); + } else { + fixed_size = false; + } + + mwmHints.functions = (IntPtr)functions; + mwmHints.decorations = (IntPtr)decorations; + + FormWindowState current_state = GetWindowState (); + if (current_state == (FormWindowState)(-1)) + current_state = FormWindowState.Normal; + + client_rect = ClientRect; + + atom_count = 0; + + // needed! map toolwindows to _NET_WM_WINDOW_TYPE_UTILITY to make newer metacity versions happy + // and get those windows in front of their parents + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + WINDOW_TYPE = display.Atoms._NET_WM_WINDOW_TYPE_UTILITY; + + Form f = Widget.FromHandle(Handle) as Form; + if (f != null && !reparented) { + if (f.Owner != null && f.Owner.Handle != IntPtr.Zero) { + Hwnd owner_hwnd = Hwnd.ObjectFromHandle(f.Owner.Handle); + if (owner_hwnd != null) + Xlib.XSetTransientForHint (display.Handle, WholeWindow, + owner_hwnd.WholeWindow); + } + } + } + + Xlib.XChangeProperty (display.Handle, WholeWindow, + display.Atoms._MOTIF_WM_HINTS, display.Atoms._MOTIF_WM_HINTS, 32, + PropertyMode.Replace, ref mwmHints, 5); + + if (StyleSet (cp.Style, WindowStyles.WS_POPUP) && (parent != null) && (parent.WholeWindow != IntPtr.Zero)) { + WINDOW_TYPE = display.Atoms._NET_WM_WINDOW_TYPE_NORMAL; + Xlib.XSetTransientForHint(display.Handle, WholeWindow, parent.WholeWindow); + } else if (!ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_APPWINDOW)) { + /* this line keeps the window from showing up in gnome's taskbar */ + atoms[atom_count++] = display.Atoms._NET_WM_STATE_SKIP_TASKBAR; + } + if ((client_rect.Width < 1) || (client_rect.Height < 1)) { + Xlib.XMoveResizeWindow (display.Handle, ClientWindow, -5, -5, 1, 1); + } else { + Xlib.XMoveResizeWindow (display.Handle, ClientWindow, client_rect.X, client_rect.Y, client_rect.Width, client_rect.Height); + } + + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) + atoms[atom_count++] = display.Atoms._NET_WM_STATE_SKIP_TASKBAR; + + /* we need to add these atoms in the + * event we're maximized, since we're + * replacing the existing + * _NET_WM_STATE here. If we don't + * add them, future calls to + * GetWindowState will return Normal + * for a window which is maximized. */ + if (current_state == FormWindowState.Maximized) { + atoms[atom_count++] = display.Atoms._NET_WM_STATE_MAXIMIZED_HORZ; + atoms[atom_count++] = display.Atoms._NET_WM_STATE_MAXIMIZED_VERT; + } + + Set_WM_STATE (atoms, atom_count); + + atom_count = 0; + atoms[atom_count++] = display.Atoms.WM_DELETE_WINDOW; + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_CONTEXTHELP)) + atoms[atom_count++] = display.Atoms._NET_WM_CONTEXT_HELP; + + Xlib.XSetWMProtocols (display.Handle, WholeWindow, atoms, atom_count); + } + + public void ClientToScreen (ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + IntPtr child; + + Xlib.XTranslateCoordinates (display.Handle, + ClientWindow, display.RootWindow.Handle, + x, y, out dest_x_return, out dest_y_return, out child); + + x = dest_x_return; + y = dest_y_return; + } + + public void ScreenToClient (ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + IntPtr child; + + Xlib.XTranslateCoordinates (display.Handle, + display.RootWindow.Handle, ClientWindow, + x, y, out dest_x_return, out dest_y_return, out child); + + x = dest_x_return; + y = dest_y_return; + } + + + public void ScreenToMenu (ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + IntPtr child; + + Xlib.XTranslateCoordinates (display.Handle, + display.RootWindow.Handle, WholeWindow, + x, y, out dest_x_return, out dest_y_return, out child); + + x = dest_x_return; + y = dest_y_return; + } + + public void ScrollWindow (Rectangle area, int XAmount, int YAmount, bool with_children) + { + IntPtr gc; + XGCValues gc_values; + + Rectangle r = Rectangle.Intersect (Invalid, area); + if (!r.IsEmpty) { + /* We have an invalid area in the window we're scrolling. + Adjust our stored invalid rectangle to to match the scrolled amount */ + + r.X += XAmount; + r.Y += YAmount; + + if (r.X < 0) { + r.Width += r.X; + r.X =0; + } + + if (r.Y < 0) { + r.Height += r.Y; + r.Y =0; + } + + if (area.Contains (Invalid)) + ClearInvalidArea(); + AddInvalidArea(r); + } + + gc_values = new XGCValues(); + + gc_values.graphics_exposures = false; + if (with_children) + gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors; + + gc = Xlib.XCreateGC (display.Handle, ClientWindow, IntPtr.Zero, ref gc_values); + + int src_x, src_y; + int dest_x, dest_y; + int width, height; + + if (YAmount > 0) { + src_y = area.Y; + height = area.Height - YAmount; + dest_y = area.Y + YAmount; + } + else { + src_y = area.Y - YAmount; + height = area.Height + YAmount; + dest_y = area.Y; + } + + if (XAmount > 0) { + src_x = area.X; + width = area.Width - XAmount; + dest_x = area.X + XAmount; + } + else { + src_x = area.X - XAmount; + width = area.Width + XAmount; + dest_x = area.X; + } + + Xlib.XCopyArea (display.Handle, ClientWindow, ClientWindow, gc, src_x, src_y, width, height, dest_x, dest_y); + + // Generate an expose for the area exposed by the horizontal scroll + // We don't use AddExpose since we're + if (XAmount > 0) { + AddExpose (true, area.X, area.Y, XAmount, area.Height); + } else if (XAmount < 0) { + AddExpose (true, XAmount + area.X + area.Width, area.Y, -XAmount, area.Height); + } + + // Generate an expose for the area exposed by the vertical scroll + if (YAmount > 0) { + AddExpose (true, area.X, area.Y, area.Width, YAmount); + } else if (YAmount < 0) { + AddExpose (true, area.X, YAmount + area.Y + area.Height, area.Width, -YAmount); + } + + Xlib.XFreeGC (display.Handle, gc); + } + + + public void SetBorderStyle (FormBorderStyle border_style) + { + Form form = Widget.FromHandle (Handle) as Form; + if (form != null && form.window_manager == null && (border_style == FormBorderStyle.FixedToolWindow || + border_style == FormBorderStyle.SizableToolWindow)) { + form.window_manager = new ToolWindowManager (form); + } + + BorderStyle = border_style; + RequestNCRecalc (); + } + + // XXX this should probably be in Hwnd + public void SetClipRegion (Region region) + { + UserClip = region; + Invalidate (new Rectangle(0, 0, Width, Height), false); + } + + // XXX this should probably be in Hwnd + public Region GetClipRegion () + { + return UserClip; + } + + public void SetMenu (Menu menu) + { + Menu = menu; + + RequestNCRecalc (); + } + + public void SetMinMax (Rectangle maximized, Size min, Size max) + { + XSizeHints hints; + IntPtr dummy; + + hints = new XSizeHints(); + + Xlib.XGetWMNormalHints (display.Handle, WholeWindow, ref hints, out dummy); + if ((min != Size.Empty) && (min.Width > 0) && (min.Height > 0)) { + hints.flags = (IntPtr)((int)hints.flags | (int)XSizeHintsFlags.PMinSize); + hints.min_width = min.Width; + hints.min_height = min.Height; + } + + if ((max != Size.Empty) && (max.Width > 0) && (max.Height > 0)) { + hints.flags = (IntPtr)((int)hints.flags | (int)XSizeHintsFlags.PMaxSize); + hints.max_width = max.Width; + hints.max_height = max.Height; + } + + if (hints.flags != IntPtr.Zero) + Xlib.XSetWMNormalHints (display.Handle, WholeWindow, ref hints); + + if ((maximized != Rectangle.Empty) && (maximized.Width > 0) && (maximized.Height > 0)) { + hints.flags = (IntPtr)XSizeHintsFlags.PPosition; + hints.x = maximized.X; + hints.y = maximized.Y; + hints.width = maximized.Width; + hints.height = maximized.Height; + + // Metacity does not seem to follow this constraint for maximized (zoomed) windows + Xlib.XSetZoomHints (display.Handle, WholeWindow, ref hints); + } + } + + // For WM_LBUTTONDOWN, WM_MBUTTONDOWN, WM_RBUTTONDOWN, WM_XBUTTONDOWN + // WM_CREATE and WM_DESTROY causes + public void SendParentNotify (Msg cause, int x, int y) + { + if (Handle == IntPtr.Zero) + return; + + if (ExStyleSet ((int) initial_ex_style, WindowExStyles.WS_EX_NOPARENTNOTIFY)) + return; + + if (Parent == null || Parent.Handle == IntPtr.Zero) + return; + + if (cause == Msg.WM_CREATE || cause == Msg.WM_DESTROY) { + display.SendMessage(Parent.Handle, Msg.WM_PARENTNOTIFY, Widget.MakeParam((int)cause, 0), Handle); + } else { + display.SendMessage(Parent.Handle, Msg.WM_PARENTNOTIFY, Widget.MakeParam((int)cause, 0), Widget.MakeParam(x, y)); + } + + ((X11Hwnd)Parent).SendParentNotify (cause, x, y); + } + + + public void GetPosition (bool is_toplevel, out int x, out int y, out int width, out int height, out int client_width, out int client_height) + { + x = X; + y = Y; + width = Width; + height = Height; + + PerformNCCalc (); + + client_width = ClientRect.Width; + client_height = ClientRect.Height; + } + + public void SetPosition (int x, int y, int width, int height) + { + // Win32 automatically changes negative width/height to 0. + if (width < 0) + width = 0; + if (height < 0) + height = 0; + + // X requires a sanity check for width & height; otherwise it dies + if (zero_sized && width > 0 && height > 0) { + if (Visible) { + Map (); + } + zero_sized = false; + } + + if ((width < 1) || (height < 1)) { + zero_sized = true; + Unmap (); + } + + // Save a server roundtrip (and prevent a feedback loop) + if ((X == x) && (Y == y) && + (Width == width) && (Height == height)) { + return; + } + + if (!zero_sized) { + //Hack? + X = x; + Y = y; + Width = width; + Height = height; + display.SendMessage (Handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + + if (fixed_size) { + SetMinMax (Rectangle.Empty, new Size(width, height), new Size(width, height)); + } + + Xlib.XMoveResizeWindow (display.Handle, WholeWindow, x, y, width, height); + PerformNCCalc (); + } + + // Update our position/size immediately, so + // that future calls to SetWindowPos aren't + // kept from calling XMoveResizeWindow (by the + // "Save a server roundtrip" block above). + X = x; + Y = y; + Width = width; + Height = height; + ClientRect = Rectangle.Empty; + } + + public void SetParent (X11Hwnd parent_hwnd) + { + Parent = parent_hwnd; + +#if DriverDebug || DriverDebugParent + Console.WriteLine("Parent for window {0} = {1}", XplatUI.Window(Handle), XplatUI.Window(hwnd.parent != null ? parent_hwnd.Handle : IntPtr.Zero)); +#endif + Xlib.XReparentWindow (display.Handle, WholeWindow, + parent_hwnd == null ? display.FosterParent.ClientWindow : parent_hwnd.ClientWindow, + X, Y); + } + + public void SetCursorPos (int x, int y) + { + Xlib.XWarpPointer (display.Handle, IntPtr.Zero, ClientWindow, 0, 0, 0, 0, x, y); + } + + public bool SetTopmost (bool enabled) + { + if (enabled) { + int[] atoms = new int[8]; + atoms[0] = display.Atoms._NET_WM_STATE_ABOVE.ToInt32(); + Xlib.XChangeProperty (display.Handle, WholeWindow, display.Atoms._NET_WM_STATE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1); + } + else { + Xlib.XDeleteProperty (display.Handle, WholeWindow, display.Atoms._NET_WM_STATE); + } + + return true; + } + + public bool SetOwner (X11Hwnd owner) + { + if (owner != null) { + WINDOW_TYPE = display.Atoms._NET_WM_WINDOW_TYPE_NORMAL; + if (owner != null) + Xlib.XSetTransientForHint (display.Handle, WholeWindow, owner.WholeWindow); + else + Xlib.XSetTransientForHint (display.Handle, WholeWindow, display.RootWindow.WholeWindow); + } + else { + Xlib.XDeleteProperty (display.Handle, WholeWindow, display.Atoms.XA_WM_TRANSIENT_FOR); + } + + return true; + } + + public bool SetVisible (bool visible, bool activate) + { + Visible = visible; + + if (visible) { + Map (); + + if (Widget.FromHandle (Handle) is Form) { + FormWindowState s; + + s = ((Form)Widget.FromHandle(Handle)).WindowState; + + switch(s) { + case FormWindowState.Minimized: SetWindowState (FormWindowState.Minimized); break; + case FormWindowState.Maximized: SetWindowState (FormWindowState.Maximized); break; + } + + } + + display.SendMessage (Handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + } + else { + Unmap (); + } + + return true; + } + + public FormWindowState GetWindowState () + { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + IntPtr atom; + int maximized; + bool minimized; + XWindowAttributes attributes; + + maximized = 0; + minimized = false; + Xlib.XGetWindowProperty (display.Handle, WholeWindow, + display.Atoms._NET_WM_STATE, IntPtr.Zero, new IntPtr (256), false, + display.Atoms.XA_ATOM, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + + if (((long)nitems > 0) && (prop != IntPtr.Zero)) { + for (int i = 0; i < (long)nitems; i++) { + // XXX 64 bit clean? + atom = (IntPtr)Marshal.ReadInt32(prop, i * 4); + if ((atom == display.Atoms._NET_WM_STATE_MAXIMIZED_HORZ) || (atom == display.Atoms._NET_WM_STATE_MAXIMIZED_VERT)) + maximized++; + else if (atom == display.Atoms._NET_WM_STATE_HIDDEN) + minimized = true; + } + Xlib.XFree(prop); + } + + if (minimized) + return FormWindowState.Minimized; + else if (maximized == 2) + return FormWindowState.Maximized; + + attributes = new XWindowAttributes(); + Xlib.XGetWindowAttributes (display.Handle, ClientWindow, ref attributes); + if (attributes.map_state == MapState.IsUnmapped) + return (FormWindowState)(-1); + + return FormWindowState.Normal; + } + + + public void SetWindowState (FormWindowState state) + { + FormWindowState current_state; + + current_state = GetWindowState (); + + if (current_state == state) + return; + + switch (state) { + case FormWindowState.Normal: + if (current_state == FormWindowState.Minimized) + Map (); + else if (current_state == FormWindowState.Maximized) + display.SendNetWMMessage (WholeWindow, + display.Atoms._NET_WM_STATE, (IntPtr)2 /* toggle */, + display.Atoms._NET_WM_STATE_MAXIMIZED_HORZ, + display.Atoms._NET_WM_STATE_MAXIMIZED_VERT); + Activate (); + break; + + case FormWindowState.Minimized: + if (current_state == FormWindowState.Maximized) + display.SendNetWMMessage (WholeWindow, + display.Atoms._NET_WM_STATE, (IntPtr)2 /* toggle */, + display.Atoms._NET_WM_STATE_MAXIMIZED_HORZ, + display.Atoms._NET_WM_STATE_MAXIMIZED_VERT); + + // FIXME multiscreen support + Xlib.XIconifyWindow (display.Handle, WholeWindow, display.DefaultScreen); + break; + + case FormWindowState.Maximized: + if (current_state == FormWindowState.Minimized) + Map (); + + display.SendNetWMMessage (WholeWindow, + display.Atoms._NET_WM_STATE, (IntPtr)1 /* Add */, + display.Atoms._NET_WM_STATE_MAXIMIZED_HORZ, + display.Atoms._NET_WM_STATE_MAXIMIZED_VERT); + Activate (); + break; + } + } + + public bool SetZOrder (X11Hwnd after_hwnd, bool top, bool bottom) + { + if (top) { + Xlib.XRaiseWindow (display.Handle, WholeWindow); + return true; + } + else if (bottom) { + Xlib.XLowerWindow (display.Handle, WholeWindow); + return true; + } + else { + if (after_hwnd == null) { + Update_USER_TIME (); + Xlib.XRaiseWindow (display.Handle, WholeWindow); + display.SendNetWMMessage (WholeWindow, display.Atoms._NET_ACTIVE_WINDOW, (IntPtr)1, IntPtr.Zero, IntPtr.Zero); + return true; + } + + XWindowChanges values = new XWindowChanges(); + values.sibling = after_hwnd.WholeWindow; + values.stack_mode = StackMode.Below; + + Xlib.XConfigureWindow (display.Handle, WholeWindow, ChangeWindowFlags.CWStackMode | ChangeWindowFlags.CWSibling, ref values); + } + return false; + } + + public X11Display Display { + get { return display; } + } + + public string Text { + get { return text; } + set { + if (value == null) + value = ""; + + if (value == text) + return; + + text = value; + + Xlib.XChangeProperty(display.Handle, WholeWindow, + display.Atoms._NET_WM_NAME, display.Atoms.UNICODETEXT, 8, + PropertyMode.Replace, text, Encoding.UTF8.GetByteCount (text)); + + // XXX this has problems with UTF8. + // we need to either use the actual + // text if it's latin-1, or convert it + // to compound text if it's in a + // different charset. + Xlib.XStoreName(display.Handle, WholeWindow, text); + } + } + + public bool GetText (out string text) + { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + + Xlib.XGetWindowProperty (display.Handle, WholeWindow, + display.Atoms._NET_WM_NAME, IntPtr.Zero, new IntPtr (1), false, + display.Atoms.UNICODETEXT, out actual_atom, out actual_format, + out nitems, out bytes_after, ref prop); + + if ((long)nitems > 0 && prop != IntPtr.Zero) { + text = Marshal.PtrToStringUni (prop, (int)nitems); + Xlib.XFree (prop); + return true; + } + else { + // fallback on the non-_NET property + IntPtr textptr; + + textptr = IntPtr.Zero; + + Xlib.XFetchName (display.Handle, WholeWindow, ref textptr); + if (textptr != IntPtr.Zero) { + text = Marshal.PtrToStringAnsi(textptr); + Xlib.XFree(textptr); + return true; + } else { + text = ""; + return false; + } + } + } + + public IntPtr WINDOW_TYPE { + get { + if (refetch_window_type) { + window_type = GetAtomListProperty (display.Atoms._NET_WM_WINDOW_TYPE); + refetch_window_type = false; + } + + return window_type.Length > 0 ? window_type[0] : IntPtr.Zero; + } + set { + Set_WINDOW_TYPE (new IntPtr[] {value}, 1); + } + } + + public void Set_WINDOW_TYPE (IntPtr[] value, int count) + { + if (refetch_window_type) { + window_type = GetAtomListProperty (display.Atoms._NET_WM_WINDOW_TYPE); + refetch_window_type = false; + } + + if (ArrayDifferent (window_type, value)) { + window_type = value; + Xlib.XChangeProperty (display.Handle, WholeWindow, + display.Atoms._NET_WM_WINDOW_TYPE, display.Atoms.XA_ATOM, 32, + PropertyMode.Replace, window_type, window_type.Length); + } + } + + public void Set_WM_STATE (IntPtr[] value, int count) + { + if (ArrayDifferent (wm_state, value)) { + wm_state = value; + Xlib.XChangeProperty (display.Handle, WholeWindow, + display.Atoms._NET_WM_STATE, display.Atoms.XA_ATOM, 32, + PropertyMode.Replace, wm_state, wm_state.Length); + } + } + + public void Update_USER_TIME () + { + int[] args; + + args = new int[2]; + args[0] = display.CurrentTimestamp; + Xlib.XChangeProperty (display.Handle, WholeWindow, + display.Atoms._NET_WM_USER_TIME, display.Atoms.XA_CARDINAL, 32, + PropertyMode.Replace, args, 1); + } + + public IntPtr[] GetAtomListProperty (IntPtr atom) + { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + + Xlib.XGetWindowProperty (display.Handle, WholeWindow, + atom, IntPtr.Zero, new IntPtr (Int32.MaxValue), false, + display.Atoms.XA_ATOM, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + + if (actual_atom != display.Atoms.XA_ATOM || + (long)nitems == 0 || + prop == IntPtr.Zero) { + return new IntPtr[0]; + } + + IntPtr[] values = new IntPtr[(long)nitems]; + int ofs = 0; + + for (int i = 0; i < values.Length; i ++) { + values[i] = Marshal.ReadIntPtr (prop, ofs); ofs += IntPtr.Size; + } + + Xlib.XFree (prop); + + return values; + } + + bool ArrayDifferent (IntPtr[] a, IntPtr[] b) + { + if (a.Length != b.Length) + return true; + + for (int i = 0; i < a.Length; i ++) { + if (a[i] != b[i]) + return true; + } + + return false; + } + } +} diff --git a/source/ShiftUI/Internal/X11Keyboard.cs b/source/ShiftUI/Internal/X11Keyboard.cs new file mode 100644 index 0000000..70a6c03 --- /dev/null +++ b/source/ShiftUI/Internal/X11Keyboard.cs @@ -0,0 +1,1478 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) +// +// + + +// +// TODO: +// - dead chars are not translated properly +// - There is a lot of potential for optimmization in here +// +using System; +using System.Collections; +using System.Diagnostics; +using System.Drawing; +using System.Text; +using System.Globalization; +using System.Runtime.InteropServices; + +namespace ShiftUI { + + public enum XLookupStatus + { + XBufferOverflow = -1, + XLookupNone = 1, + XLookupChars = 2, + XLookupKeySym = 3, + XLookupBoth = 4 + } + + internal class X11Keyboard : IDisposable { + internal static object XlibLock; + + private IntPtr display; + private IntPtr client_window; + private IntPtr xim; + private Hashtable xic_table = new Hashtable (); + private XIMPositionContext positionContext; + private XIMCallbackContext callbackContext; + private XIMProperties ximStyle; + private EventMask xic_event_mask = EventMask.NoEventMask; + private StringBuilder lookup_buffer; + private byte [] lookup_byte_buffer = new byte [100]; + private int min_keycode, max_keycode, keysyms_per_keycode, syms; + private int [] keyc2vkey = new int [256]; + private int [] keyc2scan = new int [256]; + private byte [] key_state_table = new byte [256]; + private int lcid; + private bool num_state, cap_state; + private bool initialized; + private bool menu_state = false; + private Encoding encoding; + + private int NumLockMask; + private int AltGrMask; + + public X11Keyboard (IntPtr display, IntPtr clientWindow) + { + this.display = display; + lookup_buffer = new StringBuilder (24); + EnsureLayoutInitialized (); + } + + private Encoding AnsiEncoding + { + get + { + if (encoding == null) + encoding = Encoding.GetEncoding(new CultureInfo(lcid).TextInfo.ANSICodePage); + return encoding; + } + } + + public IntPtr ClientWindow { + get { return client_window; } + } + + void IDisposable.Dispose () + { + if (xim != IntPtr.Zero) { + foreach (IntPtr xic in xic_table.Values) + XDestroyIC (xic); + xic_table.Clear (); + + XCloseIM (xim); + xim = IntPtr.Zero; + } + } + + public void DestroyICForWindow (IntPtr window) + { + IntPtr xic = GetXic (window); + if (xic != IntPtr.Zero) { + xic_table.Remove ((long) window); + XDestroyIC (xic); + } + } + + public void EnsureLayoutInitialized () + { + if (initialized) + return; + + KeyboardLayouts layouts = new KeyboardLayouts (); + KeyboardLayout layout = DetectLayout (layouts); + lcid = layout.Lcid; + CreateConversionArray (layouts, layout); + SetupXIM (); + initialized = true; + } + + private void SetupXIM () + { + xim = IntPtr.Zero; + + if (!XSupportsLocale ()) { + Console.Error.WriteLine ("X does not support your locale"); + return; + } + + if (!XSetLocaleModifiers (String.Empty)) { + Console.Error.WriteLine ("Could not set X locale modifiers"); + return; + } + + if (Environment.GetEnvironmentVariable (ENV_NAME_XIM_STYLE) == "disabled") { + return; + } + + xim = XOpenIM (display, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); + if (xim == IntPtr.Zero) + Console.Error.WriteLine ("Could not get XIM"); + + initialized = true; + } + + void CreateXicForWindow (IntPtr window) + { + IntPtr xic = CreateXic (window, xim); + xic_table [(long) window] = xic; + if (xic == IntPtr.Zero) + Console.Error.WriteLine ("Could not get XIC"); + else { + if (XGetICValues (xic, "filterEvents", out xic_event_mask, IntPtr.Zero) != null) + Console.Error.WriteLine ("Could not get XIC values"); + EventMask mask = EventMask.ExposureMask | EventMask.KeyPressMask | EventMask.FocusChangeMask; + if ((xic_event_mask | mask) == xic_event_mask) { + xic_event_mask |= mask; + lock (XlibLock) { + XplatUIX11.XSelectInput(display, window, new IntPtr ((int) xic_event_mask)); + } + } + } + } + + public EventMask KeyEventMask { + get { return xic_event_mask; } + } + + public Keys ModifierKeys { + get { + Keys keys = Keys.None; + if ((key_state_table [(int) VirtualKeys.VK_SHIFT] & 0x80) != 0) + keys |= Keys.Shift; + if ((key_state_table [(int) VirtualKeys.VK_CONTROL ] & 0x80) != 0) + keys |= Keys.Widget; + if ((key_state_table [(int) VirtualKeys.VK_MENU] & 0x80) != 0) + keys |= Keys.Alt; + return keys; + } + } + + private IntPtr GetXic (IntPtr window) + { + if (xim != IntPtr.Zero && xic_table.ContainsKey ((long) window)) + return (IntPtr) xic_table [(long) window]; + else + return IntPtr.Zero; + } + + private bool FilterKey (XEvent e, int vkey) + { + if (XplatUI.key_filters.Count == 0) + return false; + XLookupStatus status; + XKeySym ks; + KeyFilterData data; + data.Down = (e.type == XEventName.KeyPress); + data.ModifierKeys = ModifierKeys; + LookupString (ref e, 0, out ks, out status); + data.keysym = (int)ks; + data.keycode = e.KeyEvent.keycode; + data.str = lookup_buffer.ToString (0, lookup_buffer.Length); + return XplatUI.FilterKey (data); + } + + public void FocusIn (IntPtr window) + { + this.client_window = window; + if (xim == IntPtr.Zero) + return; + + if (!xic_table.ContainsKey ((long) window)) + CreateXicForWindow (window); + IntPtr xic = GetXic (window); + if (xic != IntPtr.Zero) + XSetICFocus (xic); + } + + private bool have_Xutf8ResetIC = true; + + public void FocusOut (IntPtr window) + { + this.client_window = IntPtr.Zero; + if (xim == IntPtr.Zero) + return; + + IntPtr xic = GetXic (window); + if (xic != IntPtr.Zero) { + if (have_Xutf8ResetIC) { + try { + Xutf8ResetIC (xic); + } catch (EntryPointNotFoundException) { + have_Xutf8ResetIC = false; + } + } + XUnsetICFocus (xic); + } + } + + public bool ResetKeyState(IntPtr hwnd, ref MSG msg) { + // FIXME - keep defining events/msg and return true until we've 'restored' all + // pending keypresses + if ((key_state_table [(int) VirtualKeys.VK_SHIFT] & 0x80) != 0) { + key_state_table [(int) VirtualKeys.VK_SHIFT] &= unchecked((byte)~0x80); + } + + if ((key_state_table [(int) VirtualKeys.VK_CONTROL] & 0x80) != 0) { + key_state_table [(int) VirtualKeys.VK_CONTROL] &= unchecked((byte)~0x80); + } + + if ((key_state_table [(int) VirtualKeys.VK_MENU] & 0x80) != 0) { + key_state_table [(int) VirtualKeys.VK_MENU] &= unchecked((byte)~0x80); + } + return false; + } + + // Almost identical to UpdateKeyState() but does not call LookupString(). + // The actual purpose is to handle shift state correctly. + public void PreFilter (XEvent xevent) + { + // It is still possible that some keyboards could have some shift + // keys outside this range, but let's think about such cases only + // if it actually happened. + if (xevent.KeyEvent.keycode >= keyc2vkey.Length) + return; + + int vkey = keyc2vkey [xevent.KeyEvent.keycode]; + + switch (xevent.type) { + case XEventName.KeyRelease: + key_state_table [vkey & 0xff] &= unchecked ((byte) ~0x80); + break; + case XEventName.KeyPress: + if ((key_state_table [vkey & 0xff] & 0x80) == 0) { + key_state_table [vkey & 0xff] ^= 0x01; + } + key_state_table [vkey & 0xff] |= 0x80; + break; + } + } + + public void KeyEvent (IntPtr hwnd, XEvent xevent, ref MSG msg) + { + XKeySym keysym; + int ascii_chars; + + XLookupStatus status; + ascii_chars = LookupString (ref xevent, 24, out keysym, out status); + + if (((int) keysym >= (int) MiscKeys.XK_ISO_Lock && + (int) keysym <= (int) MiscKeys.XK_ISO_Last_Group_Lock) || + (int) keysym == (int) MiscKeys.XK_Mode_switch) { + UpdateKeyState (xevent); + return; + } + + if ((xevent.KeyEvent.keycode >> 8) == 0x10) + xevent.KeyEvent.keycode = xevent.KeyEvent.keycode & 0xFF; + + int event_time = (int)xevent.KeyEvent.time; + + if (status == XLookupStatus.XLookupChars) { + // do not ignore those inputs. They are mostly from XIM. + msg = SendImeComposition (lookup_buffer.ToString (0, lookup_buffer.Length)); + msg.hwnd = hwnd; + return; + } + + AltGrMask = xevent.KeyEvent.state & (0x6000 | (int) KeyMasks.ModMasks); + int vkey = EventToVkey (xevent); + if (vkey == 0 && ascii_chars != 0) { + vkey = (int) VirtualKeys.VK_NONAME; + } + + if (FilterKey (xevent, vkey)) + return; + switch ((VirtualKeys) (vkey & 0xFF)) { + case VirtualKeys.VK_NUMLOCK: + GenerateMessage (VirtualKeys.VK_NUMLOCK, 0x45, xevent.KeyEvent.keycode, xevent.type, event_time); + break; + case VirtualKeys.VK_CAPITAL: + GenerateMessage (VirtualKeys.VK_CAPITAL, 0x3A, xevent.KeyEvent.keycode, xevent.type, event_time); + break; + default: + if (((key_state_table [(int) VirtualKeys.VK_NUMLOCK] & 0x01) == 0) != ((xevent.KeyEvent.state & NumLockMask) == 0)) { + GenerateMessage (VirtualKeys.VK_NUMLOCK, 0x45, xevent.KeyEvent.keycode, XEventName.KeyPress, event_time); + GenerateMessage (VirtualKeys.VK_NUMLOCK, 0x45, xevent.KeyEvent.keycode, XEventName.KeyRelease, event_time); + } + + if (((key_state_table [(int) VirtualKeys.VK_CAPITAL] & 0x01) == 0) != ((xevent.KeyEvent.state & (int) KeyMasks.LockMask) == 0)) { + GenerateMessage (VirtualKeys.VK_CAPITAL, 0x3A, xevent.KeyEvent.keycode, XEventName.KeyPress, event_time); + GenerateMessage (VirtualKeys.VK_CAPITAL, 0x3A, xevent.KeyEvent.keycode, XEventName.KeyRelease, event_time); + } + + num_state = false; + cap_state = false; + + int bscan = (keyc2scan [xevent.KeyEvent.keycode] & 0xFF); + KeybdEventFlags dw_flags = KeybdEventFlags.None; + if (xevent.type == XEventName.KeyRelease) + dw_flags |= KeybdEventFlags.KeyUp; + if ((vkey & 0x100) != 0) + dw_flags |= KeybdEventFlags.ExtendedKey; + msg = SendKeyboardInput ((VirtualKeys) (vkey & 0xFF), bscan, xevent.KeyEvent.keycode, dw_flags, event_time); + msg.hwnd = hwnd; + break; + } + } + + public bool TranslateMessage (ref MSG msg) + { + bool res = false; + + if (msg.message >= Msg.WM_KEYFIRST && msg.message <= Msg.WM_KEYLAST) + res = true; + + if (msg.message == Msg.WM_SYSKEYUP && msg.wParam == (IntPtr) 0x12 && menu_state) { + msg.message = Msg.WM_KEYUP; + menu_state = false; + } + + if (msg.message != Msg.WM_KEYDOWN && msg.message != Msg.WM_SYSKEYDOWN) + return res; + + if ((key_state_table [(int) VirtualKeys.VK_MENU] & 0x80) != 0 && msg.wParam != (IntPtr) 0x12) + menu_state = true; + + EnsureLayoutInitialized (); + + string buffer; + Msg message; + int tu = ToUnicode ((int) msg.wParam, Widget.HighOrder ((int) msg.lParam), out buffer); + switch (tu) { + case 1: + message = (msg.message == Msg.WM_KEYDOWN ? Msg.WM_CHAR : Msg.WM_SYSCHAR); + XplatUI.PostMessage (msg.hwnd, message, (IntPtr) buffer [0], msg.lParam); + break; + case -1: + message = (msg.message == Msg.WM_KEYDOWN ? Msg.WM_DEADCHAR : Msg.WM_SYSDEADCHAR); + XplatUI.PostMessage (msg.hwnd, message, (IntPtr) buffer [0], msg.lParam); + return true; + } + + return res; + } + + public int ToKeycode(int key) + { + int keycode = 0; + + if (nonchar_vkey_key[key] > 0) + keycode = XKeysymToKeycode (display, nonchar_vkey_key[key]); + + if (keycode == 0) + keycode = XKeysymToKeycode (display, key); + + return keycode; + } + + public int ToUnicode (int vkey, int scan, out string buffer) + { + if ((scan & 0x8000) != 0) { + buffer = String.Empty; + return 0; + } + + XEvent e = new XEvent (); + e.AnyEvent.type = XEventName.KeyPress; + e.KeyEvent.display = display; + e.KeyEvent.keycode = 0; + e.KeyEvent.state = 0; + + if ((key_state_table [(int) VirtualKeys.VK_SHIFT] & 0x80) != 0) { + e.KeyEvent.state |= (int) KeyMasks.ShiftMask; + } + + if ((key_state_table [(int) VirtualKeys.VK_CAPITAL] & 0x01) != 0) { + e.KeyEvent.state |= (int) KeyMasks.LockMask; + } + + if ((key_state_table [(int) VirtualKeys.VK_CONTROL] & 0x80) != 0) { + e.KeyEvent.state |= (int) KeyMasks.ControlMask; + } + + if ((key_state_table [(int) VirtualKeys.VK_NUMLOCK] & 0x01) != 0) { + e.KeyEvent.state |= NumLockMask; + } + + e.KeyEvent.state |= AltGrMask; + + for (int keyc = min_keycode; (keyc <= max_keycode) && (e.KeyEvent.keycode == 0); keyc++) { + // find keycode that could have generated this vkey + if ((keyc2vkey [keyc] & 0xFF) == vkey) { + // filter extended bit because it is not known + e.KeyEvent.keycode = keyc; + if ((EventToVkey (e) & 0xFF) != vkey) { + // Wrong one (ex: because of num,lock state) + e.KeyEvent.keycode = 0; + } + } + } + + if ((vkey >= (int) VirtualKeys.VK_NUMPAD0) && (vkey <= (int) VirtualKeys.VK_NUMPAD9)) + e.KeyEvent.keycode = XKeysymToKeycode (display, vkey - (int) VirtualKeys.VK_NUMPAD0 + (int) KeypadKeys.XK_KP_0); + + if (vkey == (int) VirtualKeys.VK_DECIMAL) + e.KeyEvent.keycode = XKeysymToKeycode (display, (int) KeypadKeys.XK_KP_Decimal); + + if (vkey == (int) VirtualKeys.VK_SEPARATOR) + e.KeyEvent.keycode = XKeysymToKeycode(display, (int) KeypadKeys.XK_KP_Separator); + + if (e.KeyEvent.keycode == 0 && vkey != (int) VirtualKeys.VK_NONAME) { + // And I couldn't find the keycode so i returned the vkey and was like whatever + Console.Error.WriteLine ("unknown virtual key {0:X}", vkey); + buffer = String.Empty; + return vkey; + } + + XKeySym t; + XLookupStatus status; + int res = LookupString (ref e, 24, out t, out status); + int keysym = (int) t; + + buffer = String.Empty; + if (res == 0) { + int dead_char = MapDeadKeySym (keysym); + if (dead_char != 0) { + byte [] bytes = new byte [1]; + bytes [0] = (byte) dead_char; + buffer = new string (AnsiEncoding.GetChars (bytes)); + res = -1; + } + } else { + // Shift + arrow, shift + home, .... + // X returns a char for it, but windows doesn't + if (((e.KeyEvent.state & NumLockMask) == 0) && ((e.KeyEvent.state & (int) KeyMasks.ShiftMask) != 0) && + (keysym >= (int) KeypadKeys.XK_KP_0) && (keysym <= (int) KeypadKeys.XK_KP_9)) { + buffer = String.Empty; + res = 0; + } + + // CTRL + number, X returns chars, windows does not + if ((e.KeyEvent.state & (int) KeyMasks.ControlMask) != 0) { + if (((keysym >= 33) && (keysym < 'A')) || ((keysym > 'Z') && (keysym < 'a'))) { + buffer = String.Empty; + res = 0; + } + } + + // X returns a char for delete key on extended keyboards, windows does not + if (keysym == (int) TtyKeys.XK_Delete) { + buffer = String.Empty; + res = 0; + } + + if (keysym == (int) TtyKeys.XK_BackSpace && (key_state_table [(int) VirtualKeys.VK_CONTROL] & 0x80) != 0) { + buffer = new string (new char [] { (char) 127 }); + + return 1; + } + + // For some special chars, such backspace and enter, looking up for a string + // can randomly fail to properly fill the buffer (either marshaling or X11), so we use + // the keysysm value to fill the gap + if (keysym == (int) XKeySym.XK_BackSpace) { + buffer = new string (new char [] { (char) 8 }); + return 1; + } + if (keysym == (int) XKeySym.XK_Return) { + buffer = new string (new char [] { (char)13 }); + return 1; + } + + if (res != 0) { + buffer = lookup_buffer.ToString (); + res = buffer.Length; + } + } + + return res; + } + + string stored_keyevent_string; + + internal string GetCompositionString () + { + return stored_keyevent_string; + } + + private MSG SendImeComposition (string s) + { + MSG msg = new MSG (); + msg.message = Msg.WM_IME_COMPOSITION; + msg.refobject = s; + stored_keyevent_string = s; + return msg; + } + + private MSG SendKeyboardInput (VirtualKeys vkey, int scan, int keycode, KeybdEventFlags dw_flags, int time) + { + Msg message; + + if ((dw_flags & KeybdEventFlags.KeyUp) != 0) { + bool sys_key = (key_state_table [(int) VirtualKeys.VK_MENU] & 0x80) != 0 && + ((key_state_table [(int) VirtualKeys.VK_CONTROL] & 0x80) == 0); + key_state_table [(int) vkey] &= unchecked ((byte) ~0x80); + message = (sys_key ? Msg.WM_SYSKEYUP : Msg.WM_KEYUP); + } else { + if ((key_state_table [(int) vkey] & 0x80) == 0) { + key_state_table [(int) vkey] ^= 0x01; + } + key_state_table [(int) vkey] |= 0x80; + bool sys_key = (key_state_table [(int) VirtualKeys.VK_MENU] & 0x80) != 0 && + ((key_state_table [(int) VirtualKeys.VK_CONTROL] & 0x80) == 0); + message = (sys_key ? Msg.WM_SYSKEYDOWN : Msg.WM_KEYDOWN); + } + + MSG msg = new MSG (); + msg.message = message; + msg.wParam = (IntPtr) vkey; + msg.lParam = GenerateLParam (msg, keycode); + return msg; + } + + private IntPtr GenerateLParam (MSG m, int keyCode) + { + // http://msdn.microsoft.com/en-us/library/ms646267(VS.85).aspx + // + byte flags = 0; + + if (m.message == Msg.WM_SYSKEYUP || m.message == Msg.WM_KEYUP) + flags |= 0x80; // transition state flag = 1 + + flags |= 0x40; // previous key state flag = 1 + + if ((key_state_table [(int) VirtualKeys.VK_RMENU] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_LMENU] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_MENU] & 0x80) != 0) + flags |= 0x20; // context code flag = 1 + + if ((key_state_table [(int) VirtualKeys.VK_INSERT] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_DELETE] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_HOME] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_END] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_UP] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_DOWN] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_LEFT] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_RIGHT] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_CONTROL] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_MENU] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_NUMLOCK] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_PRINT] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_RETURN] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_DIVIDE] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_PRIOR] & 0x80) != 0 || + (key_state_table [(int) VirtualKeys.VK_NEXT] & 0x80) != 0) + flags |= 0x01; // extended key flag = 1 + + int lparam = ((((int)flags) & 0x000000FF) << 3*8); // message flags + lparam |= ((keyCode & 0x000000FF) << 2*8); // scan code + lparam |= 0x00000001; // repeat count = 1 + + return (IntPtr)lparam; + } + + private void GenerateMessage (VirtualKeys vkey, int scan, int key_code, XEventName type, int event_time) + { + bool state = (vkey == VirtualKeys.VK_NUMLOCK ? num_state : cap_state); + KeybdEventFlags up, down; + + if (state) { + // The INTERMEDIARY state means : just after a 'press' event, if a 'release' event comes, + // don't treat it. It's from the same key press. Then the state goes to ON. + // And from there, a 'release' event will switch off the toggle key. + SetState (vkey, false); + } else { + down = (vkey == VirtualKeys.VK_NUMLOCK ? KeybdEventFlags.ExtendedKey : KeybdEventFlags.None); + up = (vkey == VirtualKeys.VK_NUMLOCK ? KeybdEventFlags.ExtendedKey : + KeybdEventFlags.None) | KeybdEventFlags.KeyUp; + if ((key_state_table [(int) vkey] & 0x1) != 0) { // it was on + if (type != XEventName.KeyPress) { + SendKeyboardInput (vkey, scan, key_code, down, event_time); + SendKeyboardInput (vkey, scan, key_code, up, event_time); + SetState (vkey, false); + key_state_table [(int) vkey] &= unchecked ((byte) ~0x01); + } + } else { + if (type == XEventName.KeyPress) { + SendKeyboardInput (vkey, scan, key_code, down, event_time); + SendKeyboardInput (vkey, scan, key_code, up, event_time); + SetState (vkey, true); + key_state_table [(int) vkey] |= 0x01; + } + } + } + } + + private void UpdateKeyState (XEvent xevent) + { + int vkey = EventToVkey (xevent); + + switch (xevent.type) { + case XEventName.KeyRelease: + key_state_table [vkey & 0xff] &= unchecked ((byte) ~0x80); + break; + case XEventName.KeyPress: + if ((key_state_table [vkey & 0xff] & 0x80) == 0) { + key_state_table [vkey & 0xff] ^= 0x01; + } + key_state_table [vkey & 0xff] |= 0x80; + break; + } + } + + private void SetState (VirtualKeys key, bool state) + { + if (VirtualKeys.VK_NUMLOCK == key) + num_state = state; + else + cap_state = state; + } + + public int EventToVkey (XEvent e) + { + XLookupStatus status; + XKeySym ks; + + LookupString (ref e, 0, out ks, out status); + int keysym = (int) ks; + + if (((e.KeyEvent.state & NumLockMask) != 0) && + (keysym == (int)KeypadKeys.XK_KP_Separator || keysym == (int)KeypadKeys.XK_KP_Decimal || + (keysym >= (int)KeypadKeys.XK_KP_0 && keysym <= (int)KeypadKeys.XK_KP_9))) { + // Only the Keypad keys 0-9 and . send different keysyms + // depending on the NumLock state + return nonchar_key_vkey [keysym & 0xFF]; + } + + return keyc2vkey [e.KeyEvent.keycode]; + } + + private void CreateConversionArray (KeyboardLayouts layouts, KeyboardLayout layout) + { + XEvent e2 = new XEvent (); + uint keysym = 0; + int [] ckey = new int [] { 0, 0, 0, 0 }; + + e2.KeyEvent.display = display; + e2.KeyEvent.state = 0; + + for (int keyc = min_keycode; keyc <= max_keycode; keyc++) { + int vkey = 0; + int scan = 0; + + e2.KeyEvent.keycode = keyc; + XKeySym t; + + XLookupStatus status; + LookupString (ref e2, 0, out t, out status); + + keysym = (uint) t; + if (keysym != 0) { + if ((keysym >> 8) == 0xFF) { + vkey = nonchar_key_vkey [keysym & 0xFF]; + scan = nonchar_key_scan [keysym & 0xFF]; + // Set extended bit + if ((scan & 0x100) != 0) + vkey |= 0x100; + } else if (keysym == 0x20) { // spacebar + vkey = (int) VirtualKeys.VK_SPACE; + scan = 0x39; + } else { + // Search layout dependent scancodes + int maxlen = 0; + int maxval = -1;; + + for (int i = 0; i < syms; i++) { + keysym = XKeycodeToKeysym (display, keyc, i); + if ((keysym < 0x800) && (keysym != ' ')) + ckey [i] = (sbyte) (keysym & 0xFF); + else + ckey [i] = (sbyte) MapDeadKeySym ((int) keysym); + } + + for (int keyn = 0; keyn < layout.Keys.Length; keyn++) { + int ml = Math.Min (layout.Keys [keyn].Length, 4); + int ok = -1; + for (int i = 0; (ok != 0) && (i < ml); i++) { + sbyte ck = (sbyte) layout.Keys [keyn][i]; + if (ck != ckey [i]) + ok = 0; + if ((ok != 0) || (i > maxlen)) { + maxlen = i; + maxval = keyn; + } + if (ok != 0) + break; + } + } + if (maxval >= 0) { + if (maxval < layouts.scan_table [(int) layout.ScanIndex].Length) + scan = layouts.scan_table [(int) layout.ScanIndex][maxval]; + if (maxval < layouts.vkey_table [(int) layout.VKeyIndex].Length) + vkey = layouts.vkey_table [(int) layout.VKeyIndex][maxval]; + } + } + } + keyc2vkey [e2.KeyEvent.keycode] = vkey; + keyc2scan [e2.KeyEvent.keycode] = scan; + } + + + } + + private KeyboardLayout DetectLayout (KeyboardLayouts layouts) + { + XDisplayKeycodes (display, out min_keycode, out max_keycode); + IntPtr ksp = XGetKeyboardMapping (display, (byte) min_keycode, + max_keycode + 1 - min_keycode, out keysyms_per_keycode); + lock (XlibLock) { + XplatUIX11.XFree (ksp); + } + + syms = keysyms_per_keycode; + if (syms > 4) { + //Console.Error.WriteLine ("{0} keysymbols per a keycode is not supported, setting to 4", syms); + syms = 2; + } + + IntPtr modmap_unmanaged; + XModifierKeymap xmk = new XModifierKeymap (); + + modmap_unmanaged = XGetModifierMapping (display); + xmk = (XModifierKeymap) Marshal.PtrToStructure (modmap_unmanaged, typeof (XModifierKeymap)); + + int mmp = 0; + for (int i = 0; i < 8; i++) { + for (int j = 0; j < xmk.max_keypermod; j++, mmp++) { + byte b = Marshal.ReadByte (xmk.modifiermap, mmp); + if (b != 0) { + for (int k = 0; k < keysyms_per_keycode; k++) { + if ((int) XKeycodeToKeysym (display, b, k) == (int) MiscKeys.XK_Num_Lock) + NumLockMask = 1 << i; + } + } + } + } + XFreeModifiermap (modmap_unmanaged); + + int [] ckey = new int [4]; + KeyboardLayout layout = null; + int max_score = 0; + int max_seq = 0; + + foreach (KeyboardLayout current in layouts.Layouts) { + int ok = 0; + int score = 0; + int match = 0; + int mismatch = 0; + int seq = 0; + int pkey = -1; + int key = min_keycode; + int i; + + for (int keyc = min_keycode; keyc <= max_keycode; keyc++) { + for (i = 0; i < syms; i++) { + uint keysym = XKeycodeToKeysym (display, keyc, i); + + if ((keysym < 0x800) && (keysym != ' ')) { + ckey [i] = (sbyte) (keysym & 0xFF); + } else { + ckey [i] = (sbyte) MapDeadKeySym ((int) keysym); + } + } + if (ckey [0] != 0) { + for (key = 0; key < current.Keys.Length; key++) { + int ml = Math.Min (syms, current.Keys [key].Length); + for (ok = 0, i = 0; (ok >= 0) && (i < ml); i++) { + sbyte ck = (sbyte) current.Keys [key][i]; + if (ck != 0 && ck == ckey[i]) + ok++; + if (ck != 0 && ck != ckey[i]) + ok = -1; + } + if (ok > 0) { + score += ok; + break; + } + } + if (ok > 0) { + match++; + /* and how much the keycode order matches */ + if (key > pkey) + seq++; + pkey = key; + } else { + /* print spaces instead of \0's */ + mismatch++; + score -= syms; + } + } + } + + if ((score > max_score) || ((score == max_score) && (seq > max_seq))) { + // best match so far + layout = current; + max_score = score; + max_seq = seq; + } + } + + if (layout != null) { + return layout; + } else { + Console.WriteLine ("Keyboard layout not recognized, using default layout: " + + layouts.Layouts [0].Name); + } + + return layouts.Layouts [0]; + } + + // TODO + private int MapDeadKeySym (int val) + { + switch (val) { + case (int) DeadKeys.XK_dead_tilde : + case 0x1000FE7E : // Xfree's Dtilde + return '~'; + case (int) DeadKeys.XK_dead_acute : + case 0x1000FE27 : // Xfree's XK_Dacute_accent + return 0xb4; + case (int) DeadKeys.XK_dead_circumflex: + case 0x1000FE5E : // Xfree's XK_.Dcircumflex_accent + return '^'; + case (int) DeadKeys.XK_dead_grave : + case 0x1000FE60 : // Xfree's XK_.Dgrave_accent + return '`'; + case (int) DeadKeys.XK_dead_diaeresis : + case 0x1000FE22 : // Xfree's XK_.Ddiaeresis + return 0xa8; + case (int) DeadKeys.XK_dead_cedilla : + return 0xb8; + case (int) DeadKeys.XK_dead_macron : + return '-'; + case (int) DeadKeys.XK_dead_breve : + return 0xa2; + case (int) DeadKeys.XK_dead_abovedot : + return 0xff; + case (int) DeadKeys.XK_dead_abovering : + return '0'; + case (int) DeadKeys.XK_dead_doubleacute : + return 0xbd; + case (int) DeadKeys.XK_dead_caron : + return 0xb7; + case (int) DeadKeys.XK_dead_ogonek : + return 0xb2; + } + + return 0; + } + + private XIMProperties [] GetSupportedInputStyles (IntPtr xim) + { + IntPtr stylesPtr; + string ret = XGetIMValues (xim, XNames.XNQueryInputStyle, out stylesPtr, IntPtr.Zero); + if (ret != null || stylesPtr == IntPtr.Zero) + return new XIMProperties [0]; + XIMStyles styles = (XIMStyles) Marshal.PtrToStructure (stylesPtr, typeof (XIMStyles)); + XIMProperties [] supportedStyles = new XIMProperties [styles.count_styles]; + for (int i = 0; i < styles.count_styles; i++) + supportedStyles [i] = (XIMProperties) Marshal.PtrToStructure (new IntPtr ((long) styles.supported_styles + i * Marshal.SizeOf (typeof (IntPtr))), typeof (XIMProperties)); + lock (XlibLock) { + XplatUIX11.XFree (stylesPtr); + } + return supportedStyles; + } + + const XIMProperties styleRoot = XIMProperties.XIMPreeditNothing | XIMProperties.XIMStatusNothing; + const XIMProperties styleOverTheSpot = XIMProperties.XIMPreeditPosition | XIMProperties.XIMStatusNothing; + const XIMProperties styleOnTheSpot = XIMProperties.XIMPreeditCallbacks | XIMProperties.XIMStatusNothing; + const string ENV_NAME_XIM_STYLE = "MONO_WINFORMS_XIM_STYLE"; + + private XIMProperties [] GetPreferredStyles () + { + string env = Environment.GetEnvironmentVariable (ENV_NAME_XIM_STYLE); + if (env == null) + env = "over-the-spot"; + string [] list = env.Split (' '); + XIMProperties [] ret = new XIMProperties [list.Length]; + for (int i = 0; i < list.Length; i++) { + string s = list [i]; + switch (s) { + case "over-the-spot": + ret [i] = styleOverTheSpot; + break; + case "on-the-spot": + ret [i] = styleOnTheSpot; + break; + case "root": + ret [i] = styleRoot; + break; + } + } + return ret; + } + + private IEnumerable GetMatchingStylesInPreferredOrder (IntPtr xim) + { + XIMProperties [] supportedStyles = GetSupportedInputStyles (xim); + foreach (XIMProperties p in GetPreferredStyles ()) + if (Array.IndexOf (supportedStyles, p) >= 0) + yield return p; + } + + private IntPtr CreateXic (IntPtr window, IntPtr xim) + { + IntPtr xic = IntPtr.Zero; + foreach (XIMProperties targetStyle in GetMatchingStylesInPreferredOrder (xim)) { + ximStyle = targetStyle; + // FIXME: use __arglist when it gets working. See bug #321686 + switch (targetStyle) { + case styleOverTheSpot: + xic = CreateOverTheSpotXic (window, xim); + if (xic != IntPtr.Zero) + break; + //Console.WriteLine ("failed to create XIC in over-the-spot mode."); + continue; + case styleOnTheSpot: + // Since .NET/Winforms seems to support only over-the-spot mode,, + // I'm not likely to continue on-the-spot implementation. But in + // case we need it, this code will be still useful. + xic = CreateOnTheSpotXic (window, xim); + if (xic != IntPtr.Zero) + break; + //Console.WriteLine ("failed to create XIC in on-the-spot mode."); + continue; + case styleRoot: + xic = XCreateIC (xim, + XNames.XNInputStyle, styleRoot, + XNames.XNClientWindow, window, + IntPtr.Zero); + break; + } + } + // fall back to root mode if all modes failed + if (xic == IntPtr.Zero) { + ximStyle = styleRoot; + xic = XCreateIC (xim, + XNames.XNInputStyle, styleRoot, + XNames.XNClientWindow, window, + XNames.XNFocusWindow, window, + IntPtr.Zero); + } + return xic; + } + + private IntPtr CreateOverTheSpotXic (IntPtr window, IntPtr xim) + { + IntPtr list; + int count; + Widget c = Widget.FromHandle (window); + string xlfd = String.Format ("-*-*-*-*-*-*-{0}-*-*-*-*-*-*-*", (int) c.Font.Size); + IntPtr fontSet = XCreateFontSet (display, xlfd, out list, out count, IntPtr.Zero); + XPoint spot = new XPoint (); + spot.X = 0; + spot.Y = 0; + IntPtr pSL = IntPtr.Zero, pFS = IntPtr.Zero; + try { + pSL = Marshal.StringToHGlobalAnsi (XNames.XNSpotLocation); + pFS = Marshal.StringToHGlobalAnsi (XNames.XNFontSet); + IntPtr preedit = XVaCreateNestedList (0, + pSL, spot, + pFS, fontSet, + IntPtr.Zero); + return XCreateIC (xim, + XNames.XNInputStyle, styleOverTheSpot, + XNames.XNClientWindow, window, + XNames.XNPreeditAttributes, preedit, + IntPtr.Zero); + } finally { + if (pSL != IntPtr.Zero) + Marshal.FreeHGlobal (pSL); + if (pFS != IntPtr.Zero) + Marshal.FreeHGlobal (pFS); + XFreeStringList (list); + //XplatUIX11.XFree (preedit); + //XFreeFontSet (fontSet); + } + } + + private IntPtr CreateOnTheSpotXic (IntPtr window, IntPtr xim) + { + callbackContext = new XIMCallbackContext (window); + return callbackContext.CreateXic (window, xim); + } + + class XIMCallbackContext + { + XIMCallback startCB, doneCB, drawCB, caretCB; + IntPtr pStartCB = IntPtr.Zero, pDoneCB = IntPtr.Zero, pDrawCB = IntPtr.Zero, pCaretCB = IntPtr.Zero; + IntPtr pStartCBN = IntPtr.Zero, pDoneCBN = IntPtr.Zero, pDrawCBN = IntPtr.Zero, pCaretCBN = IntPtr.Zero; + + public XIMCallbackContext (IntPtr clientWindow) + { + startCB = new XIMCallback (clientWindow, DoPreeditStart); + doneCB = new XIMCallback (clientWindow, DoPreeditDone); + drawCB = new XIMCallback (clientWindow, DoPreeditDraw); + caretCB = new XIMCallback (clientWindow, DoPreeditCaret); + pStartCB = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (XIMCallback))); + pDoneCB = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (XIMCallback))); + pDrawCB = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (XIMCallback))); + pCaretCB = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (XIMCallback))); + pStartCBN = Marshal.StringToHGlobalAnsi (XNames.XNPreeditStartCallback); + pDoneCBN = Marshal.StringToHGlobalAnsi (XNames.XNPreeditDoneCallback); + pDrawCBN = Marshal.StringToHGlobalAnsi (XNames.XNPreeditDrawCallback); + pCaretCBN = Marshal.StringToHGlobalAnsi (XNames.XNPreeditCaretCallback); + } + + ~XIMCallbackContext () + { + if (pStartCBN != IntPtr.Zero) + Marshal.FreeHGlobal (pStartCBN); + if (pDoneCBN != IntPtr.Zero) + Marshal.FreeHGlobal (pDoneCBN); + if (pDrawCBN != IntPtr.Zero) + Marshal.FreeHGlobal (pDrawCBN); + if (pCaretCBN != IntPtr.Zero) + Marshal.FreeHGlobal (pCaretCBN); + + if (pStartCB != IntPtr.Zero) + Marshal.FreeHGlobal (pStartCB); + if (pDoneCB != IntPtr.Zero) + Marshal.FreeHGlobal (pDoneCB); + if (pDrawCB != IntPtr.Zero) + Marshal.FreeHGlobal (pDrawCB); + if (pCaretCB != IntPtr.Zero) + Marshal.FreeHGlobal (pCaretCB); + } + + int DoPreeditStart (IntPtr xic, IntPtr clientData, IntPtr callData) + { + Debug.WriteLine ("DoPreeditStart"); + XplatUI.SendMessage(clientData, Msg.WM_XIM_PREEDITSTART, clientData, callData); + return 100; + } + + int DoPreeditDone (IntPtr xic, IntPtr clientData, IntPtr callData) + { + Debug.WriteLine ("DoPreeditDone"); + XplatUI.SendMessage(clientData, Msg.WM_XIM_PREEDITDONE, clientData, callData); + return 0; + } + + int DoPreeditDraw (IntPtr xic, IntPtr clientData, IntPtr callData) + { + Debug.WriteLine ("DoPreeditDraw"); + XplatUI.SendMessage(clientData, Msg.WM_XIM_PREEDITDRAW, clientData, callData); + return 0; + } + + int DoPreeditCaret (IntPtr xic, IntPtr clientData, IntPtr callData) + { + Debug.WriteLine ("DoPreeditCaret"); + XplatUI.SendMessage(clientData, Msg.WM_XIM_PREEDITCARET, clientData, callData); + return 0; + } + + public IntPtr CreateXic (IntPtr window, IntPtr xim) + { + Marshal.StructureToPtr (startCB, pStartCB, false); + Marshal.StructureToPtr (doneCB, pDoneCB, false); + Marshal.StructureToPtr (drawCB, pDrawCB, false); + Marshal.StructureToPtr (caretCB, pCaretCB, false); + IntPtr preedit = XVaCreateNestedList (0, + pStartCBN, pStartCB, + pDoneCBN, pDoneCB, + pDrawCBN, pDrawCB, + pCaretCBN, pCaretCB, + IntPtr.Zero); + return XCreateIC (xim, + XNames.XNInputStyle, styleOnTheSpot, + XNames.XNClientWindow, window, + XNames.XNPreeditAttributes, preedit, + IntPtr.Zero); + } + } + + class XIMPositionContext + { + public CaretStruct Caret; + public int X; + public int Y; + } + + internal void SetCaretPos (CaretStruct caret, IntPtr handle, int x, int y) + { + if (ximStyle != styleOverTheSpot) + return; + + if (positionContext == null) + this.positionContext = new XIMPositionContext (); + + positionContext.Caret = caret; + positionContext.X = x; + positionContext.Y = y + caret.Height; + + MoveCurrentCaretPos (); + } + + internal void MoveCurrentCaretPos () + { + if (positionContext == null || ximStyle != styleOverTheSpot || client_window == IntPtr.Zero) + return; + + int x = positionContext.X; + int y = positionContext.Y; + CaretStruct caret = positionContext.Caret; + IntPtr xic = GetXic (client_window); + if (xic == IntPtr.Zero) + return; + Widget Widget = Widget.FromHandle (client_window); + if (Widget == null || !Widget.IsHandleCreated) + return; + Widget = Widget.FromHandle (caret.Hwnd); + if (Widget == null || !Widget.IsHandleCreated) + return; + Hwnd hwnd = Hwnd.ObjectFromHandle (client_window); + if (!hwnd.mapped) + return; + + int dx, dy; + IntPtr child; + lock (XlibLock) { + XplatUIX11.XTranslateCoordinates (display, client_window, client_window, x, y, out dx, out dy, out child); + } + + XPoint spot = new XPoint (); + spot.X = (short) dx; + spot.Y = (short) dy; + + IntPtr pSL = IntPtr.Zero; + try { + pSL = Marshal.StringToHGlobalAnsi (XNames.XNSpotLocation); + IntPtr preedit = XVaCreateNestedList (0, pSL, spot, IntPtr.Zero); + XSetICValues (xic, XNames.XNPreeditAttributes, preedit, IntPtr.Zero); + } finally { + if (pSL != IntPtr.Zero) + Marshal.FreeHGlobal (pSL); + } + } + + private bool have_Xutf8LookupString = true; + + private int LookupString (ref XEvent xevent, int len, out XKeySym keysym, out XLookupStatus status) + { + IntPtr keysym_res; + int res; + + status = XLookupStatus.XLookupNone; + IntPtr xic = GetXic (client_window); + if (xic != IntPtr.Zero && have_Xutf8LookupString && xevent.type == XEventName.KeyPress) { + do { + try { + res = Xutf8LookupString (xic, ref xevent, lookup_byte_buffer, 100, out keysym_res, out status); + } catch (EntryPointNotFoundException) { + have_Xutf8LookupString = false; + + // call again, this time we'll go through the non-xic clause + return LookupString (ref xevent, len, out keysym, out status); + } + if (status != XLookupStatus.XBufferOverflow) + break; + lookup_byte_buffer = new byte [lookup_byte_buffer.Length << 1]; + } while (true); + lookup_buffer.Length = 0; + string s = Encoding.UTF8.GetString (lookup_byte_buffer, 0, res); + lookup_buffer.Append (s); + keysym = (XKeySym) keysym_res.ToInt32 (); + return s.Length; + } else { + IntPtr statusPtr = IntPtr.Zero; + lookup_buffer.Length = 0; + res = XLookupString (ref xevent, lookup_buffer, len, out keysym_res, out statusPtr); + keysym = (XKeySym) keysym_res.ToInt32 (); + return res; + } + } + + [DllImport ("libX11")] + private static extern IntPtr XOpenIM (IntPtr display, IntPtr rdb, IntPtr res_name, IntPtr res_class); + + [DllImport ("libX11", CallingConvention = CallingConvention.Cdecl)] + private static extern IntPtr XCreateIC (IntPtr xim, string name, XIMProperties im_style, string name2, IntPtr value2, IntPtr terminator); + [DllImport ("libX11", CallingConvention = CallingConvention.Cdecl)] + private static extern IntPtr XCreateIC (IntPtr xim, string name, XIMProperties im_style, string name2, IntPtr value2, string name3, IntPtr value3, IntPtr terminator); +// [DllImport ("libX11", CallingConvention = CallingConvention.Cdecl)] +// private static extern IntPtr XCreateIC (IntPtr xim, string name, XIMProperties im_style, string name2, IntPtr value2, string name3, IntPtr value3, string name4, IntPtr value4, IntPtr terminator); + + [DllImport ("libX11", CallingConvention = CallingConvention.Cdecl)] + private static extern IntPtr XVaCreateNestedList (int dummy, IntPtr name0, XPoint value0, IntPtr terminator); + [DllImport ("libX11", CallingConvention = CallingConvention.Cdecl)] + private static extern IntPtr XVaCreateNestedList (int dummy, IntPtr name0, XPoint value0, IntPtr name1, IntPtr value1, IntPtr terminator); + [DllImport ("libX11", CallingConvention = CallingConvention.Cdecl)] + private static extern IntPtr XVaCreateNestedList (int dummy, IntPtr name0, IntPtr value0, IntPtr name1, IntPtr value1, IntPtr name2, IntPtr value2, IntPtr name3, IntPtr value3, IntPtr terminator); + + [DllImport ("libX11")] + private static extern IntPtr XCreateFontSet (IntPtr display, string name, out IntPtr list, out int count, IntPtr terminator); + + [DllImport ("libX11")] + internal extern static void XFreeFontSet (IntPtr data); + + [DllImport ("libX11")] + private static extern void XFreeStringList (IntPtr ptr); + + //[DllImport ("libX11")] + //private static extern IntPtr XIMOfIC (IntPtr xic); + + [DllImport ("libX11")] + private static extern void XCloseIM (IntPtr xim); + + [DllImport ("libX11")] + private static extern void XDestroyIC (IntPtr xic); + + [DllImport ("libX11")] + private static extern string XGetIMValues (IntPtr xim, string name, out IntPtr value, IntPtr terminator); + + [DllImport ("libX11")] + private static extern string XGetICValues (IntPtr xic, string name, out EventMask value, IntPtr terminator); + + [DllImport ("libX11", CallingConvention = CallingConvention.Cdecl)] + private static extern void XSetICValues (IntPtr xic, string name, IntPtr value, IntPtr terminator); + + [DllImport ("libX11")] + private static extern void XSetICFocus (IntPtr xic); + + [DllImport ("libX11")] + private static extern void XUnsetICFocus (IntPtr xic); + + [DllImport ("libX11")] + private static extern string Xutf8ResetIC (IntPtr xic); + + [DllImport ("libX11")] + private static extern bool XSupportsLocale (); + + [DllImport ("libX11")] + private static extern bool XSetLocaleModifiers (string mods); + + [DllImport ("libX11")] + internal extern static int XLookupString(ref XEvent xevent, StringBuilder buffer, int num_bytes, out IntPtr keysym, out IntPtr status); + [DllImport ("libX11")] + internal extern static int Xutf8LookupString(IntPtr xic, ref XEvent xevent, byte [] buffer, int num_bytes, out IntPtr keysym, out XLookupStatus status); + + [DllImport ("libX11")] + private static extern IntPtr XGetKeyboardMapping (IntPtr display, byte first_keycode, int keycode_count, + out int keysyms_per_keycode_return); + + [DllImport ("libX11")] + private static extern void XDisplayKeycodes (IntPtr display, out int min, out int max); + + [DllImport ("libX11", EntryPoint="XKeycodeToKeysym")] + private static extern uint XKeycodeToKeysym (IntPtr display, int keycode, int index); + + [DllImport ("libX11")] + private static extern int XKeysymToKeycode (IntPtr display, IntPtr keysym); + private static int XKeysymToKeycode (IntPtr display, int keysym) { + return XKeysymToKeycode(display, (IntPtr)keysym); + } + + [DllImport ("libX11")] + internal extern static IntPtr XGetModifierMapping (IntPtr display); + + [DllImport ("libX11")] + internal extern static int XFreeModifiermap (IntPtr modmap); + + + private readonly static int [] nonchar_key_vkey = new int [] + { + /* unused */ + 0, 0, 0, 0, 0, 0, 0, 0, /* FF00 */ + /* special keys */ + (int) VirtualKeys.VK_BACK, (int) VirtualKeys.VK_TAB, 0, (int) VirtualKeys.VK_CLEAR, 0, (int) VirtualKeys.VK_RETURN, 0, 0, /* FF08 */ + 0, 0, 0, (int) VirtualKeys.VK_PAUSE, (int) VirtualKeys.VK_SCROLL, 0, 0, 0, /* FF10 */ + 0, 0, 0, (int) VirtualKeys.VK_ESCAPE, 0, 0, 0, 0, /* FF18 */ + 0, 0, (int) VirtualKeys.VK_NONCONVERT, (int) VirtualKeys.VK_CONVERT, 0, 0, 0, 0, /* FF20 */ + 0, 0, (int) VirtualKeys.VK_OEM_AUTO, 0, 0, 0, 0, 0, /* FF28 */ + /* unused */ + 0, 0, 0, 0, 0, 0, 0, 0, /* FF30 */ + 0, 0, 0, 0, 0, 0, 0, 0, /* FF38 */ + 0, 0, 0, 0, 0, 0, 0, 0, /* FF40 */ + 0, 0, 0, 0, 0, 0, 0, 0, /* FF48 */ + /* cursor keys */ + (int) VirtualKeys.VK_HOME, (int) VirtualKeys.VK_LEFT, (int) VirtualKeys.VK_UP, (int) VirtualKeys.VK_RIGHT, /* FF50 */ + (int) VirtualKeys.VK_DOWN, (int) VirtualKeys.VK_PRIOR, (int) VirtualKeys.VK_NEXT, (int) VirtualKeys.VK_END, + 0, 0, 0, 0, 0, 0, 0, 0, /* FF58 */ + /* misc keys */ + (int) VirtualKeys.VK_SELECT, (int) VirtualKeys.VK_SNAPSHOT, (int) VirtualKeys.VK_EXECUTE, (int) VirtualKeys.VK_INSERT, 0, 0, 0, 0, /* FF60 */ + (int) VirtualKeys.VK_CANCEL, (int) VirtualKeys.VK_HELP, (int) VirtualKeys.VK_CANCEL, (int) VirtualKeys.VK_CANCEL, 0, 0, 0, 0, /* FF68 */ + 0, 0, 0, 0, 0, 0, 0, 0, /* FF70 */ + /* keypad keys */ + 0, 0, 0, 0, 0, 0, 0, (int) VirtualKeys.VK_NUMLOCK, /* FF78 */ + 0, 0, 0, 0, 0, 0, 0, 0, /* FF80 */ + 0, 0, 0, 0, 0, (int) VirtualKeys.VK_RETURN, 0, 0, /* FF88 */ + 0, 0, 0, 0, 0, (int) VirtualKeys.VK_HOME, (int) VirtualKeys.VK_LEFT, (int) VirtualKeys.VK_UP, /* FF90 */ + (int) VirtualKeys.VK_RIGHT, (int) VirtualKeys.VK_DOWN, (int) VirtualKeys.VK_PRIOR, (int) VirtualKeys.VK_NEXT, /* FF98 */ + (int) VirtualKeys.VK_END, 0, (int) VirtualKeys.VK_INSERT, (int) VirtualKeys.VK_DELETE, + 0, 0, 0, 0, 0, 0, 0, 0, /* FFA0 */ + 0, 0, (int) VirtualKeys.VK_MULTIPLY, (int) VirtualKeys.VK_ADD, /* FFA8 */ + (int) VirtualKeys.VK_SEPARATOR, (int) VirtualKeys.VK_SUBTRACT, (int) VirtualKeys.VK_DECIMAL, (int) VirtualKeys.VK_DIVIDE, + (int) VirtualKeys.VK_NUMPAD0, (int) VirtualKeys.VK_NUMPAD1, (int) VirtualKeys.VK_NUMPAD2, (int) VirtualKeys.VK_NUMPAD3, /* FFB0 */ + (int) VirtualKeys.VK_NUMPAD4, (int) VirtualKeys.VK_NUMPAD5, (int) VirtualKeys.VK_NUMPAD6, (int) VirtualKeys.VK_NUMPAD7, + (int) VirtualKeys.VK_NUMPAD8, (int) VirtualKeys.VK_NUMPAD9, 0, 0, 0, 0, /* FFB8 */ + /* function keys */ + (int) VirtualKeys.VK_F1, (int) VirtualKeys.VK_F2, + (int) VirtualKeys.VK_F3, (int) VirtualKeys.VK_F4, (int) VirtualKeys.VK_F5, (int) VirtualKeys.VK_F6, (int) VirtualKeys.VK_F7, (int) VirtualKeys.VK_F8, (int) VirtualKeys.VK_F9, (int) VirtualKeys.VK_F10, /* FFC0 */ + (int) VirtualKeys.VK_F11, (int) VirtualKeys.VK_F12, (int) VirtualKeys.VK_F13, (int) VirtualKeys.VK_F14, (int) VirtualKeys.VK_F15, (int) VirtualKeys.VK_F16, 0, 0, /* FFC8 */ + 0, 0, 0, 0, 0, 0, 0, 0, /* FFD0 */ + 0, 0, 0, 0, 0, 0, 0, 0, /* FFD8 */ + /* modifier keys */ + 0, (int) VirtualKeys.VK_SHIFT, (int) VirtualKeys.VK_SHIFT, (int) VirtualKeys.VK_CONTROL, /* FFE0 */ + (int) VirtualKeys.VK_CONTROL, (int) VirtualKeys.VK_CAPITAL, 0, (int) VirtualKeys.VK_MENU, + (int) VirtualKeys.VK_MENU, (int) VirtualKeys.VK_MENU, (int) VirtualKeys.VK_MENU, 0, 0, 0, 0, 0, /* FFE8 */ + 0, 0, 0, 0, 0, 0, 0, 0, /* FFF0 */ + 0, 0, 0, 0, 0, 0, 0, (int) VirtualKeys.VK_DELETE /* FFF8 */ + }; + + private static readonly int [] nonchar_key_scan = new int [] + { + /* unused */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FF00 */ + /* special keys */ + 0x0E, 0x0F, 0x00, /*?*/ 0, 0x00, 0x1C, 0x00, 0x00, /* FF08 */ + 0x00, 0x00, 0x00, 0x45, 0x46, 0x00, 0x00, 0x00, /* FF10 */ + 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, /* FF18 */ + /* unused */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FF20 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FF28 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FF30 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FF38 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FF40 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FF48 */ + /* cursor keys */ + 0x147, 0x14B, 0x148, 0x14D, 0x150, 0x149, 0x151, 0x14F, /* FF50 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FF58 */ + /* misc keys */ + /*?*/ 0, 0x137, /*?*/ 0, 0x152, 0x00, 0x00, 0x00, 0x00, /* FF60 */ + /*?*/ 0, /*?*/ 0, 0x38, 0x146, 0x00, 0x00, 0x00, 0x00, /* FF68 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FF70 */ + /* keypad keys */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x138, 0x145, /* FF78 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FF80 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x11C, 0x00, 0x00, /* FF88 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x4B, 0x48, /* FF90 */ + 0x4D, 0x50, 0x49, 0x51, 0x4F, 0x4C, 0x52, 0x53, /* FF98 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FFA0 */ + 0x00, 0x00, 0x37, 0x4E, /*?*/ 0, 0x4A, 0x53, 0x135, /* FFA8 */ + 0x52, 0x4F, 0x50, 0x51, 0x4B, 0x4C, 0x4D, 0x47, /* FFB0 */ + 0x48, 0x49, 0x00, 0x00, 0x00, 0x00, /* FFB8 */ + /* function keys */ + 0x3B, 0x3C, + 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, /* FFC0 */ + 0x57, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FFC8 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FFD0 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FFD8 */ + /* modifier keys */ + 0x00, 0x2A, 0x36, 0x1D, 0x11D, 0x3A, 0x00, 0x38, /* FFE0 */ + 0x138, 0x38, 0x138, 0x00, 0x00, 0x00, 0x00, 0x00, /* FFE8 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* FFF0 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x153 /* FFF8 */ + }; + + private readonly static int [] nonchar_vkey_key = new int [] + { + 0, 0, 0, 0, 0, /* 00-04 */ + 0, 0, 0, (int)XKeySym.XK_BackSpace, (int)XKeySym.XK_Tab, /* 05-09 */ + 0, 0, (int)XKeySym.XK_Clear, (int)XKeySym.XK_Return, 0, 0, /* 0A-0F */ + (int)XKeySym.XK_Shift_L, (int)XKeySym.XK_Control_L, (int)XKeySym.XK_Menu, 0, (int)XKeySym.XK_Caps_Lock, /* 10-14 */ + 0, 0, 0, 0, 0, /* 15-19 */ + 0, 0, 0, 0, 0, 0, /* 1A-1F */ + 0, 0, 0, (int)XKeySym.XK_End, (int)XKeySym.XK_Home, /* 20-24 */ + (int)XKeySym.XK_Left, (int)XKeySym.XK_Up, (int)XKeySym.XK_Right, (int)XKeySym.XK_Down, 0, /* 25-29 */ + 0, 0, 0, 0, 0, 0, /* 2A-2F */ + 0, 0, 0, 0, 0, /* 30-34 */ + 0, 0, 0, 0, 0, /* 35-39 */ + 0, 0, 0, 0, 0, 0, /* 3A-3F */ + 0, 0, 0, 0, 0, /* 40-44 */ + 0, 0, 0, 0, 0, /* 45-49 */ + 0, 0, 0, 0, 0, 0, /* 4A-4F */ + 0, 0, 0, 0, 0, /* 50-54 */ + 0, 0, 0, 0, 0, /* 55-59 */ + 0, (int)XKeySym.XK_Meta_L, (int)XKeySym.XK_Meta_R, 0, 0, 0, /* 5A-5F */ + 0, 0, 0, 0, 0, /* 60-64 */ + 0, 0, 0, 0, 0, /* 65-69 */ + 0, 0, 0, 0, 0, 0, /* 6A-6F */ + 0, 0, 0, 0, 0, /* 70-74 */ + 0, 0, 0, 0, 0, /* 75-79 */ + 0, 0, 0, 0, 0, 0, /* 7A-7F */ + 0, 0, 0, 0, 0, /* 80-84 */ + 0, 0, 0, 0, 0, /* 85-89 */ + 0, 0, 0, 0, 0, 0, /* 8A-8F */ + 0, 0, 0, 0, 0, /* 90-94 */ + 0, 0, 0, 0, 0, /* 95-99 */ + 0, 0, 0, 0, 0, 0, /* 9A-9F */ + (int)XKeySym.XK_Shift_L, (int)XKeySym.XK_Shift_R, (int)XKeySym.XK_Control_L, (int)XKeySym.XK_Control_R, (int)XKeySym.XK_Alt_L, /* A0-A4 */ + (int)XKeySym.XK_Alt_R, 0, 0, 0, 0, /* A5-A9 */ + 0, 0, 0, 0, 0, 0, /* AA-AF */ + 0, 0, 0, 0, 0, /* B0-B4 */ + 0, 0, 0, 0, 0, /* B5-B9 */ + 0, 0, 0, 0, 0, 0, /* BA-BF */ + 0, 0, 0, 0, 0, /* C0-C4 */ + 0, 0, 0, 0, 0, /* C5-C9 */ + 0, 0, 0, 0, 0, 0, /* CA-CF */ + 0, 0, 0, 0, 0, /* D0-D4 */ + 0, 0, 0, 0, 0, /* D5-D9 */ + 0, 0, 0, 0, 0, 0, /* DA-DF */ + 0, 0, 0, 0, 0, /* E0-E4 */ + 0, 0, 0, 0, 0, /* E5-E9 */ + 0, 0, 0, 0, 0, 0, /* EA-EF */ + 0, 0, 0, 0, 0, /* F0-F4 */ + 0, 0, 0, 0, 0, /* F5-F9 */ + 0, 0, 0, 0, 0, 0 /* FA-FF */ + }; + + } + +} + diff --git a/source/ShiftUI/Internal/X11RootHwnd.cs b/source/ShiftUI/Internal/X11RootHwnd.cs new file mode 100644 index 0000000..45a7bee --- /dev/null +++ b/source/ShiftUI/Internal/X11RootHwnd.cs @@ -0,0 +1,87 @@ +// 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) 2006 Novell, Inc. (http://www.novell.com) +// +// + +using System; +using System.Runtime.InteropServices; +using ShiftUI; + +namespace ShiftUI.X11Internal { + + internal class X11RootHwnd : X11Hwnd + { + public X11RootHwnd (X11Display display, IntPtr window_handle) : base (display) + { + WholeWindow = ClientWindow = window_handle; + + Xlib.XSelectInput(display.Handle, WholeWindow, new IntPtr ((int)EventMask.PropertyChangeMask)); + } + + public override void CreateWindow (CreateParams cp) + { + // we don't do anything here + } + + public override void PropertyChanged (XEvent xevent) + { + if (xevent.PropertyEvent.atom == Display.Atoms._NET_ACTIVE_WINDOW) { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + + Xlib.XGetWindowProperty (Display.Handle, WholeWindow, + Display.Atoms._NET_ACTIVE_WINDOW, IntPtr.Zero, new IntPtr (1), false, + Display.Atoms.XA_WINDOW, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + + if (((long)nitems > 0) && (prop != IntPtr.Zero)) { + // FIXME - is this 64 bit clean? + Display.SetActiveWindow ((X11Hwnd)Hwnd.ObjectFromHandle((IntPtr)Marshal.ReadInt32(prop))); + Xlib.XFree(prop); + } + } + else if (xevent.PropertyEvent.atom == Display.Atoms._NET_SUPPORTED) { + // we'll need to refetch the supported protocols list + refetch_net_supported = true; + _net_supported = null; + } + else + base.PropertyChanged (xevent); + } + + bool refetch_net_supported = true; + IntPtr[] _net_supported; + public IntPtr[] _NET_SUPPORTED { + get { + if (refetch_net_supported) { + _net_supported = GetAtomListProperty (Display.Atoms._NET_SUPPORTED); + refetch_net_supported = false; + } + + return _net_supported; + } + } + } + +} + diff --git a/source/ShiftUI/Internal/X11Structs.cs b/source/ShiftUI/Internal/X11Structs.cs new file mode 100644 index 0000000..52bd880 --- /dev/null +++ b/source/ShiftUI/Internal/X11Structs.cs @@ -0,0 +1,1824 @@ +// 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) 2004 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// + + +// NOT COMPLETE + +using System; +using System.ComponentModel; +using System.Collections; +using System.Drawing; +using System.Diagnostics; +using System.Runtime.InteropServices; + +/// X11 Version +using System.Reflection; + + +namespace ShiftUI { + // + // In the structures below, fields of type long are mapped to IntPtr. + // This will work on all platforms where sizeof(long)==sizeof(void*), which + // is almost all platforms except WIN64. + // + + [StructLayout(LayoutKind.Sequential)] + internal struct XAnyEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XKeyEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal IntPtr root; + internal IntPtr subwindow; + internal IntPtr time; + internal int x; + internal int y; + internal int x_root; + internal int y_root; + internal int state; + internal int keycode; + internal bool same_screen; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XButtonEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal IntPtr root; + internal IntPtr subwindow; + internal IntPtr time; + internal int x; + internal int y; + internal int x_root; + internal int y_root; + internal int state; + internal int button; + internal bool same_screen; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XMotionEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal IntPtr root; + internal IntPtr subwindow; + internal IntPtr time; + internal int x; + internal int y; + internal int x_root; + internal int y_root; + internal int state; + internal byte is_hint; + internal bool same_screen; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XCrossingEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal IntPtr root; + internal IntPtr subwindow; + internal IntPtr time; + internal int x; + internal int y; + internal int x_root; + internal int y_root; + internal NotifyMode mode; + internal NotifyDetail detail; + internal bool same_screen; + internal bool focus; + internal int state; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XFocusChangeEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal int mode; + internal NotifyDetail detail; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XKeymapEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal byte key_vector0; + internal byte key_vector1; + internal byte key_vector2; + internal byte key_vector3; + internal byte key_vector4; + internal byte key_vector5; + internal byte key_vector6; + internal byte key_vector7; + internal byte key_vector8; + internal byte key_vector9; + internal byte key_vector10; + internal byte key_vector11; + internal byte key_vector12; + internal byte key_vector13; + internal byte key_vector14; + internal byte key_vector15; + internal byte key_vector16; + internal byte key_vector17; + internal byte key_vector18; + internal byte key_vector19; + internal byte key_vector20; + internal byte key_vector21; + internal byte key_vector22; + internal byte key_vector23; + internal byte key_vector24; + internal byte key_vector25; + internal byte key_vector26; + internal byte key_vector27; + internal byte key_vector28; + internal byte key_vector29; + internal byte key_vector30; + internal byte key_vector31; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XExposeEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal int x; + internal int y; + internal int width; + internal int height; + internal int count; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XGraphicsExposeEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr drawable; + internal int x; + internal int y; + internal int width; + internal int height; + internal int count; + internal int major_code; + internal int minor_code; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XNoExposeEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr drawable; + internal int major_code; + internal int minor_code; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XVisibilityEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal int state; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XCreateWindowEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr parent; + internal IntPtr window; + internal int x; + internal int y; + internal int width; + internal int height; + internal int border_width; + internal bool override_redirect; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XDestroyWindowEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr xevent; + internal IntPtr window; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XUnmapEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr xevent; + internal IntPtr window; + internal bool from_configure; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XMapEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr xevent; + internal IntPtr window; + internal bool override_redirect; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XMapRequestEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr parent; + internal IntPtr window; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XReparentEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr xevent; + internal IntPtr window; + internal IntPtr parent; + internal int x; + internal int y; + internal bool override_redirect; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XConfigureEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr xevent; + internal IntPtr window; + internal int x; + internal int y; + internal int width; + internal int height; + internal int border_width; + internal IntPtr above; + internal bool override_redirect; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XGravityEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr xevent; + internal IntPtr window; + internal int x; + internal int y; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XResizeRequestEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal int width; + internal int height; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XConfigureRequestEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr parent; + internal IntPtr window; + internal int x; + internal int y; + internal int width; + internal int height; + internal int border_width; + internal IntPtr above; + internal int detail; + internal IntPtr value_mask; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XCirculateEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr xevent; + internal IntPtr window; + internal int place; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XCirculateRequestEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr parent; + internal IntPtr window; + internal int place; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XPropertyEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal IntPtr atom; + internal IntPtr time; + internal int state; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XSelectionClearEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal IntPtr selection; + internal IntPtr time; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XSelectionRequestEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr owner; + internal IntPtr requestor; + internal IntPtr selection; + internal IntPtr target; + internal IntPtr property; + internal IntPtr time; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XSelectionEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr requestor; + internal IntPtr selection; + internal IntPtr target; + internal IntPtr property; + internal IntPtr time; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XColormapEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal IntPtr colormap; + internal bool c_new; + internal int state; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XClientMessageEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal IntPtr message_type; + internal int format; + internal IntPtr ptr1; + internal IntPtr ptr2; + internal IntPtr ptr3; + internal IntPtr ptr4; + internal IntPtr ptr5; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XMappingEvent { + internal XEventName type; + internal IntPtr serial; + internal bool send_event; + internal IntPtr display; + internal IntPtr window; + internal int request; + internal int first_keycode; + internal int count; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XErrorEvent { + internal XEventName type; + internal IntPtr display; + internal IntPtr resourceid; + internal IntPtr serial; + internal byte error_code; + internal XRequest request_code; + internal byte minor_code; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XEventPad { + internal IntPtr pad0; + internal IntPtr pad1; + internal IntPtr pad2; + internal IntPtr pad3; + internal IntPtr pad4; + internal IntPtr pad5; + internal IntPtr pad6; + internal IntPtr pad7; + internal IntPtr pad8; + internal IntPtr pad9; + internal IntPtr pad10; + internal IntPtr pad11; + internal IntPtr pad12; + internal IntPtr pad13; + internal IntPtr pad14; + internal IntPtr pad15; + internal IntPtr pad16; + internal IntPtr pad17; + internal IntPtr pad18; + internal IntPtr pad19; + internal IntPtr pad20; + internal IntPtr pad21; + internal IntPtr pad22; + internal IntPtr pad23; + } + + [StructLayout(LayoutKind.Explicit)] + internal struct XEvent { + [ FieldOffset(0) ] internal XEventName type; + [ FieldOffset(0) ] internal XAnyEvent AnyEvent; + [ FieldOffset(0) ] internal XKeyEvent KeyEvent; + [ FieldOffset(0) ] internal XButtonEvent ButtonEvent; + [ FieldOffset(0) ] internal XMotionEvent MotionEvent; + [ FieldOffset(0) ] internal XCrossingEvent CrossingEvent; + [ FieldOffset(0) ] internal XFocusChangeEvent FocusChangeEvent; + [ FieldOffset(0) ] internal XExposeEvent ExposeEvent; + [ FieldOffset(0) ] internal XGraphicsExposeEvent GraphicsExposeEvent; + [ FieldOffset(0) ] internal XNoExposeEvent NoExposeEvent; + [ FieldOffset(0) ] internal XVisibilityEvent VisibilityEvent; + [ FieldOffset(0) ] internal XCreateWindowEvent CreateWindowEvent; + [ FieldOffset(0) ] internal XDestroyWindowEvent DestroyWindowEvent; + [ FieldOffset(0) ] internal XUnmapEvent UnmapEvent; + [ FieldOffset(0) ] internal XMapEvent MapEvent; + [ FieldOffset(0) ] internal XMapRequestEvent MapRequestEvent; + [ FieldOffset(0) ] internal XReparentEvent ReparentEvent; + [ FieldOffset(0) ] internal XConfigureEvent ConfigureEvent; + [ FieldOffset(0) ] internal XGravityEvent GravityEvent; + [ FieldOffset(0) ] internal XResizeRequestEvent ResizeRequestEvent; + [ FieldOffset(0) ] internal XConfigureRequestEvent ConfigureRequestEvent; + [ FieldOffset(0) ] internal XCirculateEvent CirculateEvent; + [ FieldOffset(0) ] internal XCirculateRequestEvent CirculateRequestEvent; + [ FieldOffset(0) ] internal XPropertyEvent PropertyEvent; + [ FieldOffset(0) ] internal XSelectionClearEvent SelectionClearEvent; + [ FieldOffset(0) ] internal XSelectionRequestEvent SelectionRequestEvent; + [ FieldOffset(0) ] internal XSelectionEvent SelectionEvent; + [ FieldOffset(0) ] internal XColormapEvent ColormapEvent; + [ FieldOffset(0) ] internal XClientMessageEvent ClientMessageEvent; + [ FieldOffset(0) ] internal XMappingEvent MappingEvent; + [ FieldOffset(0) ] internal XErrorEvent ErrorEvent; + [ FieldOffset(0) ] internal XKeymapEvent KeymapEvent; + + //[MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=24)] + //[ FieldOffset(0) ] internal int[] pad; + [ FieldOffset(0) ] internal XEventPad Pad; + public override string ToString() { + switch (type) + { + case XEventName.ButtonPress: + case XEventName.ButtonRelease: + return ToString (ButtonEvent); + case XEventName.CirculateNotify: + case XEventName.CirculateRequest: + return ToString (CirculateEvent); + case XEventName.ClientMessage: + return ToString (ClientMessageEvent); + case XEventName.ColormapNotify: + return ToString (ColormapEvent); + case XEventName.ConfigureNotify: + return ToString (ConfigureEvent); + case XEventName.ConfigureRequest: + return ToString (ConfigureRequestEvent); + case XEventName.CreateNotify: + return ToString (CreateWindowEvent); + case XEventName.DestroyNotify: + return ToString (DestroyWindowEvent); + case XEventName.Expose: + return ToString (ExposeEvent); + case XEventName.FocusIn: + case XEventName.FocusOut: + return ToString (FocusChangeEvent); + case XEventName.GraphicsExpose: + return ToString (GraphicsExposeEvent); + case XEventName.GravityNotify: + return ToString (GravityEvent); + case XEventName.KeymapNotify: + return ToString (KeymapEvent); + case XEventName.MapNotify: + return ToString (MapEvent); + case XEventName.MappingNotify: + return ToString (MappingEvent); + case XEventName.MapRequest: + return ToString (MapRequestEvent); + case XEventName.MotionNotify: + return ToString (MotionEvent); + case XEventName.NoExpose: + return ToString (NoExposeEvent); + case XEventName.PropertyNotify: + return ToString (PropertyEvent); + case XEventName.ReparentNotify: + return ToString (ReparentEvent); + case XEventName.ResizeRequest: + return ToString (ResizeRequestEvent); + case XEventName.SelectionClear: + return ToString (SelectionClearEvent); + case XEventName.SelectionNotify: + return ToString (SelectionEvent); + case XEventName.SelectionRequest: + return ToString (SelectionRequestEvent); + case XEventName.UnmapNotify: + return ToString (UnmapEvent); + case XEventName.VisibilityNotify: + return ToString (VisibilityEvent); + case XEventName.EnterNotify: + case XEventName.LeaveNotify: + return ToString (CrossingEvent); + default: + return type.ToString (); + } + } + + public static string ToString (object ev) + { + string result = string.Empty; + Type type = ev.GetType (); + FieldInfo [] fields = type.GetFields (System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Instance); + for (int i = 0; i < fields.Length; i++) { + if (result != string.Empty) { + result += ", "; + } + object value = fields [i].GetValue (ev); + result += fields [i].Name + "=" + (value == null ? "<null>" : value.ToString ()); + } + return type.Name + " (" + result + ")"; + } + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XSetWindowAttributes { + internal IntPtr background_pixmap; + internal IntPtr background_pixel; + internal IntPtr border_pixmap; + internal IntPtr border_pixel; + internal Gravity bit_gravity; + internal Gravity win_gravity; + internal int backing_store; + internal IntPtr backing_planes; + internal IntPtr backing_pixel; + internal bool save_under; + internal IntPtr event_mask; + internal IntPtr do_not_propagate_mask; + internal bool override_redirect; + internal IntPtr colormap; + internal IntPtr cursor; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XWindowAttributes { + internal int x; + internal int y; + internal int width; + internal int height; + internal int border_width; + internal int depth; + internal IntPtr visual; + internal IntPtr root; + internal int c_class; + internal Gravity bit_gravity; + internal Gravity win_gravity; + internal int backing_store; + internal IntPtr backing_planes; + internal IntPtr backing_pixel; + internal bool save_under; + internal IntPtr colormap; + internal bool map_installed; + internal MapState map_state; + internal IntPtr all_event_masks; + internal IntPtr your_event_mask; + internal IntPtr do_not_propagate_mask; + internal bool override_direct; + internal IntPtr screen; + + public override string ToString () + { + return XEvent.ToString (this); + } + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XTextProperty { + internal string value; + internal IntPtr encoding; + internal int format; + internal IntPtr nitems; + } + + internal enum XWindowClass { + InputOutput = 1, + InputOnly = 2 + } + + internal enum XEventName { + KeyPress = 2, + KeyRelease = 3, + ButtonPress = 4, + ButtonRelease = 5, + MotionNotify = 6, + EnterNotify = 7, + LeaveNotify = 8, + FocusIn = 9, + FocusOut = 10, + KeymapNotify = 11, + Expose = 12, + GraphicsExpose = 13, + NoExpose = 14, + VisibilityNotify = 15, + CreateNotify = 16, + DestroyNotify = 17, + UnmapNotify = 18, + MapNotify = 19, + MapRequest = 20, + ReparentNotify = 21, + ConfigureNotify = 22, + ConfigureRequest = 23, + GravityNotify = 24, + ResizeRequest = 25, + CirculateNotify = 26, + CirculateRequest = 27, + PropertyNotify = 28, + SelectionClear = 29, + SelectionRequest = 30, + SelectionNotify = 31, + ColormapNotify = 32, + ClientMessage = 33, + MappingNotify = 34, + + LASTEvent + } + + [Flags] + internal enum SetWindowValuemask { + Nothing = 0, + BackPixmap = 1, + BackPixel = 2, + BorderPixmap = 4, + BorderPixel = 8, + BitGravity = 16, + WinGravity = 32, + BackingStore = 64, + BackingPlanes = 128, + BackingPixel = 256, + OverrideRedirect = 512, + SaveUnder = 1024, + EventMask = 2048, + DontPropagate = 4096, + ColorMap = 8192, + Cursor = 16384 + } + + internal enum SendEventValues { + PointerWindow = 0, + InputFocus = 1 + } + + internal enum CreateWindowArgs { + CopyFromParent = 0, + ParentRelative = 1, + InputOutput = 1, + InputOnly = 2 + } + + internal enum Gravity { + ForgetGravity = 0, + NorthWestGravity= 1, + NorthGravity = 2, + NorthEastGravity= 3, + WestGravity = 4, + CenterGravity = 5, + EastGravity = 6, + SouthWestGravity= 7, + SouthGravity = 8, + SouthEastGravity= 9, + StaticGravity = 10 + } + + internal enum XKeySym : uint { + XK_BackSpace = 0xFF08, + XK_Tab = 0xFF09, + XK_Clear = 0xFF0B, + XK_Return = 0xFF0D, + XK_Home = 0xFF50, + XK_Left = 0xFF51, + XK_Up = 0xFF52, + XK_Right = 0xFF53, + XK_Down = 0xFF54, + XK_Page_Up = 0xFF55, + XK_Page_Down = 0xFF56, + XK_End = 0xFF57, + XK_Begin = 0xFF58, + XK_Menu = 0xFF67, + XK_Shift_L = 0xFFE1, + XK_Shift_R = 0xFFE2, + XK_Control_L = 0xFFE3, + XK_Control_R = 0xFFE4, + XK_Caps_Lock = 0xFFE5, + XK_Shift_Lock = 0xFFE6, + XK_Meta_L = 0xFFE7, + XK_Meta_R = 0xFFE8, + XK_Alt_L = 0xFFE9, + XK_Alt_R = 0xFFEA, + XK_Super_L = 0xFFEB, + XK_Super_R = 0xFFEC, + XK_Hyper_L = 0xFFED, + XK_Hyper_R = 0xFFEE, + } + + [Flags] + internal enum EventMask { + NoEventMask = 0, + KeyPressMask = 1<<0, + KeyReleaseMask = 1<<1, + ButtonPressMask = 1<<2, + ButtonReleaseMask = 1<<3, + EnterWindowMask = 1<<4, + LeaveWindowMask = 1<<5, + PointerMotionMask = 1<<6, + PointerMotionHintMask = 1<<7, + Button1MotionMask = 1<<8, + Button2MotionMask = 1<<9, + Button3MotionMask = 1<<10, + Button4MotionMask = 1<<11, + Button5MotionMask = 1<<12, + ButtonMotionMask = 1<<13, + KeymapStateMask = 1<<14, + ExposureMask = 1<<15, + VisibilityChangeMask = 1<<16, + StructureNotifyMask = 1<<17, + ResizeRedirectMask = 1<<18, + SubstructureNotifyMask = 1<<19, + SubstructureRedirectMask= 1<<20, + FocusChangeMask = 1<<21, + PropertyChangeMask = 1<<22, + ColormapChangeMask = 1<<23, + OwnerGrabButtonMask = 1<<24 + } + + internal enum GrabMode { + GrabModeSync = 0, + GrabModeAsync = 1 + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XStandardColormap { + internal IntPtr colormap; + internal IntPtr red_max; + internal IntPtr red_mult; + internal IntPtr green_max; + internal IntPtr green_mult; + internal IntPtr blue_max; + internal IntPtr blue_mult; + internal IntPtr base_pixel; + internal IntPtr visualid; + internal IntPtr killid; + } + + [StructLayout(LayoutKind.Sequential, Pack=2)] + internal struct XColor { + internal IntPtr pixel; + internal ushort red; + internal ushort green; + internal ushort blue; + internal byte flags; + internal byte pad; + } + + internal enum Atom { + AnyPropertyType = 0, + XA_PRIMARY = 1, + XA_SECONDARY = 2, + XA_ARC = 3, + XA_ATOM = 4, + XA_BITMAP = 5, + XA_CARDINAL = 6, + XA_COLORMAP = 7, + XA_CURSOR = 8, + XA_CUT_BUFFER0 = 9, + XA_CUT_BUFFER1 = 10, + XA_CUT_BUFFER2 = 11, + XA_CUT_BUFFER3 = 12, + XA_CUT_BUFFER4 = 13, + XA_CUT_BUFFER5 = 14, + XA_CUT_BUFFER6 = 15, + XA_CUT_BUFFER7 = 16, + XA_DRAWABLE = 17, + XA_FONT = 18, + XA_INTEGER = 19, + XA_PIXMAP = 20, + XA_POINT = 21, + XA_RECTANGLE = 22, + XA_RESOURCE_MANAGER = 23, + XA_RGB_COLOR_MAP = 24, + XA_RGB_BEST_MAP = 25, + XA_RGB_BLUE_MAP = 26, + XA_RGB_DEFAULT_MAP = 27, + XA_RGB_GRAY_MAP = 28, + XA_RGB_GREEN_MAP = 29, + XA_RGB_RED_MAP = 30, + XA_STRING = 31, + XA_VISUALID = 32, + XA_WINDOW = 33, + XA_WM_COMMAND = 34, + XA_WM_HINTS = 35, + XA_WM_CLIENT_MACHINE = 36, + XA_WM_ICON_NAME = 37, + XA_WM_ICON_SIZE = 38, + XA_WM_NAME = 39, + XA_WM_NORMAL_HINTS = 40, + XA_WM_SIZE_HINTS = 41, + XA_WM_ZOOM_HINTS = 42, + XA_MIN_SPACE = 43, + XA_NORM_SPACE = 44, + XA_MAX_SPACE = 45, + XA_END_SPACE = 46, + XA_SUPERSCRIPT_X = 47, + XA_SUPERSCRIPT_Y = 48, + XA_SUBSCRIPT_X = 49, + XA_SUBSCRIPT_Y = 50, + XA_UNDERLINE_POSITION = 51, + XA_UNDERLINE_THICKNESS = 52, + XA_STRIKEOUT_ASCENT = 53, + XA_STRIKEOUT_DESCENT = 54, + XA_ITALIC_ANGLE = 55, + XA_X_HEIGHT = 56, + XA_QUAD_WIDTH = 57, + XA_WEIGHT = 58, + XA_POINT_SIZE = 59, + XA_RESOLUTION = 60, + XA_COPYRIGHT = 61, + XA_NOTICE = 62, + XA_FONT_NAME = 63, + XA_FAMILY_NAME = 64, + XA_FULL_NAME = 65, + XA_CAP_HEIGHT = 66, + XA_WM_CLASS = 67, + XA_WM_TRANSIENT_FOR = 68, + + XA_LAST_PREDEFINED = 68 + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XScreen { + internal IntPtr ext_data; + internal IntPtr display; + internal IntPtr root; + internal int width; + internal int height; + internal int mwidth; + internal int mheight; + internal int ndepths; + internal IntPtr depths; + internal int root_depth; + internal IntPtr root_visual; + internal IntPtr default_gc; + internal IntPtr cmap; + internal IntPtr white_pixel; + internal IntPtr black_pixel; + internal int max_maps; + internal int min_maps; + internal int backing_store; + internal bool save_unders; + internal IntPtr root_input_mask; + } + + [Flags] + internal enum ChangeWindowFlags { + CWX = 1<<0, + CWY = 1<<1, + CWWidth = 1<<2, + CWHeight = 1<<3, + CWBorderWidth = 1<<4, + CWSibling = 1<<5, + CWStackMode = 1<<6 + } + + internal enum StackMode { + Above = 0, + Below = 1, + TopIf = 2, + BottomIf = 3, + Opposite = 4 + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XWindowChanges { + internal int x; + internal int y; + internal int width; + internal int height; + internal int border_width; + internal IntPtr sibling; + internal StackMode stack_mode; + } + + [Flags] + internal enum ColorFlags { + DoRed = 1<<0, + DoGreen = 1<<1, + DoBlue = 1<<2 + } + + internal enum NotifyMode { + NotifyNormal = 0, + NotifyGrab = 1, + NotifyUngrab = 2 + } + + internal enum NotifyDetail { + NotifyAncestor = 0, + NotifyVirtual = 1, + NotifyInferior = 2, + NotifyNonlinear = 3, + NotifyNonlinearVirtual = 4, + NotifyPointer = 5, + NotifyPointerRoot = 6, + NotifyDetailNone = 7 + } + + [StructLayout(LayoutKind.Sequential)] + internal struct MotifWmHints { + internal IntPtr flags; + internal IntPtr functions; + internal IntPtr decorations; + internal IntPtr input_mode; + internal IntPtr status; + + public override string ToString () + { + return string.Format("MotifWmHints <flags={0}, functions={1}, decorations={2}, input_mode={3}, status={4}", (MotifFlags) flags.ToInt32 (), (MotifFunctions) functions.ToInt32 (), (MotifDecorations) decorations.ToInt32 (), (MotifInputMode) input_mode.ToInt32 (), status.ToInt32 ()); + } + } + + [Flags] + internal enum MotifFlags { + Functions = 1, + Decorations = 2, + InputMode = 4, + Status = 8 + } + + [Flags] + internal enum MotifFunctions { + All = 0x01, + Resize = 0x02, + Move = 0x04, + Minimize = 0x08, + Maximize = 0x10, + Close = 0x20 + } + + [Flags] + internal enum MotifDecorations { + All = 0x01, + Border = 0x02, + ResizeH = 0x04, + Title = 0x08, + Menu = 0x10, + Minimize = 0x20, + Maximize = 0x40, + + } + + [Flags] + internal enum MotifInputMode { + Modeless = 0, + ApplicationModal = 1, + SystemModal = 2, + FullApplicationModal = 3 + } + + [Flags] + internal enum KeyMasks { + ShiftMask = (1 << 0), + LockMask = (1 << 1), + ControlMask = (1 << 2), + Mod1Mask = (1 << 3), + Mod2Mask = (1 << 4), + Mod3Mask = (1 << 5), + Mod4Mask = (1 << 6), + Mod5Mask = (1 << 7), + + ModMasks = Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask + } + + [Flags] + internal enum MouseKeyMasks { + Button1Mask = (1 << 8), + Button2Mask = (1 << 9), + Button3Mask = (1 << 10), + Button4Mask = (1 << 11), + Button5Mask = (1 << 12), + } + + [StructLayout (LayoutKind.Sequential)] + internal struct XModifierKeymap { + public int max_keypermod; + public IntPtr modifiermap; + } + + internal enum PropertyMode { + Replace = 0, + Prepend = 1, + Append = 2 + } + + [StructLayout (LayoutKind.Sequential)] + internal struct XKeyBoardState { + public int key_click_percent; + public int bell_percent; + public uint bell_pitch, bell_duration; + public IntPtr led_mask; + public int global_auto_repeat; + public AutoRepeats auto_repeats; + + [StructLayout (LayoutKind.Explicit)] + public struct AutoRepeats { + [FieldOffset (0)] + public byte first; + + [FieldOffset (31)] + public byte last; + } + } + + [Flags] + internal enum GCFunction { + GCFunction = 1<<0, + GCPlaneMask = 1<<1, + GCForeground = 1<<2, + GCBackground = 1<<3, + GCLineWidth = 1<<4, + GCLineStyle = 1<<5, + GCCapStyle = 1<<6, + GCJoinStyle = 1<<7, + GCFillStyle = 1<<8, + GCFillRule = 1<<9, + GCTile = 1<<10, + GCStipple = 1<<11, + GCTileStipXOrigin = 1<<12, + GCTileStipYOrigin = 1<<13, + GCFont = 1<<14, + GCSubwindowMode = 1<<15, + GCGraphicsExposures = 1<<16, + GCClipXOrigin = 1<<17, + GCClipYOrigin = 1<<18, + GCClipMask = 1<<19, + GCDashOffset = 1<<20, + GCDashList = 1<<21, + GCArcMode = 1<<22 + } + + internal enum GCJoinStyle { + JoinMiter = 0, + JoinRound = 1, + JoinBevel = 2 + } + + internal enum GCLineStyle { + LineSolid = 0, + LineOnOffDash = 1, + LineDoubleDash = 2 + } + + internal enum GCCapStyle { + CapNotLast = 0, + CapButt = 1, + CapRound = 2, + CapProjecting = 3 + } + + internal enum GCFillStyle { + FillSolid = 0, + FillTiled = 1, + FillStippled = 2, + FillOpaqueStppled = 3 + } + + internal enum GCFillRule { + EvenOddRule = 0, + WindingRule = 1 + } + + internal enum GCArcMode { + ArcChord = 0, + ArcPieSlice = 1 + } + + internal enum GCSubwindowMode { + ClipByChildren = 0, + IncludeInferiors = 1 + } + + [StructLayout (LayoutKind.Sequential)] + internal struct XGCValues { + internal GXFunction function; + internal IntPtr plane_mask; + internal IntPtr foreground; + internal IntPtr background; + internal int line_width; + internal GCLineStyle line_style; + internal GCCapStyle cap_style; + internal GCJoinStyle join_style; + internal GCFillStyle fill_style; + internal GCFillRule fill_rule; + internal GCArcMode arc_mode; + internal IntPtr tile; + internal IntPtr stipple; + internal int ts_x_origin; + internal int ts_y_origin; + internal IntPtr font; + internal GCSubwindowMode subwindow_mode; + internal bool graphics_exposures; + internal int clip_x_origin; + internal int clib_y_origin; + internal IntPtr clip_mask; + internal int dash_offset; + internal byte dashes; + } + + internal enum GXFunction { + GXclear = 0x0, /* 0 */ + GXand = 0x1, /* src AND dst */ + GXandReverse = 0x2, /* src AND NOT dst */ + GXcopy = 0x3, /* src */ + GXandInverted = 0x4, /* NOT src AND dst */ + GXnoop = 0x5, /* dst */ + GXxor = 0x6, /* src XOR dst */ + GXor = 0x7, /* src OR dst */ + GXnor = 0x8, /* NOT src AND NOT dst */ + GXequiv = 0x9, /* NOT src XOR dst */ + GXinvert = 0xa, /* NOT dst */ + GXorReverse = 0xb, /* src OR NOT dst */ + GXcopyInverted = 0xc, /* NOT src */ + GXorInverted = 0xd, /* NOT src OR dst */ + GXnand = 0xe, /* NOT src OR NOT dst */ + GXset = 0xf /* 1 */ + } + + internal enum NetWindowManagerState { + Remove = 0, + Add = 1, + Toggle = 2 + } + + internal enum RevertTo { + None = 0, + PointerRoot = 1, + Parent = 2 + } + + internal enum MapState { + IsUnmapped = 0, + IsUnviewable = 1, + IsViewable = 2 + } + + internal enum CursorFontShape { + XC_X_cursor = 0, + XC_arrow = 2, + XC_based_arrow_down = 4, + XC_based_arrow_up = 6, + XC_boat = 8, + XC_bogosity = 10, + XC_bottom_left_corner = 12, + XC_bottom_right_corner = 14, + XC_bottom_side = 16, + XC_bottom_tee = 18, + XC_box_spiral = 20, + XC_center_ptr = 22, + + XC_circle = 24, + XC_clock = 26, + XC_coffee_mug = 28, + XC_cross = 30, + XC_cross_reverse = 32, + XC_crosshair = 34, + XC_diamond_cross = 36, + XC_dot = 38, + XC_dotbox = 40, + XC_double_arrow = 42, + XC_draft_large = 44, + XC_draft_small = 46, + + XC_draped_box = 48, + XC_exchange = 50, + XC_fleur = 52, + XC_gobbler = 54, + XC_gumby = 56, + XC_hand1 = 58, + XC_hand2 = 60, + XC_heart = 62, + XC_icon = 64, + XC_iron_cross = 66, + XC_left_ptr = 68, + XC_left_side = 70, + + XC_left_tee = 72, + XC_left_button = 74, + XC_ll_angle = 76, + XC_lr_angle = 78, + XC_man = 80, + XC_middlebutton = 82, + XC_mouse = 84, + XC_pencil = 86, + XC_pirate = 88, + XC_plus = 90, + XC_question_arrow = 92, + XC_right_ptr = 94, + + XC_right_side = 96, + XC_right_tee = 98, + XC_rightbutton = 100, + XC_rtl_logo = 102, + XC_sailboat = 104, + XC_sb_down_arrow = 106, + XC_sb_h_double_arrow = 108, + XC_sb_left_arrow = 110, + XC_sb_right_arrow = 112, + XC_sb_up_arrow = 114, + XC_sb_v_double_arrow = 116, + XC_sb_shuttle = 118, + + XC_sizing = 120, + XC_spider = 122, + XC_spraycan = 124, + XC_star = 126, + XC_target = 128, + XC_tcross = 130, + XC_top_left_arrow = 132, + XC_top_left_corner = 134, + XC_top_right_corner = 136, + XC_top_side = 138, + XC_top_tee = 140, + XC_trek = 142, + + XC_ul_angle = 144, + XC_umbrella = 146, + XC_ur_angle = 148, + XC_watch = 150, + XC_xterm = 152, + XC_num_glyphs = 154 + } + + internal enum SystrayRequest { + SYSTEM_TRAY_REQUEST_DOCK = 0, + SYSTEM_TRAY_BEGIN_MESSAGE = 1, + SYSTEM_TRAY_CANCEL_MESSAGE = 2 + } + + internal enum NetWmStateRequest { + _NET_WM_STATE_REMOVE = 0, + _NET_WM_STATE_ADD = 1, + _NET_WM_STATE_TOGGLE = 2 + } + + internal enum NetWmMoveResize { + _NET_WM_MOVERESIZE_SIZE_TOPLEFT = 0, + _NET_WM_MOVERESIZE_SIZE_TOP = 1, + _NET_WM_MOVERESIZE_SIZE_TOPRIGHT = 2, + _NET_WM_MOVERESIZE_SIZE_RIGHT = 3, + _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT = 4, + _NET_WM_MOVERESIZE_SIZE_BOTTOM = 5, + _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT = 6, + _NET_WM_MOVERESIZE_SIZE_LEFT = 7, + _NET_WM_MOVERESIZE_MOVE = 8, + _NET_WM_MOVERESIZE_SIZE_KEYBOARD = 9, + _NET_WM_MOVERESIZE_MOVE_KEYBOARD = 10, + _NET_WM_MOVERESIZE_CANCEL = 11 + } + + [Flags] + internal enum XSizeHintsFlags { + USPosition = (1 << 0), + USSize = (1 << 1), + PPosition = (1 << 2), + PSize = (1 << 3), + PMinSize = (1 << 4), + PMaxSize = (1 << 5), + PResizeInc = (1 << 6), + PAspect = (1 << 7), + PAllHints = (PPosition | PSize | PMinSize | PMaxSize | PResizeInc | PAspect), + PBaseSize = (1 << 8), + PWinGravity = (1 << 9), + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XSizeHints { + internal IntPtr flags; + internal int x; + internal int y; + internal int width; + internal int height; + internal int min_width; + internal int min_height; + internal int max_width; + internal int max_height; + internal int width_inc; + internal int height_inc; + internal int min_aspect_x; + internal int min_aspect_y; + internal int max_aspect_x; + internal int max_aspect_y; + internal int base_width; + internal int base_height; + internal int win_gravity; + } + + [Flags] + internal enum XWMHintsFlags { + InputHint = (1 << 0), + StateHint = (1 << 1), + IconPixmapHint = (1 << 2), + IconWindowHint = (1 << 3), + IconPositionHint = (1 << 4), + IconMaskHint = (1 << 5), + WindowGroupHint = (1 << 6), + AllHints = (InputHint | StateHint | IconPixmapHint | IconWindowHint | IconPositionHint | IconMaskHint | WindowGroupHint) + } + + internal enum XInitialState { + DontCareState = 0, + NormalState = 1, + ZoomState = 2, + IconicState = 3, + InactiveState = 4 + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XWMHints { + internal IntPtr flags; + internal bool input; + internal XInitialState initial_state; + internal IntPtr icon_pixmap; + internal IntPtr icon_window; + internal int icon_x; + internal int icon_y; + internal IntPtr icon_mask; + internal IntPtr window_group; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct XIconSize { + internal int min_width; + internal int min_height; + internal int max_width; + internal int max_height; + internal int width_inc; + internal int height_inc; + } + + internal struct CaretStruct { + internal Timer Timer; // Blink interval + internal IntPtr Hwnd; // Window owning the caret + internal IntPtr Window; // Actual X11 handle of the window + internal int X; // X position of the caret + internal int Y; // Y position of the caret + internal int Width; // Width of the caret; if no image used + internal int Height; // Height of the caret, if no image used + internal bool Visible; // Is caret visible? + internal bool On; // Caret blink display state: On/Off + internal IntPtr gc; // Graphics context + internal bool Paused; // Don't update right now + } + + internal struct HoverStruct { + internal Timer Timer; // for hovering + internal IntPtr Window; // Last window we entered; used to generate WM_MOUSEHOVER (handle is X11 handle) + internal int X; // Last MouseMove X coordinate; used to generate WM_MOUSEHOVER + internal int Y; // Last MouseMove Y coordinate; used to generate WM_MOUSEHOVER + internal Size Size; // Size of the rectangle the mouse has to stay in to generate hover + internal int Interval; // in milliseconds, how long to hold before hover is generated + internal IntPtr Atom; // X Atom + } + + internal struct ClickStruct { + internal IntPtr Hwnd; // + internal Msg Message; // + internal IntPtr wParam; // + internal IntPtr lParam; // + internal long Time; // Last time we received a mouse click + internal bool Pending; // True if we haven't sent the last mouse click + } + + internal struct GrabStruct { + internal bool Confined; // Is the current grab (if any) confined to grab_area? + internal IntPtr Hwnd; // The window that is grabbed + internal Rectangle Area; // The area the current grab is confined to + } + + internal delegate int XErrorHandler(IntPtr DisplayHandle, ref XErrorEvent error_event); + + internal enum XRequest : byte { + X_CreateWindow = 1, + X_ChangeWindowAttributes = 2, + X_GetWindowAttributes = 3, + X_DestroyWindow = 4, + X_DestroySubwindows = 5, + X_ChangeSaveSet = 6, + X_ReparentWindow = 7, + X_MapWindow = 8, + X_MapSubwindows = 9, + X_UnmapWindow = 10, + X_UnmapSubwindows = 11, + X_ConfigureWindow = 12, + X_CirculateWindow = 13, + X_GetGeometry = 14, + X_QueryTree = 15, + X_InternAtom = 16, + X_GetAtomName = 17, + X_ChangeProperty = 18, + X_DeleteProperty = 19, + X_GetProperty = 20, + X_ListProperties = 21, + X_SetSelectionOwner = 22, + X_GetSelectionOwner = 23, + X_ConvertSelection = 24, + X_SendEvent = 25, + X_GrabPointer = 26, + X_UngrabPointer = 27, + X_GrabButton = 28, + X_UngrabButton = 29, + X_ChangeActivePointerGrab = 30, + X_GrabKeyboard = 31, + X_UngrabKeyboard = 32, + X_GrabKey = 33, + X_UngrabKey = 34, + X_AllowEvents = 35, + X_GrabServer = 36, + X_UngrabServer = 37, + X_QueryPointer = 38, + X_GetMotionEvents = 39, + X_TranslateCoords = 40, + X_WarpPointer = 41, + X_SetInputFocus = 42, + X_GetInputFocus = 43, + X_QueryKeymap = 44, + X_OpenFont = 45, + X_CloseFont = 46, + X_QueryFont = 47, + X_QueryTextExtents = 48, + X_ListFonts = 49, + X_ListFontsWithInfo = 50, + X_SetFontPath = 51, + X_GetFontPath = 52, + X_CreatePixmap = 53, + X_FreePixmap = 54, + X_CreateGC = 55, + X_ChangeGC = 56, + X_CopyGC = 57, + X_SetDashes = 58, + X_SetClipRectangles = 59, + X_FreeGC = 60, + X_ClearArea = 61, + X_CopyArea = 62, + X_CopyPlane = 63, + X_PolyPoint = 64, + X_PolyLine = 65, + X_PolySegment = 66, + X_PolyRectangle = 67, + X_PolyArc = 68, + X_FillPoly = 69, + X_PolyFillRectangle = 70, + X_PolyFillArc = 71, + X_PutImage = 72, + X_GetImage = 73, + X_PolyText8 = 74, + X_PolyText16 = 75, + X_ImageText8 = 76, + X_ImageText16 = 77, + X_CreateColormap = 78, + X_FreeColormap = 79, + X_CopyColormapAndFree = 80, + X_InstallColormap = 81, + X_UninstallColormap = 82, + X_ListInstalledColormaps = 83, + X_AllocColor = 84, + X_AllocNamedColor = 85, + X_AllocColorCells = 86, + X_AllocColorPlanes = 87, + X_FreeColors = 88, + X_StoreColors = 89, + X_StoreNamedColor = 90, + X_QueryColors = 91, + X_LookupColor = 92, + X_CreateCursor = 93, + X_CreateGlyphCursor = 94, + X_FreeCursor = 95, + X_RecolorCursor = 96, + X_QueryBestSize = 97, + X_QueryExtension = 98, + X_ListExtensions = 99, + X_ChangeKeyboardMapping = 100, + X_GetKeyboardMapping = 101, + X_ChangeKeyboardWidget = 102, + X_GetKeyboardWidget = 103, + X_Bell = 104, + X_ChangePointerWidget = 105, + X_GetPointerWidget = 106, + X_SetScreenSaver = 107, + X_GetScreenSaver = 108, + X_ChangeHosts = 109, + X_ListHosts = 110, + X_SetAccessWidget = 111, + X_SetCloseDownMode = 112, + X_KillClient = 113, + X_RotateProperties = 114, + X_ForceScreenSaver = 115, + X_SetPointerMapping = 116, + X_GetPointerMapping = 117, + X_SetModifierMapping = 118, + X_GetModifierMapping = 119, + X_NoOperation = 127 + } + + [Flags] + internal enum XIMProperties { + XIMPreeditArea = 0x0001, + XIMPreeditCallbacks = 0x0002, + XIMPreeditPosition = 0x0004, + XIMPreeditNothing = 0x0008, + XIMPreeditNone = 0x0010, + XIMStatusArea = 0x0100, + XIMStatusCallbacks = 0x0200, + XIMStatusNothing = 0x0400, + XIMStatusNone = 0x0800, + } + + [Flags] + internal enum WindowType { + Client = 1, + Whole = 2, + Both = 3 + } + + internal enum XEmbedMessage { + EmbeddedNotify = 0, + WindowActivate = 1, + WindowDeactivate = 2, + RequestFocus = 3, + FocusIn = 4, + FocusOut = 5, + FocusNext = 6, + FocusPrev = 7, + /* 8-9 were used for XEMBED_GRAB_KEY/XEMBED_UNGRAB_KEY */ + ModalityOn = 10, + ModalityOff = 11, + RegisterAccelerator = 12, + UnregisterAccelerator = 13, + ActivateAccelerator = 14 + } + + [StructLayout (LayoutKind.Sequential)] + internal struct XcursorImage + { + private int version; + public int size; /* nominal size for matching */ + public int width; /* actual width */ + public int height; /* actual height */ + public int xhot; /* hot spot x (must be inside image) */ + public int yhot; /* hot spot y (must be inside image) */ + public int delay; /* hot spot y (must be inside image) */ + public IntPtr pixels; /* pointer to pixels */ + + public override string ToString () + { + return string.Format ("XCursorImage (version: {0}, size: {1}, width: {2}, height: {3}, xhot: {4}, yhot: {5}, delay: {6}, pixels: {7}", + version, size, width, height, xhot, yhot, delay, pixels); + } + } ; + + [StructLayout (LayoutKind.Sequential)] + internal struct XcursorImages + { + public int nimage; /* number of images */ + public IntPtr images; /* array of XcursorImage pointers */ + } + + [StructLayout (LayoutKind.Sequential)] + internal struct XIMStyles + { + public ushort count_styles; + public IntPtr supported_styles; + } + + [StructLayout (LayoutKind.Sequential)] + [Serializable] + internal class XPoint + { + public short X; + public short Y; + } + + [StructLayout (LayoutKind.Sequential)] + [Serializable] + internal class XIMCallback + { + public IntPtr client_data; + public XIMProc callback; + [NonSerialized] + GCHandle gch; + + public XIMCallback (IntPtr clientData, XIMProc proc) + { + this.client_data = clientData; + this.gch = GCHandle.Alloc (proc); + this.callback = proc; + } + + ~XIMCallback () + { + gch.Free (); + } + } + + internal enum XIMFeedback + { + Reverse = 1, + Underline = 2, + Highlight = 4, + Primary = 32, + Secondary = 64, + Tertiary = 128, + } + + internal struct XIMFeedbackStruct + { + public byte FeedbackMask; // one or more of XIMFeedback enum + } + + internal struct XIMText + { + public ushort Length; + public IntPtr Feedback; // to XIMFeedbackStruct + public bool EncodingIsWChar; + public IntPtr String; // it could be either char* or wchar_t* + } + + internal struct XIMPreeditDrawCallbackStruct + { + public int Caret; + public int ChangeFirst; + public int ChangeLength; + public IntPtr Text; // to XIMText + } + + internal enum XIMCaretDirection + { + XIMForwardChar, + XIMBackwardChar, + XIMForwardWord, + XIMBackwardWord, + XIMCaretUp, + XIMCaretDown, + XIMNextLine, + XIMPreviousLine, + XIMLineStart, + XIMLineEnd, + XIMAbsolutePosition, + XIMDontChange + } + + internal enum XIMCaretStyle + { + IsInvisible, + IsPrimary, + IsSecondary + } + + internal struct XIMPreeditCaretCallbackStruct + { + public int Position; + public XIMCaretDirection Direction; + public XIMCaretStyle Style; + } + + // only PreeditStartCallback requires return value though. + internal delegate int XIMProc (IntPtr xim, IntPtr clientData, IntPtr callData); + + internal static class XNames + { + public const string XNVaNestedList = "XNVaNestedList"; + public const string XNQueryInputStyle = "queryInputStyle"; + public const string XNClientWindow = "clientWindow"; + public const string XNInputStyle = "inputStyle"; + public const string XNFocusWindow = "focusWindow"; + + // XIMPreeditCallbacks delegate names. + public const string XNPreeditStartCallback = "preeditStartCallback"; + public const string XNPreeditDoneCallback = "preeditDoneCallback"; + public const string XNPreeditDrawCallback = "preeditDrawCallback"; + public const string XNPreeditCaretCallback = "preeditCaretCallback"; + public const string XNPreeditStateNotifyCallback = "preeditStateNotifyCallback"; + public const string XNPreeditAttributes = "preeditAttributes"; + // XIMStatusCallbacks delegate names. + public const string XNStatusStartCallback = "statusStartCallback"; + public const string XNStatusDoneCallback = "statusDoneCallback"; + public const string XNStatusDrawCallback = "statusDrawCallback"; + public const string XNStatusAttributes = "statusAttributes"; + + public const string XNArea = "area"; + public const string XNAreaNeeded = "areaNeeded"; + public const string XNSpotLocation = "spotLocation"; + public const string XNFontSet = "fontSet"; + } + + [StructLayout (LayoutKind.Sequential)] + internal struct XineramaScreenInfo + { + public int screen_number; + public short x_org; + public short y_org; + public short width; + public short height; + } +} diff --git a/source/ShiftUI/Internal/X11ThreadQueue.cs b/source/ShiftUI/Internal/X11ThreadQueue.cs new file mode 100644 index 0000000..b68d74c --- /dev/null +++ b/source/ShiftUI/Internal/X11ThreadQueue.cs @@ -0,0 +1,502 @@ +// 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) 2004-2006 Novell, Inc. +// +// Authors: +// Jackson Harper ([email protected]) +// Peter Dennis Bartok ([email protected]) +// Chris Toshok ([email protected]) +// + +using System; +using System.Threading; +using System.Collections; + +namespace ShiftUI.X11Internal { + + internal class X11ThreadQueue { + + XEventQueue xqueue; + PaintQueue paint_queue; + ConfigureQueue configure_queue; + ArrayList timer_list; + Thread thread; + bool quit_posted; + bool dispatch_idle; + bool need_dispatch_idle = true; + object lockobj = new object (); + + static readonly int InitialXEventQueueSize = 128; + static readonly int InitialHwndQueueSize = 50; + + public X11ThreadQueue (Thread thread) + { + xqueue = new XEventQueue (InitialXEventQueueSize); + paint_queue = new PaintQueue (InitialHwndQueueSize); + configure_queue = new ConfigureQueue (InitialHwndQueueSize); + timer_list = new ArrayList (); + this.thread = thread; + this.quit_posted = false; + this.dispatch_idle = true; + } + + public int CountUnlocked { + get { return xqueue.Count + paint_queue.Count; } + } + + public Thread Thread { + get { return thread; } + } + + public void EnqueueUnlocked (XEvent xevent) + { + switch (xevent.type) { + case XEventName.KeyPress: + case XEventName.KeyRelease: + case XEventName.ButtonPress: + case XEventName.ButtonRelease: + NeedDispatchIdle = true; + break; + case XEventName.MotionNotify: + if (xqueue.Count > 0) { + XEvent peek = xqueue.Peek (); + if (peek.AnyEvent.type == XEventName.MotionNotify) + return; // we've already got a pending motion notify. + } + + // otherwise fall through and enqueue + // the event. + break; + } + + xqueue.Enqueue (xevent); + // wake up any thread blocking in DequeueUnlocked + Monitor.PulseAll (lockobj); + } + + public void Enqueue (XEvent xevent) + { + lock (lockobj) { + EnqueueUnlocked (xevent); + } + } + + public bool Dequeue (out XEvent xevent) + { + StartOver: + bool got_xevent = false; + + lock (lockobj) { + if (xqueue.Count > 0) { + got_xevent = true; + xevent = xqueue.Dequeue (); + } + else + xevent = new XEvent (); /* not strictly needed, but mcs complains */ + } + + if (got_xevent) { + if (xevent.AnyEvent.type == XEventName.Expose) { +#if spew + Console.Write ("E"); + Console.Out.Flush (); +#endif + X11Hwnd hwnd = (X11Hwnd)Hwnd.GetObjectFromWindow (xevent.AnyEvent.window); + hwnd.AddExpose (xevent.AnyEvent.window == hwnd.ClientWindow, + xevent.ExposeEvent.x, xevent.ExposeEvent.y, + xevent.ExposeEvent.width, xevent.ExposeEvent.height); + goto StartOver; + } + else if (xevent.AnyEvent.type == XEventName.ConfigureNotify) { +#if spew + Console.Write ("C"); + Console.Out.Flush (); +#endif + X11Hwnd hwnd = (X11Hwnd)Hwnd.GetObjectFromWindow (xevent.AnyEvent.window); + hwnd.AddConfigureNotify (xevent); + goto StartOver; + } + else { +#if spew + Console.Write ("X"); + Console.Out.Flush (); +#endif + /* it was an event we can deal with directly, return it */ + return true; + } + } + else { + if (paint_queue.Count > 0) { + xevent = paint_queue.Dequeue (); +#if spew + Console.Write ("e"); + Console.Out.Flush (); +#endif + return true; + } + else if (configure_queue.Count > 0) { + xevent = configure_queue.Dequeue (); +#if spew + Console.Write ("c"); + Console.Out.Flush (); +#endif + return true; + } + } + + if (dispatch_idle && need_dispatch_idle) { + OnIdle (EventArgs.Empty); + need_dispatch_idle = false; + } + + lock (lockobj) { + if (CountUnlocked > 0) + goto StartOver; + + if (Monitor.Wait (lockobj, NextTimeout (), true)) { + // the lock was reaquired before the + // timeout. meaning an event was + // enqueued by X11Display.XEventThread. + goto StartOver; + } + else { + CheckTimers (); + return false; + } + } + } + + public void RemovePaint (Hwnd hwnd) + { + paint_queue.Remove (hwnd); + } + + public void AddPaint (Hwnd hwnd) + { + paint_queue.Enqueue (hwnd); + } + + public void AddConfigure (Hwnd hwnd) + { + configure_queue.Enqueue (hwnd); + } + + public ConfigureQueue Configure { + get { return configure_queue; } + } + + public PaintQueue Paint { + get { return paint_queue; } + } + + public void Lock () + { + Monitor.Enter (lockobj); + } + + public void Unlock () + { + Monitor.Exit (lockobj); + } + + private int NextTimeout () + { + int timeout = Int32.MaxValue; + DateTime now = DateTime.UtcNow; + + foreach (Timer timer in timer_list) { + int next = (int) (timer.Expires - now).TotalMilliseconds; + if (next < 0) + return 0; // Have a timer that has already expired + + if (next < timeout) + timeout = next; + } + + if (timeout < Timer.Minimum) { + timeout = Timer.Minimum; + } + + if (timeout == Int32.MaxValue) + timeout = Timeout.Infinite; + + return timeout; + } + + public void CheckTimers () + { + int count; + DateTime now = DateTime.UtcNow; + + count = timer_list.Count; + + if (count == 0) + return; + + for (int i = 0; i < timer_list.Count; i++) { + Timer timer; + + timer = (Timer) timer_list [i]; + + if (timer.Enabled && timer.Expires <= now) { + timer.Update (now); + timer.FireTick (); + } + } + } + + public void SetTimer (Timer timer) + { + lock (lockobj) { + timer_list.Add (timer); + + // we need to wake up any thread waiting in DequeueUnlocked, + // since it might need to wait for a different amount of time. + Monitor.PulseAll (lockobj); + } + + } + + public void KillTimer (Timer timer) + { + lock (lockobj) { + timer_list.Remove (timer); + + // we need to wake up any thread waiting in DequeueUnlocked, + // since it might need to wait for a different amount of time. + Monitor.PulseAll (lockobj); + } + } + + public event EventHandler Idle; + public void OnIdle (EventArgs e) + { + if (Idle != null) + Idle (thread, e); + } + + public bool NeedDispatchIdle { + get { return need_dispatch_idle; } + set { need_dispatch_idle = value; } + } + + public bool DispatchIdle { + get { return dispatch_idle; } + set { dispatch_idle = value; } + } + + public bool PostQuitState { + get { return quit_posted; } + set { quit_posted = value; } + } + + public abstract class HwndEventQueue { + protected ArrayList hwnds; +#if DebugHwndEventQueue + protected ArrayList stacks; +#endif + public HwndEventQueue (int size) + { + hwnds = new ArrayList (size); +#if DebugHwndEventQueue + stacks = new ArrayList (size); +#endif + } + + public int Count { + get { return hwnds.Count; } + } + + public void Enqueue (Hwnd hwnd) + { + if (hwnds.Contains (hwnd)) { +#if DebugHwndEventQueue + Console.WriteLine ("hwnds can only appear in the queue once."); + Console.WriteLine (Environment.StackTrace); + Console.WriteLine ("originally added here:"); + Console.WriteLine (stacks[hwnds.IndexOf (hwnd)]); +#endif + + return; + } + hwnds.Add(hwnd); +#if DebugHwndEventQueue + stacks.Add(Environment.StackTrace); +#endif + } + + public void Remove(Hwnd hwnd) + { +#if DebugHwndEventQueue + int index = hwnds.IndexOf(hwnd); + if (index != -1) + stacks.RemoveAt(index); +#endif + hwnds.Remove(hwnd); + } + + protected abstract XEvent Peek (); + + public virtual XEvent Dequeue () + { + if (hwnds.Count == 0) + throw new Exception ("Attempt to dequeue empty queue."); + + return Peek (); + } + } + + + public class ConfigureQueue : HwndEventQueue + { + public ConfigureQueue (int size) : base (size) + { + } + + protected override XEvent Peek () + { + X11Hwnd hwnd = (X11Hwnd)hwnds[0]; + + XEvent xevent = new XEvent (); + xevent.AnyEvent.type = XEventName.ConfigureNotify; + + xevent.ConfigureEvent.window = hwnd.ClientWindow; + xevent.ConfigureEvent.x = hwnd.X; + xevent.ConfigureEvent.y = hwnd.Y; + xevent.ConfigureEvent.width = hwnd.Width; + xevent.ConfigureEvent.height = hwnd.Height; + + return xevent; + } + + public override XEvent Dequeue () + { + XEvent xev = base.Dequeue (); + + + hwnds.RemoveAt(0); +#if DebugHwndEventQueue + stacks.RemoveAt(0); +#endif + + return xev; + } + } + + public class PaintQueue : HwndEventQueue + { + public PaintQueue (int size) : base (size) + { + } + + protected override XEvent Peek () + { + X11Hwnd hwnd = (X11Hwnd)hwnds[0]; + + XEvent xevent = new XEvent (); + + xevent.AnyEvent.type = XEventName.Expose; + + if (hwnd.PendingExpose) { + xevent.ExposeEvent.window = hwnd.ClientWindow; + } else { + xevent.ExposeEvent.window = hwnd.WholeWindow; + xevent.ExposeEvent.x = hwnd.nc_invalid.X; + xevent.ExposeEvent.y = hwnd.nc_invalid.Y; + xevent.ExposeEvent.width = hwnd.nc_invalid.Width; + xevent.ExposeEvent.height = hwnd.nc_invalid.Height; + } + + return xevent; + } + + // don't override Dequeue like ConfigureQueue does. + } + + /* a circular queue for holding X events for processing by GetMessage */ + private class XEventQueue { + + XEvent[] xevents; + int head; + int tail; + int size; + + public XEventQueue (int initial_size) + { + if (initial_size % 2 != 0) + throw new Exception ("XEventQueue must be a power of 2 size"); + + xevents = new XEvent [initial_size]; + } + + public int Count { + get { return size; } + } + + public void Enqueue (XEvent xevent) + { + if (size == xevents.Length) + Grow (); + + xevents [tail] = xevent; + tail = (tail + 1) & (xevents.Length - 1); + size++; + } + + public XEvent Dequeue () + { + if (size < 1) + throw new Exception ("Attempt to dequeue empty queue."); + + XEvent res = xevents [head]; + head = (head + 1) & (xevents.Length - 1); + size--; + return res; + } + + public XEvent Peek() + { + if (size < 1) + throw new Exception ("Attempt to peek at empty queue."); + + return xevents[head]; + } + + private void Grow () + { + int newcap = (xevents.Length * 2); + XEvent [] na = new XEvent [newcap]; + + if (head + size > xevents.Length) { + Array.Copy (xevents, head, na, 0, xevents.Length - head); + Array.Copy (xevents, 0, na, xevents.Length - head, head + size - xevents.Length); + } + else { + Array.Copy (xevents, head, na, 0, size); + } + + xevents = na; + head = 0; + tail = head + size; + } + } + } +} + diff --git a/source/ShiftUI/Internal/XEventQueue.cs b/source/ShiftUI/Internal/XEventQueue.cs new file mode 100644 index 0000000..526c14c --- /dev/null +++ b/source/ShiftUI/Internal/XEventQueue.cs @@ -0,0 +1,261 @@ +// 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) 2004-2006 Novell, Inc. +// +// ShiftUI.XEventQueue +// +// Authors: +// Jackson Harper ([email protected]) +// Peter Dennis Bartok ([email protected]) +// + +using System; +using System.Threading; +using System.Collections; + +namespace ShiftUI { + + internal class XEventQueue { + + private XQueue xqueue; + private XQueue lqueue; // Events inserted from threads other then the main X thread + private PaintQueue paint; // Paint-only queue + internal ArrayList timer_list; + private Thread thread; + private bool dispatch_idle; + + private static readonly int InitialXEventSize = 100; + private static readonly int InitialLXEventSize = 10; + private static readonly int InitialPaintSize = 50; + + public XEventQueue (Thread thread) { + xqueue = new XQueue (InitialXEventSize); + lqueue = new XQueue (InitialLXEventSize); + paint = new PaintQueue(InitialPaintSize); + timer_list = new ArrayList (); + this.thread = thread; + this.dispatch_idle = true; + } + + public int Count { + get { + lock (lqueue) { + return xqueue.Count + lqueue.Count; + } + } + } + + public PaintQueue Paint { + get { + return paint; + } + } + + public Thread Thread { + get { + return thread; + } + } + + public void Enqueue (XEvent xevent) + { + if (Thread.CurrentThread != thread) { + Console.WriteLine ("Hwnd.Queue.Enqueue called from a different thread without locking."); + Console.WriteLine (Environment.StackTrace); + } + + xqueue.Enqueue (xevent); + } + + public void EnqueueLocked (XEvent xevent) + { + lock (lqueue) { + lqueue.Enqueue (xevent); + } + } + + public XEvent Dequeue () + { + if (Thread.CurrentThread != thread) { + Console.WriteLine ("Hwnd.Queue.Dequeue called from a different thread without locking."); + Console.WriteLine (Environment.StackTrace); + } + + if (xqueue.Count == 0) { + lock (lqueue) { + return lqueue.Dequeue (); + } + } + return xqueue.Dequeue (); + } + + public XEvent Peek() + { + if (Thread.CurrentThread != thread) { + Console.WriteLine ("Hwnd.Queue.Peek called from a different thread without locking."); + Console.WriteLine (Environment.StackTrace); + } + + if (xqueue.Count == 0) { + lock (lqueue) { + return lqueue.Peek (); + } + } + return xqueue.Peek (); + } + + public bool DispatchIdle { + get { + return dispatch_idle; + } + set { + dispatch_idle = value; + } + } + + public class PaintQueue { + + private ArrayList hwnds; + private XEvent xevent; + + public PaintQueue (int size) { + hwnds = new ArrayList (size); + xevent = new XEvent (); + xevent.AnyEvent.type = XEventName.Expose; + } + + public int Count { + get { + lock (hwnds) { + return hwnds.Count; + } + } + } + + public void Enqueue (Hwnd hwnd) { + lock (hwnds) { + hwnds.Add (hwnd); + } + } + + public void Remove(Hwnd hwnd) { + if (!hwnd.expose_pending && !hwnd.nc_expose_pending) { + lock (hwnds) { + hwnds.Remove (hwnd); + } + } + } + + public XEvent Dequeue () { + Hwnd hwnd; + IEnumerator next; + + lock (hwnds) { + if (hwnds.Count == 0) { + xevent.ExposeEvent.window = IntPtr.Zero; + return xevent; + } + + next = hwnds.GetEnumerator (); + next.MoveNext (); + hwnd = (Hwnd)next.Current; + + // We only remove the event from the queue if we have one expose left since + // a single 'entry in our queue may be for both NC and Client exposed + if (!(hwnd.nc_expose_pending && hwnd.expose_pending)) { + hwnds.Remove (hwnd); + } + if (hwnd.expose_pending) { + xevent.ExposeEvent.window = hwnd.client_window; +#if not + xevent.ExposeEvent.x = hwnd.invalid.X; + xevent.ExposeEvent.y = hwnd.invalid.Y; + xevent.ExposeEvent.width = hwnd.invalid.Width; + xevent.ExposeEvent.height = hwnd.invalid.Height; +#endif + return xevent; + } else { + xevent.ExposeEvent.window = hwnd.whole_window; + xevent.ExposeEvent.x = hwnd.nc_invalid.X; + xevent.ExposeEvent.y = hwnd.nc_invalid.Y; + xevent.ExposeEvent.width = hwnd.nc_invalid.Width; + xevent.ExposeEvent.height = hwnd.nc_invalid.Height; + return xevent; + } + } + } + } + + private class XQueue { + + private XEvent [] xevents; + private int head; + private int tail; + private int size; + + public XQueue (int size) + { + xevents = new XEvent [size]; + } + + public int Count { + get { return size; } + } + + public void Enqueue (XEvent xevent) + { + if (size == xevents.Length) + Grow (); + + xevents [tail] = xevent; + tail = (tail + 1) % xevents.Length; + size++; + } + + public XEvent Dequeue () + { + if (size < 1) + throw new Exception ("Attempt to dequeue empty queue."); + XEvent res = xevents [head]; + head = (head + 1) % xevents.Length; + size--; + return res; + } + + public XEvent Peek() { + if (size < 1) { + throw new Exception ("Attempt to peek at empty queue"); + } + return xevents[head]; + } + + private void Grow () + { + int newcap = (xevents.Length * 2); + XEvent [] na = new XEvent [newcap]; + xevents.CopyTo (na, 0); + xevents = na; + head = 0; + tail = head + size; + } + } + } +} + diff --git a/source/ShiftUI/Internal/Xlib.cs b/source/ShiftUI/Internal/Xlib.cs new file mode 100644 index 0000000..5eebd7e --- /dev/null +++ b/source/ShiftUI/Internal/Xlib.cs @@ -0,0 +1,350 @@ +// 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) 2006 Novell, Inc. (http://www.novell.com) +// +// + +using System; +using System.Text; +using System.Runtime.InteropServices; + +namespace ShiftUI.X11Internal { + + internal class Xlib { + const string libX11 = "X11"; + + [DllImport (libX11)] + public extern static IntPtr XOpenDisplay(IntPtr display); + + [DllImport (libX11)] + public extern static int XCloseDisplay(IntPtr display); + + [DllImport (libX11)] + public extern static IntPtr XSynchronize(IntPtr display, bool onoff); + + [DllImport (libX11)] + public extern static IntPtr XCreateWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, int depth, int xclass, IntPtr visual, UIntPtr valuemask, ref XSetWindowAttributes attributes); + + [DllImport (libX11)] + public extern static IntPtr XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background); + + [DllImport (libX11)] + public extern static int XMapWindow(IntPtr display, IntPtr window); + + [DllImport (libX11)] + public extern static int XUnmapWindow(IntPtr display, IntPtr window); + + [DllImport (libX11)] + public extern static int XMapSubindows(IntPtr display, IntPtr window); + + [DllImport (libX11)] + public extern static int XUnmapSubwindows(IntPtr display, IntPtr window); + + [DllImport (libX11)] + public extern static IntPtr XRootWindow(IntPtr display, int screen_number); + + [DllImport (libX11)] + public extern static IntPtr XNextEvent(IntPtr display, ref XEvent xevent); + + [DllImport (libX11)] + public extern static int XConnectionNumber (IntPtr diplay); + + [DllImport (libX11)] + public extern static int XPending (IntPtr diplay); + + [DllImport (libX11)] + public extern static IntPtr XSelectInput(IntPtr display, IntPtr window, IntPtr mask); + + [DllImport (libX11)] + public extern static int XDestroyWindow(IntPtr display, IntPtr window); + + [DllImport (libX11)] + public extern static int XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y); + + [DllImport (libX11)] + public extern static int XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height); + + [DllImport (libX11)] + public extern static int XResizeWindow(IntPtr display, IntPtr window, int width, int height); + + [DllImport (libX11)] + public extern static int XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes); + + [DllImport (libX11)] + public extern static int XFlush(IntPtr display); + + [DllImport (libX11)] + public extern static int XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop); + + [DllImport (libX11)] + public extern static int XStoreName(IntPtr display, IntPtr window, string window_name); + + [DllImport (libX11)] + public extern static int XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name); + + [DllImport (libX11)] + public extern static int XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event); + + [DllImport (libX11)] + public extern static int XQueryTree(IntPtr display, IntPtr window, out IntPtr root_return, out IntPtr parent_return, out IntPtr children_return, out int nchildren_return); + + [DllImport (libX11)] + public extern static int XFree(IntPtr data); + + [DllImport (libX11)] + public extern static int XRaiseWindow(IntPtr display, IntPtr window); + + [DllImport (libX11)] + public extern static uint XLowerWindow(IntPtr display, IntPtr window); + + [DllImport (libX11)] + public extern static uint XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values); + + [DllImport (libX11)] + public extern static IntPtr XInternAtom(IntPtr display, string atom_name, bool only_if_exists); + + [DllImport (libX11)] + public extern static int XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms); + + [DllImport (libX11)] + public extern static int XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count); + + [DllImport (libX11)] + public extern static int XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp); + + [DllImport (libX11)] + public extern static int XUngrabPointer(IntPtr display, IntPtr timestamp); + + [DllImport (libX11)] + public extern static bool XQueryPointer(IntPtr display, IntPtr window, out IntPtr root, out IntPtr child, out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons); + + [DllImport (libX11)] + public extern static bool XTranslateCoordinates (IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return); + + [DllImport (libX11)] + public extern static bool XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y, out int width, out int height, out int border_width, out int depth); + + [DllImport (libX11)] + public extern static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, out int width, out int height, IntPtr border_width, IntPtr depth); + + [DllImport (libX11)] + public extern static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, IntPtr width, IntPtr height, IntPtr border_width, IntPtr depth); + + [DllImport (libX11)] + public extern static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, IntPtr x, IntPtr y, out int width, out int height, IntPtr border_width, IntPtr depth); + + [DllImport (libX11)] + public extern static uint XWarpPointer(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, uint src_width, uint src_height, int dest_x, int dest_y); + + [DllImport (libX11)] + public extern static int XClearWindow(IntPtr display, IntPtr window); + + [DllImport (libX11)] + public extern static int XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures); + + // Colormaps + [DllImport (libX11)] + public extern static IntPtr XDefaultScreenOfDisplay(IntPtr display); + + [DllImport (libX11)] + public extern static int XScreenNumberOfScreen(IntPtr display, IntPtr Screen); + + [DllImport (libX11)] + public extern static IntPtr XDefaultVisual(IntPtr display, int screen_number); + + [DllImport (libX11)] + public extern static uint XDefaultDepth(IntPtr display, int screen_number); + + [DllImport (libX11)] + public extern static int XDefaultScreen(IntPtr display); + + [DllImport (libX11)] + public extern static IntPtr XDefaultColormap(IntPtr display, int screen_number); + + [DllImport (libX11)] + public extern static int XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color); + + [DllImport (libX11)] + public extern static int XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def); + + [DllImport (libX11)] + public extern static int XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window); + + [DllImport (libX11)] + public extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements); + + [DllImport (libX11)] + public extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements); + + [DllImport (libX11)] + public extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements); + + [DllImport (libX11)] + public extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements); + + [DllImport (libX11)] + public extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements); + + [DllImport (libX11)] + public extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements); + + [DllImport (libX11)] + public extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements); + + [DllImport (libX11, CharSet=CharSet.Ansi)] + public extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length); + + [DllImport (libX11)] + public extern static int XDeleteProperty(IntPtr display, IntPtr window, IntPtr property); + + // Drawing + [DllImport (libX11)] + public extern static IntPtr XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values); + + [DllImport (libX11)] + public extern static int XFreeGC(IntPtr display, IntPtr gc); + + [DllImport (libX11)] + public extern static int XSetFunction(IntPtr display, IntPtr gc, GXFunction function); + + [DllImport (libX11)] + internal extern static int XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style); + + [DllImport (libX11)] + public extern static int XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2); + + [DllImport (libX11)] + public extern static int XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height); + + [DllImport (libX11)] + public extern static int XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height); + + [DllImport (libX11)] + public extern static int XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background); + + [DllImport (libX11)] + public extern static int XCopyArea(IntPtr display, IntPtr src, IntPtr dest, IntPtr gc, int src_x, int src_y, int width, int height, int dest_x, int dest_y); + + [DllImport (libX11)] + public extern static int XGetWindowProperty(IntPtr display, IntPtr window, IntPtr atom, IntPtr long_offset, IntPtr long_length, bool delete, IntPtr req_type, out IntPtr actual_type, out int actual_format, out IntPtr nitems, out IntPtr bytes_after, ref IntPtr prop); + + [DllImport (libX11)] + public extern static int XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time); + + [DllImport (libX11)] + public extern static int XIconifyWindow(IntPtr display, IntPtr window, int screen_number); + + [DllImport (libX11)] + public extern static int XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor); + + [DllImport (libX11)] + public extern static int XUndefineCursor(IntPtr display, IntPtr window); + + [DllImport (libX11)] + public extern static int XFreeCursor(IntPtr display, IntPtr cursor); + + [DllImport (libX11)] + public extern static IntPtr XCreateFontCursor(IntPtr display, CursorFontShape shape); + + [DllImport (libX11)] + public extern static IntPtr XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot); + + [DllImport (libX11)] + public extern static IntPtr XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth); + + [DllImport (libX11)] + public extern static IntPtr XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth); + + [DllImport (libX11)] + public extern static IntPtr XFreePixmap(IntPtr display, IntPtr pixmap); + + [DllImport (libX11)] + public extern static int XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height); + + [DllImport (libX11)] + public extern static IntPtr XWhitePixel(IntPtr display, int screen_no); + + [DllImport (libX11)] + public extern static IntPtr XBlackPixel(IntPtr display, int screen_no); + + [DllImport (libX11)] + public extern static void XGrabServer(IntPtr display); + + [DllImport (libX11)] + public extern static void XUngrabServer(IntPtr display); + + [DllImport (libX11)] + public extern static void XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return); + + [DllImport (libX11)] + public extern static void XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints); + + [DllImport (libX11)] + public extern static void XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints); + + [DllImport (libX11)] + public extern static void XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints); + + [DllImport (libX11)] + public extern static int XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count); + + [DllImport (libX11)] + public extern static IntPtr XSetErrorHandler(XErrorHandler error_handler); + + [DllImport (libX11)] + public extern static IntPtr XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length); + + [DllImport (libX11)] + public extern static int XInitThreads(); + + [DllImport (libX11)] + public extern static int XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time); + + [DllImport (libX11)] + public extern static IntPtr XGetSelectionOwner(IntPtr display, IntPtr selection); + + [DllImport (libX11)] + public extern static int XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time); + + [DllImport (libX11)] + public extern static int XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask); + + [DllImport (libX11)] + public extern static int XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground); + + [DllImport (libX11)] + public extern static int XSetBackground(IntPtr display, IntPtr gc, UIntPtr background); + + [DllImport (libX11)] + public extern static int XBell(IntPtr display, int percent); + + [DllImport (libX11)] + public extern static int XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time); + + [DllImport (libX11)] + public extern static bool XFilterEvent(ref XEvent xevent, IntPtr window); + + [DllImport (libX11)] + public extern static void XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported); + + [DllImport (libX11)] + public extern static void XPeekEvent (IntPtr display, ref XEvent xevent); + } +} diff --git a/source/ShiftUI/Internal/XplatUI.cs b/source/ShiftUI/Internal/XplatUI.cs new file mode 100644 index 0000000..afa3ddb --- /dev/null +++ b/source/ShiftUI/Internal/XplatUI.cs @@ -0,0 +1,1235 @@ +// 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) 2004-2006 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] + +// NOT COMPLETE + +// define to log API calls to stdout +#undef DriverDebug +#undef DriverDebugPaint +#undef DriverDebugCreate +#undef DriverDebugDestroy +#undef DriverDebugState + +using System; +using System.Drawing; +using System.ComponentModel; +using System.Collections; +using System.Diagnostics; +using System.Runtime.InteropServices; +using System.Threading; + +namespace ShiftUI { + internal class XplatUI { + #region Local Variables + static XplatUIDriver driver; + //static String default_class_name; + internal static ArrayList key_filters = new ArrayList (); + #endregion // Local Variables + + public static string DefaultClassName { + get { return GetDefaultClassName(); } + } + + #region Private Methods + internal static string Window (IntPtr handle) + { + return String.Format ("'{0}' ({1:X})", Widget.FromHandle (handle), handle.ToInt32 ()); + } + + [Conditional ("DriverDebug")] + static void DriverDebug (string format, params object [] args) + { + Console.WriteLine (String.Format (format, args)); + } + + #endregion // Private Methods + + #region Subclasses + public class State { + static public Keys ModifierKeys { + get { + return driver.ModifierKeys; + } + } + + static public MouseButtons MouseButtons { + get { + return driver.MouseButtons; + } + } + + static public Point MousePosition { + get { + return driver.MousePosition; + } + } + + } + #endregion // Subclasses + + #region Constructor & Destructor + static XplatUI () + { + // Compose name with current domain id because on Win32 we register class name + // and name must be unique to process. If we load MWF into multiple appdomains + // and try to register same class name we fail. + //default_class_name = "SWFClass" + System.Threading.Thread.GetDomainID ().ToString (); + try { + if (RunningOnUnix) { + //if (Environment.GetEnvironmentVariable ("not_supported_MONO_MWF_USE_NEW_X11_BACKEND") != null) { + // driver=XplatUIX11_new.GetInstance (); + //} else + if (Environment.GetEnvironmentVariable ("MONO_MWF_MAC_FORCE_X11") != null) { + driver = XplatUIX11.GetInstance (); + } else { + IntPtr buf = Marshal.AllocHGlobal (8192); + // This is a hacktastic way of getting sysname from uname () + if (uname (buf) != 0) { + // WTF: We cannot run uname + driver=XplatUIX11.GetInstance (); + } else { + string os = Marshal.PtrToStringAnsi (buf); + if (os == "Darwin") + driver=XplatUICarbon.GetInstance (); + else + driver=XplatUIX11.GetInstance (); + } + Marshal.FreeHGlobal (buf); + } + } else { + driver=XplatUIWin32.GetInstance (); + } + + driver.InitializeDriver (); + + // Initialize things that need to be done after the driver is ready + DataFormats.GetFormat (0); + + // Signal that the Application loop can be run. + // This allows UIA to initialize a11y support for MWF + // before the main loop begins. + Application.FirePreRun (); + } + catch (Exception ex) { + Console.WriteLine ("[ShiftUI/XplatUI] Driver init error: {0}", ex.Message); + } + } + #endregion // Constructor & Destructor + + #region Public Static Properties + + public static bool RunningOnUnix { + get { + int p = (int) Environment.OSVersion.Platform; + + return (p == 4 || p == 6 || p == 128); + } + } + + public static int ActiveWindowTrackingDelay { + get { return driver.ActiveWindowTrackingDelay; } + } + + // Compose name with current domain id because on Win32 we register class name + // and name must be unique to process. If we load MWF into multiple appdomains + // and try to register same class name we fail. + internal static string GetDefaultClassName (Type type) + { + return "SWFClass" + Thread.GetDomainID ().ToString () + "." + type.ToString (); + } + + // Generate a class name using current domain and a random number. + internal static string GetDefaultClassName () + { + return "SWFClass" + Thread.GetDomainID ().ToString () + "." + new Random().Next(0, 9999999).ToString(); + } + + + static public Size Border3DSize { + get { + return driver.Border3DSize; + } + } + + static public Size BorderSize { + get { + return driver.BorderSize; + } + } + + static public Size CaptionButtonSize { + get { + return driver.CaptionButtonSize; + } + } + + static public int CaptionHeight { + get { + return driver.CaptionHeight; + } + } + + public static int CaretBlinkTime { get { return driver.CaretBlinkTime; } } + public static int CaretWidth { get { return driver.CaretWidth; } } + + static public Size CursorSize { + get { + return driver.CursorSize; + } + } + + static public Size DoubleClickSize { + get { + return driver.DoubleClickSize; + } + } + + static public int DoubleClickTime { + get { + return driver.DoubleClickTime; + } + } + + static public bool DragFullWindows { + get { + return driver.DragFullWindows; + } + } + + static public Size DragSize { + get { + return driver.DragSize; + } + } + + static public Size FixedFrameBorderSize { + get { + return driver.FixedFrameBorderSize; + } + } + + public static int FontSmoothingContrast { get { return driver.FontSmoothingContrast; } } + public static int FontSmoothingType { get { return driver.FontSmoothingType; } } + + public static Size FrameBorderSize { + get { + return driver.FrameBorderSize; + } + } + + public static int HorizontalResizeBorderThickness { get { return driver.HorizontalResizeBorderThickness; } } + + static public int HorizontalScrollBarHeight { + get { + return driver.HorizontalScrollBarHeight; + } + } + + static public Size IconSize { + get { + return driver.IconSize; + } + } + + public static bool IsActiveWindowTrackingEnabled { get { return driver.IsActiveWindowTrackingEnabled; } } + public static bool IsComboBoxAnimationEnabled { get { return driver.IsComboBoxAnimationEnabled; } } + public static bool IsDropShadowEnabled { get { return driver.IsDropShadowEnabled; } } + public static bool IsFontSmoothingEnabled { get { return driver.IsFontSmoothingEnabled; } } + public static bool IsHotTrackingEnabled { get { return driver.IsHotTrackingEnabled; } } + public static bool IsIconTitleWrappingEnabled { get { return driver.IsIconTitleWrappingEnabled; } } + public static bool IsKeyboardPreferred { get { return driver.IsKeyboardPreferred; } } + public static bool IsListBoxSmoothScrollingEnabled { get { return driver.IsListBoxSmoothScrollingEnabled; } } + public static bool IsMenuAnimationEnabled { get { return driver.IsMenuAnimationEnabled; } } + public static bool IsMenuFadeEnabled { get { return driver.IsMenuFadeEnabled; } } + public static bool IsMinimizeRestoreAnimationEnabled { get { return driver.IsMinimizeRestoreAnimationEnabled; } } + public static bool IsSelectionFadeEnabled { get { return driver.IsSelectionFadeEnabled; } } + public static bool IsSnapToDefaultEnabled { get { return driver.IsSnapToDefaultEnabled; } } + public static bool IsTitleBarGradientEnabled { get { return driver.IsTitleBarGradientEnabled; } } + public static bool IsToolTipAnimationEnabled { get { return driver.IsToolTipAnimationEnabled; } } + + static public int KeyboardSpeed { + get { + return driver.KeyboardSpeed; + } + } + + static public int KeyboardDelay { + get { + return driver.KeyboardDelay; + } + } + + static public Size MaxWindowTrackSize { + get { + return driver.MaxWindowTrackSize; + } + } + + static public bool MenuAccessKeysUnderlined { + get { + return driver.MenuAccessKeysUnderlined; + } + } + + static public Size MenuBarButtonSize { get { return driver.MenuBarButtonSize; } } + + public static Size MenuButtonSize { + get { + return driver.MenuButtonSize; + } + } + + static public int MenuShowDelay { get { return driver.MenuShowDelay; } } + + static public Size MinimizedWindowSize { + get { + return driver.MinimizedWindowSize; + } + } + + static public Size MinimizedWindowSpacingSize { + get { + return driver.MinimizedWindowSpacingSize; + } + } + + static public Size MinimumWindowSize { + get { + return driver.MinimumWindowSize; + } + } + + static public Size MinimumFixedToolWindowSize { + get { return driver.MinimumFixedToolWindowSize; } + } + + static public Size MinimumSizeableToolWindowSize { + get { return driver.MinimumSizeableToolWindowSize; } + } + + static public Size MinimumNoBorderWindowSize { + get { return driver.MinimumNoBorderWindowSize; } + } + + static public Size MinWindowTrackSize { + get { + return driver.MinWindowTrackSize; + } + } + + public static int MouseSpeed { + get { return driver.MouseSpeed; } + } + + static public Size SmallIconSize { + get { + return driver.SmallIconSize; + } + } + + static public int MenuHeight { + get { + return driver.MenuHeight; + } + } + + static public int MouseButtonCount { + get { + return driver.MouseButtonCount; + } + } + + static public bool MouseButtonsSwapped { + get { + return driver.MouseButtonsSwapped; + } + } + + static public Size MouseHoverSize { + get { + return driver.MouseHoverSize; + } + } + + static public int MouseHoverTime { + get { + return driver.MouseHoverTime; + } + } + + static public int MouseWheelScrollDelta { + get { + return driver.MouseWheelScrollDelta; + } + } + + static public bool MouseWheelPresent { + get { + return driver.MouseWheelPresent; + } + } + + public static LeftRightAlignment PopupMenuAlignment { + get { return driver.PopupMenuAlignment; } + } + + public static PowerStatus PowerStatus { + get { return driver.PowerStatus; } + } + + public static bool RequiresPositiveClientAreaSize { + get { + return driver.RequiresPositiveClientAreaSize; + } + } + + public static int SizingBorderWidth { + get { return driver.SizingBorderWidth; } + } + + public static Size SmallCaptionButtonSize { + get { return driver.SmallCaptionButtonSize; } + } + + public static bool UIEffectsEnabled { + get { return driver.UIEffectsEnabled; } + } + + static public bool UserClipWontExposeParent { + get { + return driver.UserClipWontExposeParent; + } + } + + public static int VerticalResizeBorderThickness { get { return driver.VerticalResizeBorderThickness; } } + + static public int VerticalScrollBarWidth { + get { + return driver.VerticalScrollBarWidth; + } + } + + static public Rectangle VirtualScreen { + get { + return driver.VirtualScreen; + } + } + + static public Rectangle WorkingArea { + get { + return driver.WorkingArea; + } + } + + public static Screen[] AllScreens { + get { + return driver.AllScreens; + } + } + + public static bool ThemesEnabled { + get { + return XplatUI.driver.ThemesEnabled; + } + } + + public static int ToolWindowCaptionHeight { + get { + return driver.ToolWindowCaptionHeight; + } + } + + public static Size ToolWindowCaptionButtonSize { + get { + return driver.ToolWindowCaptionButtonSize; + } + } + #endregion // Public Static Properties + + #region Events + + internal static event EventHandler Idle { + add { + driver.Idle += value; + } + remove { + driver.Idle -= value; + } + } + + #endregion // Events + + #region Public Static Methods + internal static void Activate (IntPtr handle) + { + DriverDebug ("Activate ({0}): Called", Window (handle)); + driver.Activate (handle); + } + + internal static void AudibleAlert (AlertType alert) + { + DriverDebug ("AudibleAlert (): Called"); + driver.AudibleAlert (alert); + } + + internal static void BeginMoveResize (IntPtr handle) + { + driver.BeginMoveResize (handle); + } + + internal static bool CalculateWindowRect (ref Rectangle ClientRect, CreateParams cp, Menu menu, out Rectangle WindowRect) + { + DriverDebug ("CalculateWindowRect ({0}, {1}, {2}): Called", ClientRect, cp, menu); + return driver.CalculateWindowRect (ref ClientRect, cp, menu, out WindowRect); + } + + internal static void CaretVisible (IntPtr handle, bool visible) + { + DriverDebug ("CaretVisible ({0:X}, {1}): Called", handle.ToInt32 (), visible); + driver.CaretVisible (handle, visible); + } + + internal static void CreateCaret (IntPtr handle, int width, int height) + { + DriverDebug ("CreateCaret ({0:X}), {1}, {2}: Called", handle.ToInt32 (), width, height); + driver.CreateCaret (handle, width, height); + } + + internal static IntPtr CreateWindow (CreateParams cp) + { + #if DriverDebug || DriverDebugCreate + IntPtr handle; + + handle = driver.CreateWindow (cp); + + Console.WriteLine ("CreateWindow (): Called, returning {0:X}", handle.ToInt32 ()); + return handle; + #else + return driver.CreateWindow (cp); + #endif + } + + internal static IntPtr CreateWindow (IntPtr Parent, int X, int Y, int Width, int Height) + { + #if DriverDebug || DriverDebugCreate + Console.WriteLine ("CreateWindow (): Called"); + #endif + return driver.CreateWindow (Parent, X, Y, Width, Height); + } + + internal static void ClientToScreen (IntPtr handle, ref int x, ref int y) + { + #if DriverDebug + Console.WriteLine ("ClientToScreen ({0}, {1}, {2}): Called", Window (handle), x, y); + #endif + driver.ClientToScreen (handle, ref x, ref y); + } + + internal static int[] ClipboardAvailableFormats (IntPtr handle) + { + DriverDebug ("ClipboardAvailableTypes ({0:X}): Called", handle.ToInt32 ()); + return driver.ClipboardAvailableFormats (handle); + } + + internal static void ClipboardClose (IntPtr handle) + { + DriverDebug ("ClipboardClose ({0:X}): Called", handle.ToInt32 ()); + driver.ClipboardClose (handle); + } + + internal static int ClipboardGetID (IntPtr handle, string format) + { + DriverDebug ("ClipboardGetID ({0:X}, {1}): Called", handle.ToInt32 (), format); + return driver.ClipboardGetID (handle, format); + } + + internal static IntPtr ClipboardOpen (bool primary_selection) + { + DriverDebug ("ClipboardOpen (): Called"); + return driver.ClipboardOpen (primary_selection); + } + + internal static void ClipboardStore (IntPtr handle, object obj, int type, XplatUI.ObjectToClipboard converter, bool copy) + { + DriverDebug ("ClipboardStore ({0:X}, {1}, {2}, {3}, {4}): Called", handle.ToInt32 (), obj, type, converter, copy); + driver.ClipboardStore (handle, obj, type, converter, copy); + } + + internal static object ClipboardRetrieve (IntPtr handle, int type, XplatUI.ClipboardToObject converter) + { + DriverDebug ("ClipboardRetrieve ({0:X}, type, {1}): Called", handle.ToInt32 (), converter); + return driver.ClipboardRetrieve (handle, type, converter); + } + + internal static IntPtr DefineCursor (Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot) + { + DriverDebug ("DefineCursor (...): Called"); + return driver.DefineCursor (bitmap, mask, cursor_pixel, mask_pixel, xHotSpot, yHotSpot); + } + + internal static IntPtr DefineStdCursor (StdCursor id) + { + return driver.DefineStdCursor (id); + } + + internal static Bitmap DefineStdCursorBitmap (StdCursor id) + { + return driver.DefineStdCursorBitmap (id); + } + + internal static IntPtr DefWndProc (ref Message msg) + { + return driver.DefWndProc (ref msg); + } + + internal static void DestroyCaret (IntPtr handle) + { + DriverDebug ("DestroyCaret ({0:X}): Called", handle.ToInt32 ()); + driver.DestroyCaret (handle); + } + + internal static void DestroyCursor (IntPtr cursor) + { + DriverDebug ("DestroyCursor ({0:X}): Called", cursor.ToInt32 ()); + driver.DestroyCursor (cursor); + } + + internal static void DestroyWindow (IntPtr handle) + { + DriverDebug ("DestroyWindow ({0}): Called", Window (handle)); + driver.DestroyWindow (handle); + } + + internal static IntPtr DispatchMessage (ref MSG msg) + { + return driver.DispatchMessage (ref msg); + } + + internal static void DoEvents () + { + driver.DoEvents (); + } + + internal static void DrawReversibleRectangle (IntPtr handle, Rectangle rect, int line_width) + { + DriverDebug ("DrawReversibleRectangle ({0}, {1}, {2}): Called", Window (handle), rect, line_width); + driver.DrawReversibleRectangle (handle, rect, line_width); + } + + internal static void FillReversibleRectangle (Rectangle rectangle, Color backColor) + { + DriverDebug ("FillReversibleRectangle ({0}, {1}): Called", rectangle, backColor); + driver.FillReversibleRectangle (rectangle, backColor); + } + + internal static void DrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style) + { + DriverDebug ("DrawReversibleFrame ({0}, {1}, {2}): Called", rectangle, backColor, style); + driver.DrawReversibleFrame (rectangle, backColor, style); + } + + internal static void DrawReversibleLine (Point start, Point end, Color backColor) + { + DriverDebug ("DrawReversibleLine ({0}, {1}, {2}): Called", start, end, backColor); + driver.DrawReversibleLine (start, end, backColor); + } + + internal static void EnableThemes () + { + driver.EnableThemes (); + } + + internal static void EnableWindow (IntPtr handle, bool Enable) + { + DriverDebug ("EnableWindow ({0}, {1}): Called", Window (handle), Enable); + driver.EnableWindow (handle, Enable); + } + + internal static void EndLoop (Thread thread) + { + DriverDebug ("EndLoop ({0:X}): Called", thread.GetHashCode ()); + driver.EndLoop (thread); + } + + internal static IntPtr GetActive () + { + DriverDebug ("GetActive (): Called"); + return driver.GetActive (); + } + + internal static SizeF GetAutoScaleSize (Font font) + { + DriverDebug ("GetAutoScaleSize ({0}): Called", font); + return driver.GetAutoScaleSize (font); + } + + internal static Region GetClipRegion (IntPtr handle) + { + DriverDebug ("GetClipRegion ({0}): Called", Window (handle)); + return driver.GetClipRegion (handle); + } + + internal static void GetCursorInfo (IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y) + { + DriverDebug ("GetCursorInfo ({0}): Called", cursor.ToInt32 ()); + driver.GetCursorInfo (cursor, out width, out height, out hotspot_x, out hotspot_y); + } + + internal static void GetCursorPos (IntPtr handle, out int x, out int y) + { + DriverDebug ("GetCursorPos ({0}): Called", Window (handle)); + driver.GetCursorPos (handle, out x, out y); + } + + internal static void GetDisplaySize (out Size size) + { + DriverDebug ("GetDisplaySize (): Called"); + driver.GetDisplaySize (out size); + } + + internal static IntPtr GetFocus () + { + DriverDebug ("GetFocus (): Called, Result:{0}", Window (driver.GetFocus ())); + return driver.GetFocus (); + } + + internal static bool GetFontMetrics (Graphics g, Font font, out int ascent, out int descent) + { + DriverDebug ("GetFontMetrics (): Called"); + return driver.GetFontMetrics (g, font, out ascent, out descent); + } + + internal static Point GetMenuOrigin (IntPtr handle) + { + DriverDebug ("GetMenuOrigin ({0}): Called", Window (handle)); + return driver.GetMenuOrigin (handle); + } + + internal static bool GetMessage (object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax) + { + return driver.GetMessage (queue_id, ref msg, hWnd, wFilterMin, wFilterMax); + } + + internal static IntPtr GetParent (IntPtr handle) + { + DriverDebug ("GetParent ({0}): Called", Window (handle)); + return driver.GetParent (handle); + } + + internal static IntPtr GetPreviousWindow (IntPtr handle) + { + return driver.GetPreviousWindow (handle); + } + + internal static bool GetText (IntPtr handle, out string text) + { + DriverDebug ("GetText ({0}): Called", Window (handle)); + return driver.GetText (handle, out text); + } + + internal static void GetWindowPos (IntPtr handle, bool is_toplevel, out int x, out int y, out int width, out int height, out int client_width, out int client_height) + { + DriverDebug ("GetWindowPos ({0}): Called", Window (handle)); + driver.GetWindowPos (handle, is_toplevel, out x, out y, out width, out height, out client_width, out client_height); + } + + /* this method can (and does, on X11) return + * (FormWindowState) (-1), when the state of the window + * cannot be determined (in the X11 case, when the + * window isn't mapped.) Checking for the additional + * return value is less expensive than + * throwing/catching an exception. */ + internal static FormWindowState GetWindowState (IntPtr handle) + { + DriverDebug ("GetWindowState ({0}): Called", Window (handle)); + return driver.GetWindowState (handle); + } + + internal static void GrabInfo (out IntPtr handle, out bool GrabConfined, out Rectangle GrabArea) + { + DriverDebug ("GrabInfo (): Called"); + driver.GrabInfo (out handle, out GrabConfined, out GrabArea); + } + + internal static void GrabWindow (IntPtr handle, IntPtr ConfineToHwnd) + { + DriverDebug ("GrabWindow ({0}, {1}): Called", Window (handle), Window (ConfineToHwnd)); + driver.GrabWindow (handle, ConfineToHwnd); + } + + internal static void HandleException (Exception e) + { + driver.HandleException (e); + } + + internal static void Invalidate (IntPtr handle, Rectangle rc, bool clear) + { + DriverDebug ("Invalidate ({0}, {1}, {2}): Called", Window (handle), rc, clear); + driver.Invalidate (handle, rc, clear); + } + + internal static void InvalidateNC (IntPtr handle) + { + DriverDebug ("InvalidateNC ({0}): Called", Window (handle)); + driver.InvalidateNC (handle); + } + + + internal static bool IsEnabled (IntPtr handle) + { + #if DriverDebug || DriverDebugState + Console.WriteLine ("IsEnabled ({0}): Called, Result={1}", Window (handle), driver.IsEnabled (handle)); + #endif + return driver.IsEnabled (handle); + } + + internal static bool IsKeyLocked (VirtualKeys key) + { + #if DriverDebug || DriverDebugState + Console.WriteLine ("IsKeyLocked ({0}): Called, Result={1}", key, driver.IsKeyLocked (key)); + #endif + return driver.IsKeyLocked (key); + } + + internal static bool IsVisible (IntPtr handle) + { + #if DriverDebug || DriverDebugState + Console.WriteLine ("IsVisible ({0}): Called, Result={1}", Window (handle), driver.IsVisible (handle)); + #endif + return driver.IsVisible (handle); + } + + internal static void KillTimer (Timer timer) + { + DriverDebug ("KillTimer ({0}): Called", timer); + driver.KillTimer (timer); + } + + internal static void MenuToScreen (IntPtr handle, ref int x, ref int y) + { + DriverDebug ("MenuToScreen ({0}, {1}, {2}): Called", Window (handle), x, y); + driver.MenuToScreen (handle, ref x, ref y); + } + + internal static void OverrideCursor (IntPtr cursor) + { + DriverDebug ("OverrideCursor ({0:X}): Called", cursor.ToInt32 ()); + driver.OverrideCursor (cursor); + } + + internal static void PaintEventEnd (ref Message msg, IntPtr handle, bool client) + { + #if DriverDebug || DriverDebugPaint + Console.WriteLine ("PaintEventEnd ({0}, {1}, {2}): Called from thread {3}", msg, Window (handle), client, Thread.CurrentThread.GetHashCode ()); + #endif + driver.PaintEventEnd (ref msg, handle, client); + } + + internal static PaintEventArgs PaintEventStart (ref Message msg, IntPtr handle, bool client) + { + #if DriverDebug || DriverDebugPaint + Console.WriteLine ("PaintEventStart ({0}, {1}, {2}): Called from thread {3}", msg, Window (handle), client, Thread.CurrentThread.GetHashCode ()); + #endif + return driver.PaintEventStart (ref msg, handle, client); + } + + internal static bool PeekMessage (Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags) + { + return driver.PeekMessage (queue_id, ref msg, hWnd, wFilterMin, wFilterMax, flags); + } + + internal static bool PostMessage (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam) + { + DriverDebug ("PostMessage ({0}, {1}, {2:X}, {3:X}): Called", Window (hwnd), message, wParam.ToInt32 (), lParam.ToInt32 ()); + return driver.PostMessage (hwnd, message, wParam, lParam); + } + + internal static bool PostMessage (ref MSG msg) + { + DriverDebug ("PostMessage ({0}): Called", msg); + return driver.PostMessage (msg.hwnd, msg.message, msg.wParam, msg.lParam); + } + + internal static void PostQuitMessage (int exitCode) + { + DriverDebug ("PostQuitMessage ({0}): Called", exitCode); + driver.PostQuitMessage (exitCode); + } + + internal static void RaiseIdle (EventArgs e) + { + DriverDebug ("RaiseIdle ({0}): Called", e.ToString ()); + + driver.RaiseIdle (e); + } + + internal static void RequestAdditionalWM_NCMessages (IntPtr handle, bool hover, bool leave) + { + DriverDebug ("RequestAdditionalWM_NCMessages ({0}, {1}, {2}): Called", Window (handle), hover, leave); + driver.RequestAdditionalWM_NCMessages (handle, hover, leave); + } + + internal static void RequestNCRecalc (IntPtr handle) + { + DriverDebug ("RequestNCRecalc ({0}): Called", Window (handle)); + driver.RequestNCRecalc (handle); + } + + internal static void ResetMouseHover (IntPtr handle) + { + DriverDebug ("ResetMouseHover ({0}): Called", Window (handle)); + driver.ResetMouseHover (handle); + } + + internal static void ScreenToClient (IntPtr handle, ref int x, ref int y) + { + DriverDebug ("ScreenToClient ({0}, {1}, {2}): Called", Window (handle), x, y); + driver.ScreenToClient (handle, ref x, ref y); + } + + internal static void ScreenToMenu (IntPtr handle, ref int x, ref int y) + { + DriverDebug ("ScreenToMenu ({0}, {1}, {2}): Called", Window (handle), x, y); + driver.ScreenToMenu (handle, ref x, ref y); + } + + internal static void ScrollWindow (IntPtr handle, Rectangle rectangle, int XAmount, int YAmount, bool with_children) + { + DriverDebug ("ScrollWindow ({0}, {1}, {2}, {3}, {4}): Called", Window (handle), rectangle, XAmount, YAmount, with_children); + driver.ScrollWindow (handle, rectangle, XAmount, YAmount, with_children); + } + + internal static void ScrollWindow (IntPtr handle, int XAmount, int YAmount, bool with_children) + { + DriverDebug ("ScrollWindow ({0}, {1}, {2}, {3}): Called", Window (handle), XAmount, YAmount, with_children); + driver.ScrollWindow (handle, XAmount, YAmount, with_children); + } + + internal static void SendAsyncMethod (AsyncMethodData data) + { + DriverDebug ("SendAsyncMethod ({0}): Called", data); + driver.SendAsyncMethod (data); + } + + internal static int SendInput (IntPtr hwnd, Queue keys) + { + DriverDebug ("SendInput ({0}, {1}): Called", hwnd, keys); + return driver.SendInput (hwnd, keys); + } + + internal static IntPtr SendMessage (IntPtr handle, Msg message, IntPtr wParam, IntPtr lParam) + { + DriverDebug ("SendMessage ({0}, {1}, {2:X}, {3:X}): Called", Window (handle), message, wParam.ToInt32 (), lParam.ToInt32 ()); + return driver.SendMessage (handle, message, wParam, lParam); + } + + internal static void SendMessage (ref Message m) + { + DriverDebug ("SendMessage ({0}): Called", m); + m.Result = driver.SendMessage (m.HWnd, (Msg)m.Msg, m.WParam, m.LParam); + } + + internal static void SetAllowDrop (IntPtr handle, bool value) + { + DriverDebug ("SetAllowDrop ({0}, {1}): Called", handle, value); + driver.SetAllowDrop (handle, value); + } + + internal static void SetBorderStyle (IntPtr handle, FormBorderStyle border_style) + { + DriverDebug ("SetBorderStyle ({0}, {1}): Called", Window (handle), border_style); + driver.SetBorderStyle (handle, border_style); + } + + internal static void SetCaretPos (IntPtr handle, int x, int y) + { + DriverDebug ("SetCaretPos ({0}, {1}, {2}): Called", Window (handle), x, y); + driver.SetCaretPos (handle, x, y); + } + + internal static void SetClipRegion (IntPtr handle, Region region) + { + DriverDebug ("SetClipRegion ({0}, {1}): Called", Window (handle), region); + driver.SetClipRegion (handle, region); + } + + internal static void SetCursor (IntPtr handle, IntPtr cursor) + { + DriverDebug ("SetCursor ({0}, {1:X}): Called", Window (handle), cursor.ToInt32 ()); + driver.SetCursor (handle, cursor); + } + + internal static void SetCursorPos (IntPtr handle, int x, int y) + { + DriverDebug ("SetCursorPos ({0}, {1}, {2}): Called", Window (handle), x, y); + driver.SetCursorPos (handle, x, y); + } + + internal static void SetFocus (IntPtr handle) + { + DriverDebug ("SetFocus ({0}): Called", Window (handle)); + driver.SetFocus (handle); + } + + internal static void SetForegroundWindow (IntPtr handle) + { + DriverDebug ("SetForegroundWindow ({0}): Called", Window (handle)); + driver.SetForegroundWindow (handle); + } + + internal static void SetIcon (IntPtr handle, Icon icon) + { + DriverDebug ("SetIcon ({0}, {1}): Called", Window (handle), icon); + driver.SetIcon (handle, icon); + } + + internal static void SetMenu (IntPtr handle, Menu menu) + { + DriverDebug ("SetMenu ({0}, {1}): Called", Window (handle), menu); + driver.SetMenu (handle, menu); + } + + internal static void SetModal (IntPtr handle, bool Modal) + { + DriverDebug ("SetModal ({0}, {1}): Called", Window (handle), Modal); + driver.SetModal (handle, Modal); + } + + internal static IntPtr SetParent (IntPtr handle, IntPtr hParent) + { + DriverDebug ("SetParent ({0}, {1:X}): Called", Window (handle), Window (hParent)); + return driver.SetParent (handle, hParent); + } + + internal static void SetTimer (Timer timer) + { + DriverDebug ("SetTimer ({0}): Called", timer); + driver.SetTimer (timer); + } + + internal static bool SetTopmost (IntPtr handle, bool Enabled) + { + DriverDebug ("SetTopMost ({0}, {1}): Called", Window (handle), Enabled); + return driver.SetTopmost (handle, Enabled); + } + + internal static bool SetOwner (IntPtr handle, IntPtr hWndOwner) + { + DriverDebug ("SetOwner ({0}, {1}): Called", Window (handle), Window (hWndOwner)); + return driver.SetOwner (handle, hWndOwner); + } + + internal static bool SetVisible (IntPtr handle, bool visible, bool activate) + { + #if DriverDebug || DriverDebugState + Console.WriteLine ("SetVisible ({0}, {1}, {2}): Called", Window (handle), visible, activate); + #endif + return driver.SetVisible (handle, visible, activate); + } + + internal static void SetWindowMinMax (IntPtr handle, Rectangle maximized, Size min, Size max) + { + #if DriverDebug || DriverDebugState + Console.WriteLine ("SetWindowMinMax ({0}, {1}, {2}, {3}): Called", Window (handle), maximized, min, max); + #endif + driver.SetWindowMinMax (handle, maximized, min, max); + } + + internal static void SetWindowPos (IntPtr handle, int x, int y, int width, int height) + { + DriverDebug ("SetWindowPos ({0}, {1}, {2}, {3}, {4}): Called", Window (handle), x, y, width, height); + driver.SetWindowPos (handle, x, y, width, height); + } + + internal static void SetWindowState (IntPtr handle, FormWindowState state) + { + #if DriverDebug || DriverDebugState + Console.WriteLine ("SetWindowState ({0} {1}): Called", Window (handle), state); + #endif + driver.SetWindowState (handle, state); + } + + internal static void SetWindowStyle (IntPtr handle, CreateParams cp) + { + DriverDebug ("SetWindowStyle ({0}): Called", Window (handle)); + driver.SetWindowStyle (handle, cp); + } + + internal static double GetWindowTransparency (IntPtr handle) + { + DriverDebug ("SetWindowTransparency ({0}): Called", Window (handle)); + return driver.GetWindowTransparency (handle); + } + + internal static void SetWindowTransparency (IntPtr handle, double transparency, Color key) + { + DriverDebug ("SetWindowTransparency ({0}): Called", Window (handle)); + driver.SetWindowTransparency (handle, transparency, key); + } + + internal static bool SetZOrder (IntPtr handle, IntPtr AfterhWnd, bool Top, bool Bottom) + { + DriverDebug ("SetZOrder ({0}, {1:X}, {2}, {3}): Called", Window (handle), Window (AfterhWnd), Top, Bottom); + return driver.SetZOrder (handle, AfterhWnd, Top, Bottom); + } + + internal static void ShowCursor (bool show) + { + DriverDebug ("ShowCursor ({0}): Called", show); + driver.ShowCursor (show); + } + + internal static DragDropEffects StartDrag (IntPtr handle, object data, DragDropEffects allowedEffects) + { + DriverDebug ("StartDrag ({0}, {1}, {2}): Called", Window (handle), data, allowedEffects); + return driver.StartDrag (handle, data, allowedEffects); + } + + internal static object StartLoop (Thread thread) + { + DriverDebug ("StartLoop ({0:X}): Called", thread.GetHashCode ()); + return driver.StartLoop (thread); + } + + internal static TransparencySupport SupportsTransparency () + { + DriverDebug ("SupportsTransparency (): Called, result={0}", driver.SupportsTransparency ()); + return driver.SupportsTransparency (); + } + + internal static bool SystrayAdd (IntPtr handle, string tip, Icon icon, out ToolTip tt) + { + DriverDebug ("SystrayAdd ({0}, {1}): Called", Window (handle), tip); + return driver.SystrayAdd (handle, tip, icon, out tt); + } + + internal static void SystrayChange (IntPtr handle, string tip, Icon icon, ref ToolTip tt) + { + DriverDebug ("SystrayChange ({0}, {1}): Called", Window (handle), tip); + driver.SystrayChange (handle, tip, icon, ref tt); + } + + internal static void SystrayRemove (IntPtr handle, ref ToolTip tt) + { + DriverDebug ("SystrayRemove ({0}): Called", Window (handle)); + driver.SystrayRemove (handle, ref tt); + } + + internal static void SystrayBalloon (IntPtr handle, int timeout, string title, string text, ToolTipIcon icon) + { + DriverDebug ("SystrayBalloon ({0}, {1}, {2}, {3}, {4}): Called", Window (handle), timeout, title, text, icon); + driver.SystrayBalloon (handle, timeout, title, text, icon); + } + + internal static bool Text (IntPtr handle, string text) + { + DriverDebug ("Text ({0}, {1}): Called", Window (handle), text); + return driver.Text (handle, text); + } + + internal static bool TranslateMessage (ref MSG msg) + { + return driver.TranslateMessage (ref msg); + } + + internal static void UngrabWindow (IntPtr handle) + { + DriverDebug ("UngrabWindow ({0}): Called", Window (handle)); + driver.UngrabWindow (handle); + } + + internal static void UpdateWindow (IntPtr handle) + { + DriverDebug ("UpdateWindow ({0}): Called", Window (handle)); + driver.UpdateWindow (handle); + } + + // double buffering + internal static void CreateOffscreenDrawable (IntPtr handle, + int width, int height, + out object offscreen_drawable) + { + DriverDebug ("CreateOffscreenDrawable ({2}, {0},{1}): Called", width, height, Window (handle)); + driver.CreateOffscreenDrawable (handle, width, height, + out offscreen_drawable); + } + + internal static void DestroyOffscreenDrawable (object offscreen_drawable) + { + DriverDebug ("DestroyOffscreenDrawable (): Called"); + driver.DestroyOffscreenDrawable (offscreen_drawable); + } + + internal static Graphics GetOffscreenGraphics (object offscreen_drawable) + { + DriverDebug ("GetOffscreenGraphics (): Called"); + return driver.GetOffscreenGraphics (offscreen_drawable); + } + + internal static void BlitFromOffscreen (IntPtr dest_handle, + Graphics dest_dc, + object offscreen_drawable, + Graphics offscreen_dc, + Rectangle r) + { + DriverDebug ("BlitFromOffscreen ({0}): Called", Window (dest_handle)); + driver.BlitFromOffscreen (dest_handle, dest_dc, offscreen_drawable, offscreen_dc, r); + } + + + // Santa's little helper + internal static void Version () + { + Console.WriteLine ("Xplat version $Revision: $"); + } + + internal static void AddKeyFilter (IKeyFilter value) + { + lock (key_filters) { + key_filters.Add (value); + } + } + + internal static bool FilterKey (KeyFilterData key) + { + lock (key_filters) { + for (int i = 0; i < key_filters.Count; i++) { + IKeyFilter filter = (IKeyFilter) key_filters[i]; + if (filter.PreFilterKey (key)) + return true; + } + } + return false; + } + #endregion // Public Static Methods + + #region Delegates + public delegate bool ClipboardToObject (int type, IntPtr data, out object obj); + public delegate bool ObjectToClipboard (ref int type, object obj, out byte[] data); + #endregion // Delegates + + [DllImport ("libc")] + static extern int uname (IntPtr buf); + } +} diff --git a/source/ShiftUI/Internal/XplatUICarbon.cs b/source/ShiftUI/Internal/XplatUICarbon.cs new file mode 100644 index 0000000..ec1b53a --- /dev/null +++ b/source/ShiftUI/Internal/XplatUICarbon.cs @@ -0,0 +1,2432 @@ +// 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) 2004-2007 Novell, Inc. +// +// Authors: +// Geoff Norton <[email protected]> +// +// + +using System; +using System.Threading; +using System.Drawing; +using System.ComponentModel; +using System.Collections; +using System.Diagnostics; +using System.Runtime.InteropServices; + +using Carbon = ShiftUI.CarbonInternal; + +/// Carbon Version +using ShiftUI; + + +namespace ShiftUI { + internal delegate Rectangle [] HwndDelegate (IntPtr handle); + + internal class XplatUICarbon : XplatUIDriver { + #region Local Variables + // General driver variables + private static XplatUICarbon Instance; + private static int RefCount; + private static bool themes_enabled; + + // Internal members available to the event handler sub-system + internal static IntPtr FocusWindow; + internal static IntPtr ActiveWindow; + internal static IntPtr UnactiveWindow; + internal static IntPtr ReverseWindow; + internal static IntPtr CaretWindow; + + internal static Hwnd MouseHwnd; + + internal static MouseButtons MouseState; + internal static Carbon.Hover Hover; + + internal static HwndDelegate HwndDelegate = new HwndDelegate (GetClippingRectangles); + // Instance members + internal Point mouse_position; + + // Event handlers + internal Carbon.ApplicationHandler ApplicationHandler; + internal Carbon.WidgetHandler WidgetHandler; + internal Carbon.HIObjectHandler HIObjectHandler; + internal Carbon.KeyboardHandler KeyboardHandler; + internal Carbon.MouseHandler MouseHandler; + internal Carbon.WindowHandler WindowHandler; + + // Carbon Specific + internal static GrabStruct Grab; + internal static Carbon.Caret Caret; + private static Carbon.Dnd Dnd; + private static Hashtable WindowMapping; + private static Hashtable HandleMapping; + private static IntPtr FosterParent; + private static IntPtr Subclass; + private static int MenuBarHeight; + internal static ArrayList UtilityWindows; + + // Message loop + private static Queue MessageQueue; + private static bool GetMessageResult; + + private static bool ReverseWindowMapped; + + // Timers + private ArrayList TimerList; + private static bool in_doevents; + + static readonly object instancelock = new object (); + static readonly object queuelock = new object (); + + // Event Handlers + internal override event EventHandler Idle; + #endregion + + #region Constructors + private XplatUICarbon() { + + RefCount = 0; + TimerList = new ArrayList (); + in_doevents = false; + MessageQueue = new Queue (); + + Initialize (); + } + + ~XplatUICarbon() { + // FIXME: Clean up the FosterParent here. + } + #endregion + + #region Singleton specific code + public static XplatUICarbon GetInstance() { + lock (instancelock) { + if (Instance == null) { + Instance = new XplatUICarbon (); + } + RefCount++; + } + return Instance; + } + + public int Reference { + get { + return RefCount; + } + } + #endregion + + #region Internal methods + internal void AddExpose (Hwnd hwnd, bool client, Carbon.HIRect rect) { + AddExpose (hwnd, client, (int) rect.origin.x, (int) rect.origin.y, (int) rect.size.width, (int) rect.size.height); + } + + internal void AddExpose (Hwnd hwnd, bool client, Rectangle rect) { + AddExpose (hwnd, client, (int) rect.X, (int) rect.Y, (int) rect.Width, (int) rect.Height); + } + + internal void FlushQueue () { + CheckTimers (DateTime.UtcNow); + lock (queuelock) { + while (MessageQueue.Count > 0) { + object queueobj = MessageQueue.Dequeue (); + if (queueobj is GCHandle) { + XplatUIDriverSupport.ExecuteClientMessage((GCHandle)queueobj); + } else { + MSG msg = (MSG)queueobj; + NativeWindow.WndProc (msg.hwnd, msg.message, msg.wParam, msg.lParam); + } + } + } + } + + internal static Rectangle [] GetClippingRectangles (IntPtr handle) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd == null) + return null; + if (hwnd.Handle != handle) + return new Rectangle [] {hwnd.ClientRect}; + + return (Rectangle []) hwnd.GetClippingRectangles ().ToArray (typeof (Rectangle)); + } + + internal IntPtr GetMousewParam(int Delta) { + int result = 0; + + if ((MouseState & MouseButtons.Left) != 0) { + result |= (int)MsgButtons.MK_LBUTTON; + } + + if ((MouseState & MouseButtons.Middle) != 0) { + result |= (int)MsgButtons.MK_MBUTTON; + } + + if ((MouseState & MouseButtons.Right) != 0) { + result |= (int)MsgButtons.MK_RBUTTON; + } + + Keys mods = ModifierKeys; + if ((mods & Keys.Widget) != 0) { + result |= (int)MsgButtons.MK_CONTROL; + } + + if ((mods & Keys.Shift) != 0) { + result |= (int)MsgButtons.MK_SHIFT; + } + + result |= Delta << 16; + + return (IntPtr)result; + } + + internal IntPtr HandleToWindow (IntPtr handle) { + if (HandleMapping [handle] != null) + return (IntPtr) HandleMapping [handle]; + return IntPtr.Zero; + } + + internal void Initialize () { + if (Marshal.SizeOf<IntPtr> () == 8){ + Console.Error.WriteLine ("WARNING: The Carbon driver has not been ported to 64bits, and very few parts of Windows.Forms will work properly, or at all"); + } + // Initialize the event handlers + Carbon.EventHandler.Driver = this; + ApplicationHandler = new Carbon.ApplicationHandler (this); + WidgetHandler = new Carbon.WidgetHandler (this); + HIObjectHandler = new Carbon.HIObjectHandler (this); + KeyboardHandler = new Carbon.KeyboardHandler (this); + MouseHandler = new Carbon.MouseHandler (this); + WindowHandler = new Carbon.WindowHandler (this); + + // Initilize the mouse Widgets + Hover.Interval = 500; + Hover.Timer = new Timer (); + Hover.Timer.Enabled = false; + Hover.Timer.Interval = Hover.Interval; + Hover.Timer.Tick += new EventHandler (HoverCallback); + Hover.X = -1; + Hover.Y = -1; + MouseState = MouseButtons.None; + mouse_position = Point.Empty; + + // Initialize the Caret + Caret.Timer = new Timer (); + Caret.Timer.Interval = 500; + Caret.Timer.Tick += new EventHandler (CaretCallback); + + // Initialize the D&D + Dnd = new Carbon.Dnd (); + + // Initialize the Carbon Specific stuff + WindowMapping = new Hashtable (); + HandleMapping = new Hashtable (); + UtilityWindows = new ArrayList (); + + // Initialize the FosterParent + Carbon.Rect rect = new Carbon.Rect (); + SetRect (ref rect, (short)0, (short)0, (short)0, (short)0); + Carbon.ProcessSerialNumber psn = new Carbon.ProcessSerialNumber(); + + GetCurrentProcess( ref psn ); + TransformProcessType (ref psn, 1); + SetFrontProcess (ref psn); + + HIObjectRegisterSubclass (__CFStringMakeConstantString ("com.novell.mwfview"), __CFStringMakeConstantString ("com.apple.hiview"), 0, Carbon.EventHandler.EventHandlerDelegate, (uint)Carbon.EventHandler.HIObjectEvents.Length, Carbon.EventHandler.HIObjectEvents, IntPtr.Zero, ref Subclass); + + Carbon.EventHandler.InstallApplicationHandler (); + + CreateNewWindow (Carbon.WindowClass.kDocumentWindowClass, Carbon.WindowAttributes.kWindowStandardHandlerAttribute | Carbon.WindowAttributes.kWindowCloseBoxAttribute | Carbon.WindowAttributes.kWindowFullZoomAttribute | Carbon.WindowAttributes.kWindowCollapseBoxAttribute | Carbon.WindowAttributes.kWindowResizableAttribute | Carbon.WindowAttributes.kWindowCompositingAttribute, ref rect, ref FosterParent); + + CreateNewWindow (Carbon.WindowClass.kOverlayWindowClass, Carbon.WindowAttributes.kWindowNoUpdatesAttribute | Carbon.WindowAttributes.kWindowNoActivatesAttribute, ref rect, ref ReverseWindow); + CreateNewWindow (Carbon.WindowClass.kOverlayWindowClass, Carbon.WindowAttributes.kWindowNoUpdatesAttribute | Carbon.WindowAttributes.kWindowNoActivatesAttribute, ref rect, ref CaretWindow); + + // Get some values about bar heights + Carbon.Rect structRect = new Carbon.Rect (); + Carbon.Rect contentRect = new Carbon.Rect (); + GetWindowBounds (FosterParent, 32, ref structRect); + GetWindowBounds (FosterParent, 33, ref contentRect); + + MenuBarHeight = GetMBarHeight (); + + // Focus + FocusWindow = IntPtr.Zero; + + // Message loop + GetMessageResult = true; + + ReverseWindowMapped = false; + } + + internal void PerformNCCalc(Hwnd hwnd) { + XplatUIWin32.NCCALCSIZE_PARAMS ncp; + IntPtr ptr; + Rectangle rect; + + rect = new Rectangle (0, 0, hwnd.Width, hwnd.Height); + + ncp = new XplatUIWin32.NCCALCSIZE_PARAMS(); + ptr = Marshal.AllocHGlobal(Marshal.SizeOf(ncp)); + + ncp.rgrc1.left = rect.Left; + ncp.rgrc1.top = rect.Top; + ncp.rgrc1.right = rect.Right; + ncp.rgrc1.bottom = rect.Bottom; + + Marshal.StructureToPtr(ncp, ptr, true); + NativeWindow.WndProc(hwnd.client_window, Msg.WM_NCCALCSIZE, (IntPtr)1, ptr); + ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure(ptr, typeof(XplatUIWin32.NCCALCSIZE_PARAMS)); + Marshal.FreeHGlobal(ptr); + + + rect = new Rectangle(ncp.rgrc1.left, ncp.rgrc1.top, ncp.rgrc1.right - ncp.rgrc1.left, ncp.rgrc1.bottom - ncp.rgrc1.top); + hwnd.ClientRect = rect; + + rect = TranslateClientRectangleToQuartzClientRectangle (hwnd); + + if (hwnd.visible) { + Carbon.HIRect r = new Carbon.HIRect (rect.X, rect.Y, rect.Width, rect.Height); + HIViewSetFrame (hwnd.client_window, ref r); + } + + AddExpose (hwnd, false, 0, 0, hwnd.Width, hwnd.Height); + } + + internal void ScreenToClient(IntPtr handle, ref Carbon.QDPoint point) { + int x = (int) point.x; + int y = (int) point.y; + + ScreenToClient (handle, ref x, ref y); + + point.x = (short) x; + point.y = (short) y; + } + + internal static Rectangle TranslateClientRectangleToQuartzClientRectangle (Hwnd hwnd) { + return TranslateClientRectangleToQuartzClientRectangle (hwnd, Widget.FromHandle (hwnd.Handle)); + } + + internal static Rectangle TranslateClientRectangleToQuartzClientRectangle (Hwnd hwnd, Widget ctrl) { + /* From XplatUIX11 + * If this is a form with no window manager, X is handling all the border and caption painting + * so remove that from the area (since the area we set of the window here is the part of the window + * we're painting in only) + */ + Rectangle rect = hwnd.ClientRect; + Form form = ctrl as Form; + CreateParams cp = null; + + if (form != null) + cp = form.GetCreateParams (); + + if (form != null && (form.window_manager == null || cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) { + Hwnd.Borders borders = Hwnd.GetBorders (cp, null); + Rectangle qrect = rect; + + qrect.Y -= borders.top; + qrect.X -= borders.left; + qrect.Width += borders.left + borders.right; + qrect.Height += borders.top + borders.bottom; + + rect = qrect; + } + + if (rect.Width < 1 || rect.Height < 1) { + rect.Width = 1; + rect.Height = 1; + rect.X = -5; + rect.Y = -5; + } + + return rect; + } + + internal static Size TranslateWindowSizeToQuartzWindowSize (CreateParams cp) { + return TranslateWindowSizeToQuartzWindowSize (cp, new Size (cp.Width, cp.Height)); + } + + internal static Size TranslateWindowSizeToQuartzWindowSize (CreateParams cp, Size size) { + /* From XplatUIX11 + * If this is a form with no window manager, X is handling all the border and caption painting + * so remove that from the area (since the area we set of the window here is the part of the window + * we're painting in only) + */ + Form form = cp.control as Form; + if (form != null && (form.window_manager == null || cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) { + Hwnd.Borders borders = Hwnd.GetBorders (cp, null); + Size qsize = size; + + qsize.Width -= borders.left + borders.right; + qsize.Height -= borders.top + borders.bottom; + + size = qsize; + } + + if (size.Height == 0) + size.Height = 1; + if (size.Width == 0) + size.Width = 1; + return size; + } + + internal static Size TranslateQuartzWindowSizeToWindowSize (CreateParams cp, int width, int height) { + /* From XplatUIX11 + * If this is a form with no window manager, X is handling all the border and caption painting + * so remove that from the area (since the area we set of the window here is the part of the window + * we're painting in only) + */ + Size size = new Size (width, height); + Form form = cp.control as Form; + if (form != null && (form.window_manager == null || cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) { + Hwnd.Borders borders = Hwnd.GetBorders (cp, null); + Size qsize = size; + + qsize.Width += borders.left + borders.right; + qsize.Height += borders.top + borders.bottom; + + size = qsize; + } + + return size; + } + #endregion + + #region Callbacks + private void CaretCallback (object sender, EventArgs e) { + if (Caret.Paused) { + return; + } + + if (!Caret.On) { + ShowCaret (); + } else { + HideCaret (); + } + } + + private void HoverCallback (object sender, EventArgs e) { + if ((Hover.X == mouse_position.X) && (Hover.Y == mouse_position.Y)) { + MSG msg = new MSG (); + msg.hwnd = Hover.Hwnd; + msg.message = Msg.WM_MOUSEHOVER; + msg.wParam = GetMousewParam (0); + msg.lParam = (IntPtr)((ushort)Hover.X << 16 | (ushort)Hover.X); + EnqueueMessage (msg); + } + } + #endregion + + #region Private Methods + private Point ConvertScreenPointToClient (IntPtr handle, Point point) { + Point converted_point = new Point (); + Carbon.Rect window_bounds = new Carbon.Rect (); + Carbon.CGPoint native_point = new Carbon.CGPoint (); + + GetWindowBounds (HIViewGetWindow (handle), 32, ref window_bounds); + + native_point.x = (point.X - window_bounds.left); + native_point.y = (point.Y - window_bounds.top); + + HIViewConvertPoint (ref native_point, IntPtr.Zero, handle); + + converted_point.X = (int)native_point.x; + converted_point.Y = (int)native_point.y; + + return converted_point; + } + + private Point ConvertClientPointToScreen (IntPtr handle, Point point) { + Point converted_point = new Point (); + Carbon.Rect window_bounds = new Carbon.Rect (); + Carbon.CGPoint native_point = new Carbon.CGPoint (); + + GetWindowBounds (HIViewGetWindow (handle), 32, ref window_bounds); + + native_point.x = point.X; + native_point.y = point.Y; + + HIViewConvertPoint (ref native_point, handle, IntPtr.Zero); + + converted_point.X = (int)(native_point.x + window_bounds.left); + converted_point.Y = (int)(native_point.y + window_bounds.top); + + return converted_point; + } + + private double NextTimeout () { + DateTime now = DateTime.UtcNow; + int timeout = 0x7FFFFFF; + lock (TimerList) { + foreach (Timer timer in TimerList) { + int next = (int) (timer.Expires - now).TotalMilliseconds; + if (next < 0) + return 0; + if (next < timeout) + timeout = next; + } + } + if (timeout < Timer.Minimum) + timeout = Timer.Minimum; + + return (double)((double)timeout/1000); + } + + private void CheckTimers (DateTime now) { + lock (TimerList) { + int count = TimerList.Count; + if (count == 0) + return; + for (int i = 0; i < TimerList.Count; i++) { + Timer timer = (Timer) TimerList [i]; + if (timer.Enabled && timer.Expires <= now) { + // Timer ticks: + // - Before MainForm.OnLoad if DoEvents () is called. + // - After MainForm.OnLoad if not. + // + if (in_doevents || + (Application.MWFThread.Current.Context != null && + Application.MWFThread.Current.Context.MainForm != null && + Application.MWFThread.Current.Context.MainForm.IsLoaded)) { + timer.FireTick (); + timer.Update (now); + } + } + } + } + } + + private void WaitForHwndMessage (Hwnd hwnd, Msg message) { + MSG msg = new MSG (); + + bool done = false; + do { + if (GetMessage(null, ref msg, IntPtr.Zero, 0, 0)) { + if ((Msg)msg.message == Msg.WM_QUIT) { + PostQuitMessage (0); + done = true; + } + else { + if (msg.hwnd == hwnd.Handle) { + if ((Msg)msg.message == message) + break; + else if ((Msg)msg.message == Msg.WM_DESTROY) + done = true; + } + + TranslateMessage (ref msg); + DispatchMessage (ref msg); + } + } + } while (!done); + } + + private void SendParentNotify(IntPtr child, Msg cause, int x, int y) { + Hwnd hwnd; + + if (child == IntPtr.Zero) { + return; + } + + hwnd = Hwnd.GetObjectFromWindow (child); + + if (hwnd == null) { + return; + } + + if (hwnd.Handle == IntPtr.Zero) { + return; + } + + if (ExStyleSet ((int) hwnd.initial_ex_style, WindowExStyles.WS_EX_NOPARENTNOTIFY)) { + return; + } + + if (hwnd.Parent == null) { + return; + } + + if (hwnd.Parent.Handle == IntPtr.Zero) { + return; + } + + if (cause == Msg.WM_CREATE || cause == Msg.WM_DESTROY) { + SendMessage(hwnd.Parent.Handle, Msg.WM_PARENTNOTIFY, Widget.MakeParam((int)cause, 0), child); + } else { + SendMessage(hwnd.Parent.Handle, Msg.WM_PARENTNOTIFY, Widget.MakeParam((int)cause, 0), Widget.MakeParam(x, y)); + } + + SendParentNotify (hwnd.Parent.Handle, cause, x, y); + } + + private bool StyleSet (int s, WindowStyles ws) { + return (s & (int)ws) == (int)ws; + } + + private bool ExStyleSet (int ex, WindowExStyles exws) { + return (ex & (int)exws) == (int)exws; + } + + private void DeriveStyles(int Style, int ExStyle, out FormBorderStyle border_style, out bool border_static, out TitleStyle title_style, out int caption_height, out int tool_caption_height) { + + caption_height = 0; + tool_caption_height = 0; + border_static = false; + + if (StyleSet (Style, WindowStyles.WS_CHILD)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_CLIENTEDGE)) { + border_style = FormBorderStyle.Fixed3D; + } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_STATICEDGE)) { + border_style = FormBorderStyle.Fixed3D; + border_static = true; + } else if (!StyleSet (Style, WindowStyles.WS_BORDER)) { + border_style = FormBorderStyle.None; + } else { + border_style = FormBorderStyle.FixedSingle; + } + title_style = TitleStyle.None; + + if (StyleSet (Style, WindowStyles.WS_CAPTION)) { + caption_height = 0; + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + title_style = TitleStyle.Tool; + } else { + title_style = TitleStyle.Normal; + } + } + + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_MDICHILD)) { + caption_height = 0; + + if (StyleSet (Style, WindowStyles.WS_OVERLAPPEDWINDOW) || + ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + border_style = (FormBorderStyle) 0xFFFF; + } else { + border_style = FormBorderStyle.None; + } + } + + } else { + title_style = TitleStyle.None; + if (StyleSet (Style, WindowStyles.WS_CAPTION)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + title_style = TitleStyle.Tool; + } else { + title_style = TitleStyle.Normal; + } + } + + border_style = FormBorderStyle.None; + + if (StyleSet (Style, WindowStyles.WS_THICKFRAME)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + border_style = FormBorderStyle.SizableToolWindow; + } else { + border_style = FormBorderStyle.Sizable; + } + } else { + if (StyleSet (Style, WindowStyles.WS_CAPTION)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_CLIENTEDGE)) { + border_style = FormBorderStyle.Fixed3D; + } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_STATICEDGE)) { + border_style = FormBorderStyle.Fixed3D; + border_static = true; + } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_DLGMODALFRAME)) { + border_style = FormBorderStyle.FixedDialog; + } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + border_style = FormBorderStyle.FixedToolWindow; + } else if (StyleSet (Style, WindowStyles.WS_BORDER)) { + border_style = FormBorderStyle.FixedSingle; + } + } else { + if (StyleSet (Style, WindowStyles.WS_BORDER)) { + border_style = FormBorderStyle.FixedSingle; + } + } + } + } + } + + private void SetHwndStyles(Hwnd hwnd, CreateParams cp) { + DeriveStyles(cp.Style, cp.ExStyle, out hwnd.border_style, out hwnd.border_static, out hwnd.title_style, out hwnd.caption_height, out hwnd.tool_caption_height); + } + + private void ShowCaret () { + if (Caret.On) + return; + Caret.On = true; + ShowWindow (CaretWindow); + Graphics g = Graphics.FromHwnd (HIViewGetRoot (CaretWindow)); + + g.FillRectangle (new SolidBrush (Color.Black), new Rectangle (0, 0, Caret.Width, Caret.Height)); + + g.Dispose (); + } + + private void HideCaret () { + if (!Caret.On) + return; + Caret.On = false; + HideWindow (CaretWindow); + } + + private void AccumulateDestroyedHandles (Widget c, ArrayList list) { + if (c != null) { + Widget[] Widgets = c.Widgets.GetAllWidgets (); + + if (c.IsHandleCreated && !c.IsDisposed) { + Hwnd hwnd = Hwnd.ObjectFromHandle(c.Handle); + + list.Add (hwnd); + CleanupCachedWindows (hwnd); + } + + for (int i = 0; i < Widgets.Length; i ++) { + AccumulateDestroyedHandles (Widgets[i], list); + } + } + + } + + private void CleanupCachedWindows (Hwnd hwnd) { + if (ActiveWindow == hwnd.Handle) { + SendMessage(hwnd.client_window, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_INACTIVE, IntPtr.Zero); + ActiveWindow = IntPtr.Zero; + } + + if (FocusWindow == hwnd.Handle) { + SendMessage(hwnd.client_window, Msg.WM_KILLFOCUS, IntPtr.Zero, IntPtr.Zero); + FocusWindow = IntPtr.Zero; + } + + if (Grab.Hwnd == hwnd.Handle) { + Grab.Hwnd = IntPtr.Zero; + Grab.Confined = false; + } + + DestroyCaret (hwnd.Handle); + } + + private void AddExpose (Hwnd hwnd, bool client, int x, int y, int width, int height) { + // Don't waste time + if ((hwnd == null) || (x > hwnd.Width) || (y > hwnd.Height) || ((x + width) < 0) || ((y + height) < 0)) { + return; + } + + // Keep the invalid area as small as needed + if ((x + width) > hwnd.width) { + width = hwnd.width - x; + } + + if ((y + height) > hwnd.height) { + height = hwnd.height - y; + } + + if (client) { + hwnd.AddInvalidArea(x, y, width, height); + if (!hwnd.expose_pending && hwnd.visible) { + MSG msg = new MSG (); + msg.message = Msg.WM_PAINT; + msg.hwnd = hwnd.Handle; + EnqueueMessage (msg); + hwnd.expose_pending = true; + } + } else { + hwnd.AddNcInvalidArea (x, y, width, height); + if (!hwnd.nc_expose_pending && hwnd.visible) { + MSG msg = new MSG (); + Region rgn = new Region (hwnd.Invalid); + IntPtr hrgn = rgn.GetHrgn (null); // Graphics object isn't needed + msg.message = Msg.WM_NCPAINT; + msg.wParam = hrgn == IntPtr.Zero ? (IntPtr)1 : hrgn; + msg.refobject = rgn; + msg.hwnd = hwnd.Handle; + EnqueueMessage (msg); + hwnd.nc_expose_pending = true; + + } + } + } + #endregion + + #region Public Methods + internal void EnqueueMessage (MSG msg) { + lock (queuelock) { + MessageQueue.Enqueue (msg); + } + } + + internal override void RaiseIdle (EventArgs e) + { + if (Idle != null) + Idle (this, e); + } + + internal override IntPtr InitializeDriver() { + return IntPtr.Zero; + } + + internal override void ShutdownDriver(IntPtr token) { + } + + internal override void EnableThemes() { + themes_enabled = true; + } + + internal override void Activate(IntPtr handle) { + if (ActiveWindow != IntPtr.Zero) { + UnactiveWindow = ActiveWindow; + ActivateWindow (HIViewGetWindow (ActiveWindow), false); + } + ActivateWindow (HIViewGetWindow (handle), true); + ActiveWindow = handle; + } + + internal override void AudibleAlert(AlertType alert) { + AlertSoundPlay (); + } + + internal override void BeginMoveResize (IntPtr handle) { + } + + internal override void CaretVisible (IntPtr hwnd, bool visible) { + if (Caret.Hwnd == hwnd) { + if (visible) { + if (Caret.Visible < 1) { + Caret.Visible++; + Caret.On = false; + if (Caret.Visible == 1) { + ShowCaret (); + Caret.Timer.Start (); + } + } + } else { + Caret.Visible--; + if (Caret.Visible == 0) { + Caret.Timer.Stop (); + HideCaret (); + } + } + } + } + + internal override bool CalculateWindowRect(ref Rectangle ClientRect, CreateParams cp, Menu menu, out Rectangle WindowRect) { + WindowRect = Hwnd.GetWindowRectangle (cp, menu, ClientRect); + return true; + } + + internal override void ClientToScreen(IntPtr handle, ref int x, ref int y) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + Point point = ConvertClientPointToScreen (hwnd.ClientWindow, new Point (x, y)); + + x = point.X; + y = point.Y; + } + + internal override void MenuToScreen(IntPtr handle, ref int x, ref int y) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + Point point = ConvertClientPointToScreen (hwnd.ClientWindow, new Point (x, y)); + + x = point.X; + y = point.Y; + } + + internal override int[] ClipboardAvailableFormats(IntPtr handle) { + ArrayList list = new ArrayList (); + DataFormats.Format f = DataFormats.Format.List; + + while (f != null) { + list.Add (f.Id); + f = f.Next; + } + + return (int [])list.ToArray (typeof (int)); + } + + internal override void ClipboardClose(IntPtr handle) { + } + + //TODO: Map our internal formats to the right os code where we can + internal override int ClipboardGetID(IntPtr handle, string format) { + return (int)__CFStringMakeConstantString (format); + } + + internal override IntPtr ClipboardOpen(bool primary_selection) { + if (primary_selection) + return Carbon.Pasteboard.Primary; + return Carbon.Pasteboard.Application; + } + + internal override object ClipboardRetrieve(IntPtr handle, int type, XplatUI.ClipboardToObject converter) { + return Carbon.Pasteboard.Retrieve (handle, type); + } + + internal override void ClipboardStore(IntPtr handle, object obj, int type, XplatUI.ObjectToClipboard converter, bool copy) { + Carbon.Pasteboard.Store (handle, obj, type); + } + + internal override void CreateCaret (IntPtr hwnd, int width, int height) { + if (Caret.Hwnd != IntPtr.Zero) + DestroyCaret (Caret.Hwnd); + + Caret.Hwnd = hwnd; + Caret.Width = width; + Caret.Height = height; + Caret.Visible = 0; + Caret.On = false; + } + + internal override IntPtr CreateWindow(CreateParams cp) { + Hwnd hwnd; + Hwnd parent_hwnd = null; + int X; + int Y; + int Width; + int Height; + IntPtr ParentHandle; + IntPtr WindowHandle; + IntPtr WholeWindow; + IntPtr ClientWindow; + IntPtr WholeWindowTracking; + IntPtr ClientWindowTracking; + + hwnd = new Hwnd (); + + X = cp.X; + Y = cp.Y; + Width = cp.Width; + Height = cp.Height; + ParentHandle = IntPtr.Zero; + WindowHandle = IntPtr.Zero; + WholeWindow = IntPtr.Zero; + ClientWindow = IntPtr.Zero; + WholeWindowTracking = IntPtr.Zero; + ClientWindowTracking = IntPtr.Zero; + + if (Width < 1) Width = 1; + if (Height < 1) Height = 1; + + if (cp.Parent != IntPtr.Zero) { + parent_hwnd = Hwnd.ObjectFromHandle (cp.Parent); + ParentHandle = parent_hwnd.client_window; + } else { + if (StyleSet (cp.Style, WindowStyles.WS_CHILD)) { + HIViewFindByID (HIViewGetRoot (FosterParent), new Carbon.HIViewID (Carbon.EventHandler.kEventClassWindow, 1), ref ParentHandle); + } + } + + Point next; + if (cp.control is Form) { + next = Hwnd.GetNextStackedFormLocation (cp, parent_hwnd); + X = next.X; + Y = next.Y; + } + + hwnd.x = X; + hwnd.y = Y; + hwnd.width = Width; + hwnd.height = Height; + hwnd.Parent = Hwnd.ObjectFromHandle (cp.Parent); + hwnd.initial_style = cp.WindowStyle; + hwnd.initial_ex_style = cp.WindowExStyle; + hwnd.visible = false; + + if (StyleSet (cp.Style, WindowStyles.WS_DISABLED)) { + hwnd.enabled = false; + } + + ClientWindow = IntPtr.Zero; + + Size QWindowSize = TranslateWindowSizeToQuartzWindowSize (cp); + Rectangle QClientRect = TranslateClientRectangleToQuartzClientRectangle (hwnd, cp.control); + + SetHwndStyles(hwnd, cp); +/* FIXME */ + if (ParentHandle == IntPtr.Zero) { + IntPtr WindowView = IntPtr.Zero; + IntPtr GrowBox = IntPtr.Zero; + Carbon.WindowClass windowklass = Carbon.WindowClass.kOverlayWindowClass; + Carbon.WindowAttributes attributes = Carbon.WindowAttributes.kWindowCompositingAttribute | Carbon.WindowAttributes.kWindowStandardHandlerAttribute; + if (StyleSet (cp.Style, WindowStyles.WS_MINIMIZEBOX)) { + attributes |= Carbon.WindowAttributes.kWindowCollapseBoxAttribute; + } + if (StyleSet (cp.Style, WindowStyles.WS_MAXIMIZEBOX)) { + attributes |= Carbon.WindowAttributes.kWindowResizableAttribute | Carbon.WindowAttributes.kWindowHorizontalZoomAttribute | Carbon.WindowAttributes.kWindowVerticalZoomAttribute; + } + if (StyleSet (cp.Style, WindowStyles.WS_SYSMENU)) { + attributes |= Carbon.WindowAttributes.kWindowCloseBoxAttribute; + } + if (StyleSet (cp.Style, WindowStyles.WS_CAPTION)) { + windowklass = Carbon.WindowClass.kDocumentWindowClass; + } + if (hwnd.border_style == FormBorderStyle.FixedToolWindow) { + windowklass = Carbon.WindowClass.kUtilityWindowClass; + } else if (hwnd.border_style == FormBorderStyle.SizableToolWindow) { + attributes |= Carbon.WindowAttributes.kWindowResizableAttribute; + windowklass = Carbon.WindowClass.kUtilityWindowClass; + } + if (windowklass == Carbon.WindowClass.kOverlayWindowClass) { + attributes = Carbon.WindowAttributes.kWindowCompositingAttribute | Carbon.WindowAttributes.kWindowStandardHandlerAttribute; + } + attributes |= Carbon.WindowAttributes.kWindowLiveResizeAttribute; + + Carbon.Rect rect = new Carbon.Rect (); + if (StyleSet (cp.Style, WindowStyles.WS_POPUP)) { + SetRect (ref rect, (short)X, (short)(Y), (short)(X + QWindowSize.Width), (short)(Y + QWindowSize.Height)); + } else { + SetRect (ref rect, (short)X, (short)(Y + MenuBarHeight), (short)(X + QWindowSize.Width), (short)(Y + MenuBarHeight + QWindowSize.Height)); + } + + CreateNewWindow (windowklass, attributes, ref rect, ref WindowHandle); + + Carbon.EventHandler.InstallWindowHandler (WindowHandle); + HIViewFindByID (HIViewGetRoot (WindowHandle), new Carbon.HIViewID (Carbon.EventHandler.kEventClassWindow, 1), ref WindowView); + HIViewFindByID (HIViewGetRoot (WindowHandle), new Carbon.HIViewID (Carbon.EventHandler.kEventClassWindow, 7), ref GrowBox); + HIGrowBoxViewSetTransparent (GrowBox, true); + SetAutomaticWidgetDragTrackingEnabledForWindow (WindowHandle, true); + ParentHandle = WindowView; + } + + HIObjectCreate (__CFStringMakeConstantString ("com.novell.mwfview"), 0, ref WholeWindow); + HIObjectCreate (__CFStringMakeConstantString ("com.novell.mwfview"), 0, ref ClientWindow); + + Carbon.EventHandler.InstallWidgetHandler (WholeWindow); + Carbon.EventHandler.InstallWidgetHandler (ClientWindow); + + // Enable embedding on Widgets + HIViewChangeFeatures (WholeWindow, 1<<1, 0); + HIViewChangeFeatures (ClientWindow, 1<<1, 0); + + HIViewNewTrackingArea (WholeWindow, IntPtr.Zero, (UInt64)WholeWindow, ref WholeWindowTracking); + HIViewNewTrackingArea (ClientWindow, IntPtr.Zero, (UInt64)ClientWindow, ref ClientWindowTracking); + Carbon.HIRect WholeRect; + if (WindowHandle != IntPtr.Zero) { + WholeRect = new Carbon.HIRect (0, 0, QWindowSize.Width, QWindowSize.Height); + } else { + WholeRect = new Carbon.HIRect (X, Y, QWindowSize.Width, QWindowSize.Height); + } + Carbon.HIRect ClientRect = new Carbon.HIRect (QClientRect.X, QClientRect.Y, QClientRect.Width, QClientRect.Height); + HIViewSetFrame (WholeWindow, ref WholeRect); + HIViewSetFrame (ClientWindow, ref ClientRect); + + HIViewAddSubview (ParentHandle, WholeWindow); + HIViewAddSubview (WholeWindow, ClientWindow); + + hwnd.WholeWindow = WholeWindow; + hwnd.ClientWindow = ClientWindow; + + if (WindowHandle != IntPtr.Zero) { + WindowMapping [hwnd.Handle] = WindowHandle; + HandleMapping [WindowHandle] = hwnd.Handle; + if (hwnd.border_style == FormBorderStyle.FixedToolWindow || hwnd.border_style == FormBorderStyle.SizableToolWindow) { + UtilityWindows.Add (WindowHandle); + } + } + + // Allow dnd on Widgets + Dnd.SetAllowDrop (hwnd, true); + + Text (hwnd.Handle, cp.Caption); + + SendMessage (hwnd.Handle, Msg.WM_CREATE, (IntPtr)1, IntPtr.Zero /* XXX unused */); + SendParentNotify (hwnd.Handle, Msg.WM_CREATE, int.MaxValue, int.MaxValue); + + if (StyleSet (cp.Style, WindowStyles.WS_VISIBLE)) { + if (WindowHandle != IntPtr.Zero) { + if (Widget.FromHandle(hwnd.Handle) is Form) { + Form f = Widget.FromHandle(hwnd.Handle) as Form; + if (f.WindowState == FormWindowState.Normal) { + SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, (IntPtr)1, IntPtr.Zero); + } + } + ShowWindow (WindowHandle); + WaitForHwndMessage (hwnd, Msg.WM_SHOWWINDOW); + } + HIViewSetVisible (WholeWindow, true); + HIViewSetVisible (ClientWindow, true); + hwnd.visible = true; + if (!(Widget.FromHandle(hwnd.Handle) is Form)) { + SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, (IntPtr)1, IntPtr.Zero); + } + } + + if (StyleSet (cp.Style, WindowStyles.WS_MINIMIZE)) { + SetWindowState(hwnd.Handle, FormWindowState.Minimized); + } else if (StyleSet (cp.Style, WindowStyles.WS_MAXIMIZE)) { + SetWindowState(hwnd.Handle, FormWindowState.Maximized); + } + + return hwnd.Handle; + } + + internal override IntPtr CreateWindow(IntPtr Parent, int X, int Y, int Width, int Height) { + CreateParams create_params = new CreateParams(); + + create_params.Caption = ""; + create_params.X = X; + create_params.Y = Y; + create_params.Width = Width; + create_params.Height = Height; + + create_params.ClassName=XplatUI.GetDefaultClassName (GetType ()); + create_params.ClassStyle = 0; + create_params.ExStyle=0; + create_params.Parent=IntPtr.Zero; + create_params.Param=0; + + return CreateWindow(create_params); + } + + internal override Bitmap DefineStdCursorBitmap (StdCursor id) { + return Carbon.Cursor.DefineStdCursorBitmap (id); + } + + internal override IntPtr DefineCursor (Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot) { + return Carbon.Cursor.DefineCursor (bitmap, mask, cursor_pixel, mask_pixel, xHotSpot, yHotSpot); + } + + internal override IntPtr DefineStdCursor (StdCursor id) { + return Carbon.Cursor.DefineStdCursor (id); + } + + internal override IntPtr DefWndProc(ref Message msg) { + Hwnd hwnd = Hwnd.ObjectFromHandle (msg.HWnd); + switch ((Msg)msg.Msg) { + case Msg.WM_IME_COMPOSITION: + string s = KeyboardHandler.ComposedString; + foreach (char c in s) + SendMessage (msg.HWnd, Msg.WM_IME_CHAR, (IntPtr) c, msg.LParam); + break; + case Msg.WM_IME_CHAR: + // On Windows API it sends two WM_CHAR messages for each byte, but + // I wonder if it is worthy to emulate it (also no idea how to + // reconstruct those bytes into chars). + SendMessage (msg.HWnd, Msg.WM_CHAR, msg.WParam, msg.LParam); + return IntPtr.Zero; + case Msg.WM_QUIT: { + if (WindowMapping [hwnd.Handle] != null) + + Exit (); + break; + } + case Msg.WM_PAINT: { + hwnd.expose_pending = false; + break; + } + case Msg.WM_NCPAINT: { + hwnd.nc_expose_pending = false; + break; + } + case Msg.WM_NCCALCSIZE: { + if (msg.WParam == (IntPtr)1) { + XplatUIWin32.NCCALCSIZE_PARAMS ncp; + ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure (msg.LParam, typeof (XplatUIWin32.NCCALCSIZE_PARAMS)); + + // Add all the stuff X is supposed to draw. + Widget ctrl = Widget.FromHandle (hwnd.Handle); + if (ctrl != null) { + Hwnd.Borders rect = Hwnd.GetBorders (ctrl.GetCreateParams (), null); + + ncp.rgrc1.top += rect.top; + ncp.rgrc1.bottom -= rect.bottom; + ncp.rgrc1.left += rect.left; + ncp.rgrc1.right -= rect.right; + + Marshal.StructureToPtr (ncp, msg.LParam, true); + } + } + break; + } + case Msg.WM_SETCURSOR: { + // Pass to parent window first + while ((hwnd.parent != null) && (msg.Result == IntPtr.Zero)) { + hwnd = hwnd.parent; + msg.Result = NativeWindow.WndProc(hwnd.Handle, Msg.WM_SETCURSOR, msg.HWnd, msg.LParam); + } + + if (msg.Result == IntPtr.Zero) { + IntPtr handle; + + switch((HitTest)(msg.LParam.ToInt32() & 0xffff)) { + case HitTest.HTBOTTOM: handle = Cursors.SizeNS.handle; break; + case HitTest.HTBORDER: handle = Cursors.SizeNS.handle; break; + case HitTest.HTBOTTOMLEFT: handle = Cursors.SizeNESW.handle; break; + case HitTest.HTBOTTOMRIGHT: handle = Cursors.SizeNWSE.handle; break; + case HitTest.HTERROR: if ((msg.LParam.ToInt32() >> 16) == (int)Msg.WM_LBUTTONDOWN) { + //FIXME: AudibleAlert(); + } + handle = Cursors.Default.handle; + break; + + case HitTest.HTHELP: handle = Cursors.Help.handle; break; + case HitTest.HTLEFT: handle = Cursors.SizeWE.handle; break; + case HitTest.HTRIGHT: handle = Cursors.SizeWE.handle; break; + case HitTest.HTTOP: handle = Cursors.SizeNS.handle; break; + case HitTest.HTTOPLEFT: handle = Cursors.SizeNWSE.handle; break; + case HitTest.HTTOPRIGHT: handle = Cursors.SizeNESW.handle; break; + + #if SameAsDefault + case HitTest.HTGROWBOX: + case HitTest.HTSIZE: + case HitTest.HTZOOM: + case HitTest.HTVSCROLL: + case HitTest.HTSYSMENU: + case HitTest.HTREDUCE: + case HitTest.HTNOWHERE: + case HitTest.HTMAXBUTTON: + case HitTest.HTMINBUTTON: + case HitTest.HTMENU: + case HitTest.HSCROLL: + case HitTest.HTBOTTOM: + case HitTest.HTCAPTION: + case HitTest.HTCLIENT: + case HitTest.HTCLOSE: + #endif + default: handle = Cursors.Default.handle; break; + } + SetCursor(msg.HWnd, handle); + } + return (IntPtr)1; + } + } + return IntPtr.Zero; + } + + internal override void DestroyCaret (IntPtr hwnd) { + if (Caret.Hwnd == hwnd) { + if (Caret.Visible == 1) { + Caret.Timer.Stop (); + HideCaret (); + } + Caret.Hwnd = IntPtr.Zero; + Caret.Visible = 0; + Caret.On = false; + } + } + + [MonoTODO] + internal override void DestroyCursor(IntPtr cursor) { + throw new NotImplementedException (); + } + + internal override void DestroyWindow(IntPtr handle) { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd == null) { + return; + } + + SendParentNotify (hwnd.Handle, Msg.WM_DESTROY, int.MaxValue, int.MaxValue); + + CleanupCachedWindows (hwnd); + + ArrayList windows = new ArrayList (); + + AccumulateDestroyedHandles (Widget.WidgetNativeWindow.WidgetFromHandle(hwnd.Handle), windows); + + + foreach (Hwnd h in windows) { + SendMessage (h.Handle, Msg.WM_DESTROY, IntPtr.Zero, IntPtr.Zero); + h.zombie = true; + } + + // TODO: This is crashing swf-messageboxes + /* + if (false && hwnd.whole_window != IntPtr.Zero) + CFRelease (hwnd.whole_window); + if (false && hwnd.client_window != IntPtr.Zero) + CFRelease (hwnd.client_window); + */ + + if (WindowMapping [hwnd.Handle] != null) { + DisposeWindow ((IntPtr)(WindowMapping [hwnd.Handle])); + WindowMapping.Remove (hwnd.Handle); + } + } + + internal override IntPtr DispatchMessage(ref MSG msg) { + return NativeWindow.WndProc(msg.hwnd, msg.message, msg.wParam, msg.lParam); + } + + internal override void DoEvents() { + MSG msg = new MSG (); + + in_doevents = true; + while (PeekMessage (null, ref msg, IntPtr.Zero, 0, 0, (uint)PeekMessageFlags.PM_REMOVE)) { + TranslateMessage (ref msg); + DispatchMessage (ref msg); + } + in_doevents = false; + + } + + internal override void EnableWindow(IntPtr handle, bool Enable) { + //Like X11 we need not do anything here + } + + internal override void EndLoop(Thread thread) { + } + + internal void Exit () { + GetMessageResult = false; + } + + internal override IntPtr GetActive() { + return ActiveWindow; + } + + internal override Region GetClipRegion(IntPtr hwnd) { + return null; + } + + [MonoTODO] + internal override void GetCursorInfo(IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y) { + width = 12; + height = 12; + hotspot_x = 0; + hotspot_y = 0; + } + + internal override void GetDisplaySize(out Size size) { + Carbon.HIRect bounds = CGDisplayBounds (CGMainDisplayID ()); + size = new Size ((int)bounds.size.width, (int)bounds.size.height); + } + + internal override IntPtr GetParent(IntPtr handle) { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + if (hwnd != null && hwnd.Parent != null) { + return hwnd.Parent.Handle; + } + return IntPtr.Zero; + } + + internal override IntPtr GetPreviousWindow(IntPtr handle) { + return HIViewGetPreviousView(handle); + } + + internal override void GetCursorPos(IntPtr handle, out int x, out int y) { + Carbon.QDPoint pt = new Carbon.QDPoint (); + GetGlobalMouse (ref pt); + x = pt.x; + y = pt.y; + } + + internal override IntPtr GetFocus() { + return FocusWindow; + } + + + internal override bool GetFontMetrics(Graphics g, Font font, out int ascent, out int descent) { + FontFamily ff = font.FontFamily; + ascent = ff.GetCellAscent (font.Style); + descent = ff.GetCellDescent (font.Style); + return true; + } + + internal override Point GetMenuOrigin(IntPtr handle) { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) { + return hwnd.MenuOrigin; + } + return Point.Empty; + } + + internal override bool GetMessage(object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax) { + IntPtr evtRef = IntPtr.Zero; + IntPtr target = GetEventDispatcherTarget(); + CheckTimers (DateTime.UtcNow); + ReceiveNextEvent (0, IntPtr.Zero, 0, true, ref evtRef); + if (evtRef != IntPtr.Zero && target != IntPtr.Zero) { + SendEventToEventTarget (evtRef, target); + ReleaseEvent (evtRef); + } + + object queueobj; + loop: + lock (queuelock) { + + if (MessageQueue.Count <= 0) { + if (Idle != null) + Idle (this, EventArgs.Empty); + else if (TimerList.Count == 0) { + ReceiveNextEvent (0, IntPtr.Zero, 0.15, true, ref evtRef); + if (evtRef != IntPtr.Zero && target != IntPtr.Zero) { + SendEventToEventTarget (evtRef, target); + ReleaseEvent (evtRef); + } + } else { + ReceiveNextEvent (0, IntPtr.Zero, NextTimeout (), true, ref evtRef); + if (evtRef != IntPtr.Zero && target != IntPtr.Zero) { + SendEventToEventTarget (evtRef, target); + ReleaseEvent (evtRef); + } + } + msg.hwnd = IntPtr.Zero; + msg.message = Msg.WM_ENTERIDLE; + return GetMessageResult; + } + queueobj = MessageQueue.Dequeue (); + } + if (queueobj is GCHandle) { + XplatUIDriverSupport.ExecuteClientMessage((GCHandle)queueobj); + goto loop; + } else { + msg = (MSG)queueobj; + } + return GetMessageResult; + } + + [MonoTODO] + internal override bool GetText(IntPtr handle, out string text) { + throw new NotImplementedException (); + } + + internal override void GetWindowPos(IntPtr handle, bool is_toplevel, out int x, out int y, out int width, out int height, out int client_width, out int client_height) { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) { + x = hwnd.x; + y = hwnd.y; + width = hwnd.width; + height = hwnd.height; + + PerformNCCalc(hwnd); + + client_width = hwnd.ClientRect.Width; + client_height = hwnd.ClientRect.Height; + + return; + } + + // Should we throw an exception or fail silently? + // throw new ArgumentException("Called with an invalid window handle", "handle"); + + x = 0; + y = 0; + width = 0; + height = 0; + client_width = 0; + client_height = 0; + } + + internal override FormWindowState GetWindowState(IntPtr hwnd) { + IntPtr window = HIViewGetWindow (hwnd); + + if (IsWindowCollapsed (window)) + return FormWindowState.Minimized; + if (IsWindowInStandardState (window, IntPtr.Zero, IntPtr.Zero)) + return FormWindowState.Maximized; + + return FormWindowState.Normal; + } + + internal override void GrabInfo(out IntPtr handle, out bool GrabConfined, out Rectangle GrabArea) { + handle = Grab.Hwnd; + GrabConfined = Grab.Confined; + GrabArea = Grab.Area; + } + + internal override void GrabWindow(IntPtr handle, IntPtr confine_to_handle) { + Grab.Hwnd = handle; + Grab.Confined = confine_to_handle != IntPtr.Zero; + /* FIXME: Set the Grab.Area */ + } + + internal override void UngrabWindow(IntPtr hwnd) { + bool was_grabbed = Grab.Hwnd != IntPtr.Zero; + + Grab.Hwnd = IntPtr.Zero; + Grab.Confined = false; + + if (was_grabbed) { + // lparam should be the handle to the window gaining the mouse capture, + // but we dont have that information like X11. + // Also only generate WM_CAPTURECHANGED if the window actually was grabbed. + SendMessage (hwnd, Msg.WM_CAPTURECHANGED, IntPtr.Zero, IntPtr.Zero); + } + } + + internal override void HandleException(Exception e) { + StackTrace st = new StackTrace(e); + Console.WriteLine("Exception '{0}'", e.Message+st.ToString()); + Console.WriteLine("{0}{1}", e.Message, st.ToString()); + } + + internal override void Invalidate (IntPtr handle, Rectangle rc, bool clear) { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (clear) { + AddExpose (hwnd, true, hwnd.X, hwnd.Y, hwnd.Width, hwnd.Height); + } else { + AddExpose (hwnd, true, rc.X, rc.Y, rc.Width, rc.Height); + } + } + + internal override void InvalidateNC (IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + AddExpose (hwnd, false, 0, 0, hwnd.Width, hwnd.Height); + } + + internal override bool IsEnabled(IntPtr handle) { + return Hwnd.ObjectFromHandle(handle).Enabled; + } + + internal override bool IsVisible(IntPtr handle) { + return Hwnd.ObjectFromHandle(handle).visible; + } + + internal override void KillTimer(Timer timer) { + lock (TimerList) { + TimerList.Remove(timer); + } + } + + + internal override void OverrideCursor(IntPtr cursor) { + } + + internal override PaintEventArgs PaintEventStart(ref Message msg, IntPtr handle, bool client) { + PaintEventArgs paint_event; + Hwnd hwnd; + Hwnd paint_hwnd; + + hwnd = Hwnd.ObjectFromHandle(msg.HWnd); + if (msg.HWnd == handle) { + paint_hwnd = hwnd; + } else { + paint_hwnd = Hwnd.ObjectFromHandle (handle); + } + + if (Caret.Visible == 1) { + Caret.Paused = true; + HideCaret(); + } + + Graphics dc; + + if (client) { + dc = Graphics.FromHwnd (paint_hwnd.client_window); + + Region clip_region = new Region (); + clip_region.MakeEmpty(); + + foreach (Rectangle r in hwnd.ClipRectangles) { + /* Expand the region slightly. + * See bug 464464. + */ + Rectangle r2 = Rectangle.FromLTRB (r.Left, r.Top, r.Right, r.Bottom + 1); + clip_region.Union (r2); + } + + if (hwnd.UserClip != null) { + clip_region.Intersect(hwnd.UserClip); + } + + // FIXME: Clip region is hosed + dc.Clip = clip_region; + paint_event = new PaintEventArgs(dc, hwnd.Invalid); + hwnd.expose_pending = false; + hwnd.ClearInvalidArea(); + + hwnd.drawing_stack.Push (paint_event); + hwnd.drawing_stack.Push (dc); + } else { + dc = Graphics.FromHwnd (paint_hwnd.whole_window); + + if (!hwnd.nc_invalid.IsEmpty) { + // FIXME: Clip region is hosed + dc.SetClip (hwnd.nc_invalid); + paint_event = new PaintEventArgs(dc, hwnd.nc_invalid); + } else { + paint_event = new PaintEventArgs(dc, new Rectangle(0, 0, hwnd.width, hwnd.height)); + } + hwnd.nc_expose_pending = false; + hwnd.ClearNcInvalidArea (); + + hwnd.drawing_stack.Push (paint_event); + hwnd.drawing_stack.Push (dc); + } + + return paint_event; + } + + internal override void PaintEventEnd(ref Message msg, IntPtr handle, bool client) { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + // FIXME: Pop is causing invalid stack ops sometimes; race condition? + try { + Graphics dc = (Graphics)hwnd.drawing_stack.Pop(); + dc.Flush (); + dc.Dispose (); + + PaintEventArgs pe = (PaintEventArgs)hwnd.drawing_stack.Pop(); + pe.SetGraphics (null); + pe.Dispose (); + } catch {} + + if (Caret.Visible == 1) { + ShowCaret(); + Caret.Paused = false; + } + } + + internal override bool PeekMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags) { + IntPtr evtRef = IntPtr.Zero; + IntPtr target = GetEventDispatcherTarget(); + CheckTimers (DateTime.UtcNow); + ReceiveNextEvent (0, IntPtr.Zero, 0, true, ref evtRef); + if (evtRef != IntPtr.Zero && target != IntPtr.Zero) { + SendEventToEventTarget (evtRef, target); + ReleaseEvent (evtRef); + } + + lock (queuelock) { + if (MessageQueue.Count <= 0) { + return false; + } else { + object queueobj; + if (flags == (uint)PeekMessageFlags.PM_REMOVE) + queueobj = MessageQueue.Dequeue (); + else + queueobj = MessageQueue.Peek (); + + if (queueobj is GCHandle) { + XplatUIDriverSupport.ExecuteClientMessage((GCHandle)queueobj); + return false; + } + msg = (MSG)queueobj; + return true; + } + } + } + + internal override bool PostMessage (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam) { + MSG msg = new MSG(); + msg.hwnd = hwnd; + msg.message = message; + msg.wParam = wParam; + msg.lParam = lParam; + EnqueueMessage (msg); + return true; + } + + internal override void PostQuitMessage(int exitCode) { + PostMessage (FosterParent, Msg.WM_QUIT, IntPtr.Zero, IntPtr.Zero); + } + + internal override void RequestAdditionalWM_NCMessages(IntPtr hwnd, bool hover, bool leave) { + } + + internal override void RequestNCRecalc(IntPtr handle) { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd == null) { + return; + } + + PerformNCCalc(hwnd); + SendMessage(handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + InvalidateNC(handle); + } + + [MonoTODO] + internal override void ResetMouseHover(IntPtr handle) { + throw new NotImplementedException(); + } + + internal override void ScreenToClient(IntPtr handle, ref int x, ref int y) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + Point point = ConvertScreenPointToClient (hwnd.ClientWindow, new Point (x, y)); + + x = point.X; + y = point.Y; + } + + internal override void ScreenToMenu(IntPtr handle, ref int x, ref int y) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + Point point = ConvertScreenPointToClient (hwnd.WholeWindow, new Point (x, y)); + + x = point.X; + y = point.Y; + } + + internal override void ScrollWindow(IntPtr handle, Rectangle area, int XAmount, int YAmount, bool clear) { + /* + * This used to use a HIViewScrollRect but this causes issues with the fact that we dont coalesce + * updates properly with our short-circuiting of the window manager. For now we'll do a less + * efficient invalidation of the entire handle which appears to fix the problem + * see bug #381084 + */ + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + Invalidate (handle, new Rectangle (0, 0, hwnd.Width, hwnd.Height), false); + } + + + internal override void ScrollWindow(IntPtr handle, int XAmount, int YAmount, bool clear) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + Invalidate (handle, new Rectangle (0, 0, hwnd.Width, hwnd.Height), false); + } + + [MonoTODO] + internal override void SendAsyncMethod (AsyncMethodData method) { + // Fake async + lock (queuelock) { + MessageQueue.Enqueue (GCHandle.Alloc (method)); + } + } + + [MonoTODO] + internal override IntPtr SendMessage (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam) { + return NativeWindow.WndProc(hwnd, message, wParam, lParam); + } + + internal override int SendInput(IntPtr hwnd, Queue keys) { + return 0; + } + + + internal override void SetCaretPos (IntPtr hwnd, int x, int y) { + if (hwnd != IntPtr.Zero && hwnd == Caret.Hwnd) { + Caret.X = x; + Caret.Y = y; + ClientToScreen (hwnd, ref x, ref y); + SizeWindow (new Rectangle (x, y, Caret.Width, Caret.Height), CaretWindow); + Caret.Timer.Stop (); + HideCaret (); + if (Caret.Visible == 1) { + ShowCaret (); + Caret.Timer.Start (); + } + } + } + + internal override void SetClipRegion(IntPtr hwnd, Region region) { + throw new NotImplementedException(); + } + + internal override void SetCursor(IntPtr window, IntPtr cursor) { + Hwnd hwnd = Hwnd.ObjectFromHandle (window); + + hwnd.Cursor = cursor; + } + + internal override void SetCursorPos(IntPtr handle, int x, int y) { + CGDisplayMoveCursorToPoint (CGMainDisplayID (), new Carbon.CGPoint (x, y)); + } + + internal override void SetFocus(IntPtr handle) { + if (FocusWindow != IntPtr.Zero) { + PostMessage(FocusWindow, Msg.WM_KILLFOCUS, handle, IntPtr.Zero); + } + PostMessage(handle, Msg.WM_SETFOCUS, FocusWindow, IntPtr.Zero); + FocusWindow = handle; + } + + internal override void SetIcon(IntPtr handle, Icon icon) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + // FIXME: we need to map the icon for active window switches + if (WindowMapping [hwnd.Handle] != null) { + if (icon == null) { + RestoreApplicationDockTileImage (); + } else { + Bitmap bitmap; + int size; + IntPtr[] data; + int index; + + bitmap = new Bitmap (128, 128); + using (Graphics g = Graphics.FromImage (bitmap)) { + g.DrawImage (icon.ToBitmap (), 0, 0, 128, 128); + } + index = 0; + size = bitmap.Width * bitmap.Height; + data = new IntPtr[size]; + + for (int y = 0; y < bitmap.Height; y++) { + for (int x = 0; x < bitmap.Width; x++) { + int pixel = bitmap.GetPixel (x, y).ToArgb (); + if (BitConverter.IsLittleEndian) { + byte a = (byte) ((pixel >> 24) & 0xFF); + byte r = (byte) ((pixel >> 16) & 0xFF); + byte g = (byte) ((pixel >> 8) & 0xFF); + byte b = (byte) (pixel & 0xFF); + data[index++] = (IntPtr)(a + (r << 8) + (g << 16) + (b << 24)); + } else { + data[index++] = (IntPtr)pixel; + } + } + } + + IntPtr provider = CGDataProviderCreateWithData (IntPtr.Zero, data, size*4, IntPtr.Zero); + IntPtr image = CGImageCreate (128, 128, 8, 32, 4*128, CGColorSpaceCreateDeviceRGB (), 4, provider, IntPtr.Zero, 0, 0); + SetApplicationDockTileImage (image); + } + } + } + + + internal override void SetModal(IntPtr handle, bool Modal) { + IntPtr hWnd = HIViewGetWindow (Hwnd.ObjectFromHandle (handle).WholeWindow); + if (Modal) + BeginAppModalStateForWindow (hWnd); + else + EndAppModalStateForWindow (hWnd); + return; + } + + internal override IntPtr SetParent(IntPtr handle, IntPtr parent) { + IntPtr ParentHandle = IntPtr.Zero; + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + hwnd.Parent = Hwnd.ObjectFromHandle (parent); + if (HIViewGetSuperview (hwnd.whole_window) != IntPtr.Zero) { + HIViewRemoveFromSuperview (hwnd.whole_window); + } + if (hwnd.parent == null) + HIViewFindByID (HIViewGetRoot (FosterParent), new Carbon.HIViewID (Carbon.EventHandler.kEventClassWindow, 1), ref ParentHandle); + HIViewAddSubview (hwnd.parent == null ? ParentHandle : hwnd.Parent.client_window, hwnd.whole_window); + HIViewPlaceInSuperviewAt (hwnd.whole_window, hwnd.X, hwnd.Y); + HIViewAddSubview (hwnd.whole_window, hwnd.client_window); + HIViewPlaceInSuperviewAt (hwnd.client_window, hwnd.ClientRect.X, hwnd.ClientRect.Y); + + return IntPtr.Zero; + } + + internal override void SetTimer (Timer timer) { + lock (TimerList) { + TimerList.Add (timer); + } + } + + internal override bool SetTopmost(IntPtr hWnd, bool Enabled) { + HIViewSetZOrder (hWnd, 1, IntPtr.Zero); + return true; + } + + internal override bool SetOwner(IntPtr hWnd, IntPtr hWndOwner) { + // TODO: Set window owner. + return true; + } + + internal override bool SetVisible(IntPtr handle, bool visible, bool activate) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + object window = WindowMapping [hwnd.Handle]; + if (window != null) + if (visible) + ShowWindow ((IntPtr)window); + else + HideWindow ((IntPtr)window); + + if (visible) + SendMessage(handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + + HIViewSetVisible (hwnd.whole_window, visible); + HIViewSetVisible (hwnd.client_window, visible); + + hwnd.visible = visible; + hwnd.Mapped = true; + return true; + } + + internal override void SetAllowDrop (IntPtr handle, bool value) { + // Like X11 we allow drop on al windows and filter in our handler + } + + internal override DragDropEffects StartDrag (IntPtr handle, object data, DragDropEffects allowed_effects) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd == null) + throw new ArgumentException ("Attempt to begin drag from invalid window handle (" + handle.ToInt32 () + ")."); + + return Dnd.StartDrag (hwnd.client_window, data, allowed_effects); + } + + internal override void SetBorderStyle(IntPtr handle, FormBorderStyle border_style) { + Form form = Widget.FromHandle (handle) as Form; + if (form != null && form.window_manager == null && (border_style == FormBorderStyle.FixedToolWindow || + border_style == FormBorderStyle.SizableToolWindow)) { + form.window_manager = new ToolWindowManager (form); + } + + RequestNCRecalc(handle); + } + + internal override void SetMenu(IntPtr handle, Menu menu) { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + hwnd.menu = menu; + + RequestNCRecalc(handle); + } + + internal override void SetWindowMinMax(IntPtr handle, Rectangle maximized, Size min, Size max) { + } + + internal override void SetWindowPos(IntPtr handle, int x, int y, int width, int height) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd == null) { + return; + } + + // Win32 automatically changes negative width/height to 0. + if (width < 0) + width = 0; + if (height < 0) + height = 0; + + // X requires a sanity check for width & height; otherwise it dies + if (hwnd.zero_sized && width > 0 && height > 0) { + if (hwnd.visible) { + HIViewSetVisible(hwnd.WholeWindow, true); + } + hwnd.zero_sized = false; + } + + if ((width < 1) || (height < 1)) { + hwnd.zero_sized = true; + HIViewSetVisible(hwnd.WholeWindow, false); + } + + // Save a server roundtrip (and prevent a feedback loop) + if ((hwnd.x == x) && (hwnd.y == y) && (hwnd.width == width) && (hwnd.height == height)) { + return; + } + + if (!hwnd.zero_sized) { + hwnd.x = x; + hwnd.y = y; + hwnd.width = width; + hwnd.height = height; + SendMessage(hwnd.client_window, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + + Widget ctrl = Widget.FromHandle (handle); + CreateParams cp = ctrl.GetCreateParams (); + Size TranslatedSize = TranslateWindowSizeToQuartzWindowSize (cp, new Size (width, height)); + Carbon.Rect rect = new Carbon.Rect (); + + if (WindowMapping [hwnd.Handle] != null) { + if (StyleSet (cp.Style, WindowStyles.WS_POPUP)) { + SetRect (ref rect, (short)x, (short)y, (short)(x+TranslatedSize.Width), (short)(y+TranslatedSize.Height)); + } else { + SetRect (ref rect, (short)x, (short)(y+MenuBarHeight), (short)(x+TranslatedSize.Width), (short)(y+MenuBarHeight+TranslatedSize.Height)); + } + SetWindowBounds ((IntPtr) WindowMapping [hwnd.Handle], 33, ref rect); + Carbon.HIRect frame_rect = new Carbon.HIRect (0, 0, TranslatedSize.Width, TranslatedSize.Height); + HIViewSetFrame (hwnd.whole_window, ref frame_rect); + SetCaretPos (Caret.Hwnd, Caret.X, Caret.Y); + } else { + Carbon.HIRect frame_rect = new Carbon.HIRect (x, y, TranslatedSize.Width, TranslatedSize.Height); + HIViewSetFrame (hwnd.whole_window, ref frame_rect); + } + PerformNCCalc(hwnd); + } + + hwnd.x = x; + hwnd.y = y; + hwnd.width = width; + hwnd.height = height; + } + + internal override void SetWindowState(IntPtr handle, FormWindowState state) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + IntPtr window = HIViewGetWindow (handle); + + switch (state) { + case FormWindowState.Minimized: { + CollapseWindow (window, true); + break; + } + case FormWindowState.Normal: { + ZoomWindow (window, 7, false); + break; + } + case FormWindowState.Maximized: { + Form form = Widget.FromHandle (hwnd.Handle) as Form; + if (form != null && form.FormBorderStyle == FormBorderStyle.None) { + Carbon.Rect rect = new Carbon.Rect (); + Carbon.HIRect bounds = CGDisplayBounds (CGMainDisplayID ()); + SetRect (ref rect, (short)0, (short)0, (short)bounds.size.width, (short)bounds.size.height); + SetWindowBounds ((IntPtr) WindowMapping [hwnd.Handle], 33, ref rect); + HIViewSetFrame (hwnd.whole_window, ref bounds); + } else { + ZoomWindow (window, 8, false); + } + break; + } + } + } + + internal override void SetWindowStyle(IntPtr handle, CreateParams cp) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + SetHwndStyles(hwnd, cp); + + if (WindowMapping [hwnd.Handle] != null) { + Carbon.WindowAttributes attributes = Carbon.WindowAttributes.kWindowCompositingAttribute | Carbon.WindowAttributes.kWindowStandardHandlerAttribute; + if ((cp.Style & ((int)WindowStyles.WS_MINIMIZEBOX)) != 0) { + attributes |= Carbon.WindowAttributes.kWindowCollapseBoxAttribute; + } + if ((cp.Style & ((int)WindowStyles.WS_MAXIMIZEBOX)) != 0) { + attributes |= Carbon.WindowAttributes.kWindowResizableAttribute | Carbon.WindowAttributes.kWindowHorizontalZoomAttribute | Carbon.WindowAttributes.kWindowVerticalZoomAttribute; + } + if ((cp.Style & ((int)WindowStyles.WS_SYSMENU)) != 0) { + attributes |= Carbon.WindowAttributes.kWindowCloseBoxAttribute; + } + if ((cp.ExStyle & ((int)WindowExStyles.WS_EX_TOOLWINDOW)) != 0) { + attributes = Carbon.WindowAttributes.kWindowStandardHandlerAttribute | Carbon.WindowAttributes.kWindowCompositingAttribute; + } + attributes |= Carbon.WindowAttributes.kWindowLiveResizeAttribute; + + Carbon.WindowAttributes outAttributes = Carbon.WindowAttributes.kWindowNoAttributes; + GetWindowAttributes ((IntPtr)WindowMapping [hwnd.Handle], ref outAttributes); + ChangeWindowAttributes ((IntPtr)WindowMapping [hwnd.Handle], attributes, outAttributes); + } + } + + internal override void SetWindowTransparency(IntPtr handle, double transparency, Color key) { + } + + internal override double GetWindowTransparency(IntPtr handle) + { + return 1.0; + } + + internal override TransparencySupport SupportsTransparency() { + return TransparencySupport.None; + } + + internal override bool SetZOrder(IntPtr handle, IntPtr after_handle, bool Top, bool Bottom) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + if (Top) { + HIViewSetZOrder (hwnd.whole_window, 2, IntPtr.Zero); + return true; + } else if (!Bottom) { + Hwnd after_hwnd = Hwnd.ObjectFromHandle (after_handle); + HIViewSetZOrder (hwnd.whole_window, 2, (after_handle == IntPtr.Zero ? IntPtr.Zero : after_hwnd.whole_window)); + } else { + HIViewSetZOrder (hwnd.whole_window, 1, IntPtr.Zero); + return true; + } + return false; + } + + internal override void ShowCursor(bool show) { + if (show) + CGDisplayShowCursor (CGMainDisplayID ()); + else + CGDisplayHideCursor (CGMainDisplayID ()); + } + + internal override object StartLoop(Thread thread) { + return new object (); + } + + [MonoTODO] + internal override bool SystrayAdd(IntPtr hwnd, string tip, Icon icon, out ToolTip tt) { + throw new NotImplementedException(); + } + + [MonoTODO] + internal override bool SystrayChange(IntPtr hwnd, string tip, Icon icon, ref ToolTip tt) { + throw new NotImplementedException(); + } + + [MonoTODO] + internal override void SystrayRemove(IntPtr hwnd, ref ToolTip tt) { + throw new NotImplementedException(); + } + + [MonoTODO] + internal override void SystrayBalloon(IntPtr hwnd, int timeout, string title, string text, ToolTipIcon icon) + { + throw new NotImplementedException (); + } + + internal override bool Text(IntPtr handle, string text) { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + if (WindowMapping [hwnd.Handle] != null) { + SetWindowTitleWithCFString ((IntPtr)(WindowMapping [hwnd.Handle]), __CFStringMakeConstantString (text)); + } + SetWidgetTitleWithCFString (hwnd.whole_window, __CFStringMakeConstantString (text)); + SetWidgetTitleWithCFString (hwnd.client_window, __CFStringMakeConstantString (text)); + return true; + } + + internal override void UpdateWindow(IntPtr handle) { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (!hwnd.visible || !HIViewIsVisible (handle)) { + return; + } + + SendMessage(handle, Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero); + } + + internal override bool TranslateMessage(ref MSG msg) { + return Carbon.EventHandler.TranslateMessage (ref msg); + } + + #region Reversible regions + /* + * Quartz has no concept of XOR drawing due to its compositing nature + * We fake this by mapping a overlay window on the first draw and mapping it on the second. + * This has some issues with it because its POSSIBLE for WidgetPaint.DrawReversible* to actually + * reverse two regions at once. We dont do this in MWF, but this behaviour woudn't work. + * We could in theory cache the Rectangle/Color combination to handle this behaviour. + * + * PROBLEMS: This has some flicker / banding + */ + internal void SizeWindow (Rectangle rect, IntPtr window) { + Carbon.Rect qrect = new Carbon.Rect (); + + SetRect (ref qrect, (short)rect.X, (short)rect.Y, (short)(rect.X+rect.Width), (short)(rect.Y+rect.Height)); + + SetWindowBounds (window, 33, ref qrect); + } + + internal override void DrawReversibleLine(Point start, Point end, Color backColor) { +// throw new NotImplementedException(); + } + + internal override void FillReversibleRectangle (Rectangle rectangle, Color backColor) { +// throw new NotImplementedException(); + } + + internal override void DrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style) { +// throw new NotImplementedException(); + } + + internal override void DrawReversibleRectangle(IntPtr handle, Rectangle rect, int line_width) { + Rectangle size_rect = rect; + int new_x = 0; + int new_y = 0; + + if (ReverseWindowMapped) { + HideWindow (ReverseWindow); + ReverseWindowMapped = false; + } else { + ClientToScreen(handle, ref new_x, ref new_y); + + size_rect.X += new_x; + size_rect.Y += new_y; + + SizeWindow (size_rect, ReverseWindow); + ShowWindow (ReverseWindow); + + rect.X = 0; + rect.Y = 0; + rect.Width -= 1; + rect.Height -= 1; + + Graphics g = Graphics.FromHwnd (HIViewGetRoot (ReverseWindow)); + + for (int i = 0; i < line_width; i++) { + g.DrawRectangle (ThemeEngine.Current.ResPool.GetPen (Color.Black), rect); + rect.X += 1; + rect.Y += 1; + rect.Width -= 1; + rect.Height -= 1; + } + + g.Flush (); + g.Dispose (); + + ReverseWindowMapped = true; + } + } + #endregion + + internal override SizeF GetAutoScaleSize(Font font) { + Graphics g; + float width; + string magic_string = "The quick brown fox jumped over the lazy dog."; + double magic_number = 44.549996948242189; + + g = Graphics.FromImage (new Bitmap (1, 1)); + + width = (float) (g.MeasureString (magic_string, font).Width / magic_number); + return new SizeF(width, font.Height); + } + + internal override Point MousePosition { + get { + return mouse_position; + } + } + #endregion + + #region System information + internal override int KeyboardSpeed { get{ throw new NotImplementedException(); } } + internal override int KeyboardDelay { get{ throw new NotImplementedException(); } } + + internal override int CaptionHeight { + get { + return 19; + } + } + + internal override Size CursorSize { get{ throw new NotImplementedException(); } } + internal override bool DragFullWindows { get{ throw new NotImplementedException(); } } + internal override Size DragSize { + get { + return new Size(4, 4); + } + } + + internal override Size FrameBorderSize { + get { + return new Size (2, 2); + } + } + + internal override Size IconSize { get{ throw new NotImplementedException(); } } + internal override Size MaxWindowTrackSize { get{ throw new NotImplementedException(); } } + internal override bool MenuAccessKeysUnderlined { + get { + return false; + } + } + internal override Size MinimizedWindowSpacingSize { get{ throw new NotImplementedException(); } } + + internal override Size MinimumWindowSize { + get { + return new Size(110, 22); + } + } + + internal override Keys ModifierKeys { + get { + return KeyboardHandler.ModifierKeys; + } + } + internal override Size SmallIconSize { get{ throw new NotImplementedException(); } } + internal override int MouseButtonCount { get{ throw new NotImplementedException(); } } + internal override bool MouseButtonsSwapped { get{ throw new NotImplementedException(); } } + internal override bool MouseWheelPresent { get{ throw new NotImplementedException(); } } + + internal override MouseButtons MouseButtons { + get { + return MouseState; + } + } + + internal override Rectangle VirtualScreen { + get { + return WorkingArea; + } + } + + internal override Rectangle WorkingArea { + get { + Carbon.HIRect bounds = CGDisplayBounds (CGMainDisplayID ()); + return new Rectangle ((int)bounds.origin.x, (int)bounds.origin.y, (int)bounds.size.width, (int)bounds.size.height); + } + } + + [MonoTODO] + internal override Screen[] AllScreens { + get { + return null; + } + } + + internal override bool ThemesEnabled { + get { + return XplatUICarbon.themes_enabled; + } + } + + + #endregion + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIViewConvertPoint (ref Carbon.CGPoint point, IntPtr pView, IntPtr cView); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIViewChangeFeatures (IntPtr aView, ulong bitsin, ulong bitsout); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIViewFindByID (IntPtr rootWnd, Carbon.HIViewID id, ref IntPtr outPtr); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIGrowBoxViewSetTransparent (IntPtr GrowBox, bool transparency); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static IntPtr HIViewGetRoot (IntPtr hWnd); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIObjectCreate (IntPtr cfStr, uint what, ref IntPtr hwnd); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIObjectRegisterSubclass (IntPtr classid, IntPtr superclassid, uint options, Carbon.EventDelegate upp, uint count, Carbon.EventTypeSpec [] list, IntPtr state, ref IntPtr cls); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIViewPlaceInSuperviewAt (IntPtr view, float x, float y); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIViewAddSubview (IntPtr parentHnd, IntPtr childHnd); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static IntPtr HIViewGetPreviousView (IntPtr aView); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static IntPtr HIViewGetSuperview (IntPtr aView); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIViewRemoveFromSuperview (IntPtr aView); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIViewSetVisible (IntPtr vHnd, bool visible); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static bool HIViewIsVisible (IntPtr vHnd); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIViewGetBounds (IntPtr vHnd, ref Carbon.HIRect r); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIViewScrollRect (IntPtr vHnd, ref Carbon.HIRect rect, float x, float y); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIViewSetZOrder (IntPtr hWnd, int cmd, IntPtr oHnd); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIViewNewTrackingArea (IntPtr inView, IntPtr inShape, UInt64 inID, ref IntPtr outRef); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static IntPtr HIViewGetWindow (IntPtr aView); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int HIViewSetFrame (IntPtr view_handle, ref Carbon.HIRect bounds); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal extern static int HIViewSetNeedsDisplayInRect (IntPtr view_handle, ref Carbon.HIRect rect, bool needs_display); + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static void SetRect (ref Carbon.Rect r, short left, short top, short right, short bottom); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int ActivateWindow (IntPtr windowHnd, bool inActivate); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern bool IsWindowActive (IntPtr windowHnd); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + static extern int SetAutomaticWidgetDragTrackingEnabledForWindow (IntPtr window, bool enabled); + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static IntPtr GetEventDispatcherTarget (); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int SendEventToEventTarget (IntPtr evt, IntPtr target); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int ReleaseEvent (IntPtr evt); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int ReceiveNextEvent (uint evtCount, IntPtr evtTypes, double timeout, bool processEvt, ref IntPtr evt); + + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static bool IsWindowCollapsed (IntPtr hWnd); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static bool IsWindowInStandardState (IntPtr hWnd, IntPtr a, IntPtr b); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static void CollapseWindow (IntPtr hWnd, bool collapse); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static void ZoomWindow (IntPtr hWnd, short partCode, bool front); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int GetWindowAttributes (IntPtr hWnd, ref Carbon.WindowAttributes outAttributes); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int ChangeWindowAttributes (IntPtr hWnd, Carbon.WindowAttributes inAttributes, Carbon.WindowAttributes outAttributes); + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal extern static int GetGlobalMouse (ref Carbon.QDPoint outData); + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int BeginAppModalStateForWindow (IntPtr window); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int EndAppModalStateForWindow (IntPtr window); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int CreateNewWindow (Carbon.WindowClass klass, Carbon.WindowAttributes attributes, ref Carbon.Rect r, ref IntPtr window); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int DisposeWindow (IntPtr wHnd); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal extern static int ShowWindow (IntPtr wHnd); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal extern static int HideWindow (IntPtr wHnd); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal extern static bool IsWindowVisible (IntPtr wHnd); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int SetWindowBounds (IntPtr wHnd, uint reg, ref Carbon.Rect rect); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int GetWindowBounds (IntPtr wHnd, uint reg, ref Carbon.Rect rect); + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int SetWidgetTitleWithCFString (IntPtr hWnd, IntPtr titleCFStr); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int SetWindowTitleWithCFString (IntPtr hWnd, IntPtr titleCFStr); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal extern static IntPtr __CFStringMakeConstantString (string cString); + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + internal extern static int CFRelease (IntPtr wHnd); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static short GetMBarHeight (); + + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static void AlertSoundPlay (); + + #region Cursor imports + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static Carbon.HIRect CGDisplayBounds (IntPtr displayID); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static IntPtr CGMainDisplayID (); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static void CGDisplayShowCursor (IntPtr display); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static void CGDisplayHideCursor (IntPtr display); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static void CGDisplayMoveCursorToPoint (IntPtr display, Carbon.CGPoint point); + #endregion + + #region Process imports + [DllImport ("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int GetCurrentProcess (ref Carbon.ProcessSerialNumber psn); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int TransformProcessType (ref Carbon.ProcessSerialNumber psn, uint type); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static int SetFrontProcess (ref Carbon.ProcessSerialNumber psn); + #endregion + + #region Dock tile imports + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static IntPtr CGColorSpaceCreateDeviceRGB(); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static IntPtr CGDataProviderCreateWithData (IntPtr info, IntPtr [] data, int size, IntPtr releasefunc); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static IntPtr CGImageCreate (int width, int height, int bitsPerComponent, int bitsPerPixel, int bytesPerRow, IntPtr colorspace, uint bitmapInfo, IntPtr provider, IntPtr decode, int shouldInterpolate, int intent); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static void SetApplicationDockTileImage(IntPtr imageRef); + [DllImport("/System/Library/Frameworks/Carbon.framework/Versions/Current/Carbon")] + extern static void RestoreApplicationDockTileImage(); + #endregion + } +} diff --git a/source/ShiftUI/Internal/XplatUICosmos.cs b/source/ShiftUI/Internal/XplatUICosmos.cs new file mode 100644 index 0000000..55f30df --- /dev/null +++ b/source/ShiftUI/Internal/XplatUICosmos.cs @@ -0,0 +1,2916 @@ +/* Cosmos XplatUI driver + * + * Author: Michael VanOverbeek + * Based off: XplatUIWin32 driver (ShiftUI\Internal\XplatUIWin32.cs), copyright info can be found there. + * + * Cosmos is a C# open source managed operating system, capable of basic graphics using either + * VGA or VESA BIOS Extensions, it can do full console IO, has a working FAT driver, and is + * written entirely in C# and their homebrewed high-level assembly language, X#. + * + * ShiftUI cannot access Cosmos APIs directly, so to compensate, the CosmosInterface + * class exists. This is an interface between ShiftUI and Cosmos, and it is used + * to tell the operating system where to draw pixels, what colors to use, and when + * something happens, like a window opening or closing, or an error occurring. + * + * This makes it so that ShiftUI doesn't care what graphics driver you use, as long as it + * supports 32bit RGB and you are capable of converting RGB values thrown by ShiftUI + * to the values that your graphics driver wants. + * + * This also means that your OS can deal with actually drawing windows, much like how + * Win32 and X11 does it. It's sort of a "you be the puppet, ShiftUI'll pull the strings" + * situation. + * + * The Cosmos driver is UNFINISHED, and many Win32 code remains. So, if you can continue + * on, or you want to use Cosmos features when I'm done, simply uncomment this: + */ + + //#define COSMOS + + /* + * and the C# compiler and Visual Studio will compile all of the Cosmos stuff. + * + * If you're planning on using ShiftUI for a Windows application or even Linux/Mac, + * DO NOT UNCOMMENT THAT #DEFINE. YOU WILL BREAK LOTS OF THINGS. There is a lot of + * platform-dependent stuff in Mono Winforms which is what ShiftUI is HEAVILY based + * off of, for example, when the app starts, it detects if you're on Windows, Mac or + * Linux, so that it knows whether to use Win32, X11, or Carbon. Cosmos can't really + * determine what OS it's running on because it IS an OS, so the COSMOS #define is + * used to bypass the platform-dependent stuff and make ShiftUI work specifically on + * Cosmos. + * + * Michael VanOverbeek out. + */ + +#if COSMOS +using ShiftUI; +using System; +using System.Collections; +using System.Collections.Generic; +using System.Drawing; +using System.Linq; +using System.Text; +using System.Threading; +using System.Threading.Tasks; + +namespace ShiftUI.Internal +{ + public struct CosmosScreen + { + public int Width { get; set; } + public int Height { get; set; } + public CosmosGfxDriver Driver { get; set; } + } + + public enum CosmosGfxDriver + { + VGA, + VESA, + VMware, + Dummy + } + + public enum CosmosWindowState + { + Maximized, + Minimized, + Normal, + } + + public enum CosmosWindowHint + { + MESSAGEBOX, + TOPLEVEL, + DEFAULT, + BORDERLESS, + DESKTOP, + TOOL, + } + + public class CosmosWindow + { + public IntPtr Handle { get; set; } + public Hwnd Hwnd { get; set; } + public string Title { get; set; } + public CosmosWindowState WindowState { get; set; } + public CosmosWindowHint Style { get; set; } + } + + /// <summary> + /// Because Cosmos cannot do dynamic loading and therefore + /// can't do P/Invokes, I'll let the operating system developer + /// use this interface as a backbone for letting XplatUI actually + /// interact with their operating system. + /// + /// ShiftOS won't use this, however Memphis will, and it's entire window manager + /// will reside in a class deriving from this class. + /// </summary> + public abstract class CosmosInterface + { + public abstract void SetPixel(int x, int y, Color col); + public abstract Color GetPixel(int x, int y); + public abstract CosmosScreen GetScreenInfo(); + public abstract int MouseX { get; } + public abstract int MouseY { get; } + public abstract bool MouseWheelPressed { get; } + internal List<CosmosWindow> Windows = null; + public abstract void Redraw(); + + + + public bool IsWindow(IntPtr handle) + { + if(Windows == null) + { + Windows = new List<Hwnd>(); + return false; + } + foreach(var win in Windows) + { + if (win.Handle == handle) + return true; + } + return false; + } + + /// <summary> + /// Clears the screen with a specified color. + /// </summary> + /// <param name="c">The color to clear to.</param> + public void Clear(Color c) { + var scr = GetScreenInfo(); + int w = scr.Width; + int h = scr.Height; + DrawRectangle(c, new Rectangle(0, 0, w, h)); + } + + /// <summary> + /// Draws a rectangle with the specified Rectangle and color. + /// </summary> + /// <param name="c">The color to use. (Note that depending on the graphics config of the current OS, color quality may be reduced.</param> + /// <param name="rect">The Rectangle struct containing the X and Y coordinates and the width and height.</param> + public void DrawRectangle(Color c, Rectangle rect) + { + int x = rect.X; + int y = rect.Y; + int max_width = rect.Width; + int max_height = rect.Height; + for(int i = x; i < max_width; i++) + { + for(int i2 = y; i2 < max_height; i2++) + { + if (GetPixel(i, i2) != c) + SetPixel(i, i2, c); + } + } + } + + /// <summary> + /// Draws an unfilled rectangle using the specified Rectangle, line width and color. + /// </summary> + public void DrawUnfilledRectangle(Rectangle rect, int width, Color c) + { + //top & bottom border + for(int x = rect.X; x < rect.Width; x++) + { + //top + for(int y = rect.Y; y < rect.Y + width; y++) + { + if (GetPixel(x, y) != c) + SetPixel(x, y, c); + } + + //bottom + for(int y = rect.Height - width; y < rect.Height; y++) + { + if (GetPixel(x, y) != c) + SetPixel(x, y, c); + } + } + + //In theory that code should work for left & right. + for (int y = rect.Y; y < rect.Height; y++) + { + //left + for (int x = rect.X; x < rect.X + width; x++) + { + if (GetPixel(x, y) != c) + SetPixel(x, y, c); + } + + //right + for (int x = rect.Width - width; x < rect.Width; x++) + { + if (GetPixel(x, y) != c) + SetPixel(x, y, c); + } + } + + } + } + + public class DefaultCosmosInterface : CosmosInterface + { + public const string SUI_ERR_NODRIVER = "[ShiftUI] You cannot use ShiftUI yet. You still need to load in a proper CosmosInterface."; + + public override bool MouseWheelPressed + { + get + { + Console.WriteLine(SUI_ERR_NODRIVER); + } + } + + public override int MouseX + { + get + { + Console.WriteLine(SUI_ERR_NODRIVER); + } + } + + public override int MouseY + { + get + { + Console.WriteLine(SUI_ERR_NODRIVER); + } + } + + public override Color GetPixel(int x, int y) + { + Console.WriteLine(SUI_ERR_NODRIVER); + return Color.Empty; + } + + public override CosmosScreen GetScreenInfo() + { + Console.WriteLine(SUI_ERR_NODRIVER); + var s = new CosmosScreen(); + s.Driver = CosmosGfxDriver.Dummy; + s.Width = 0; + s.Height = 0; + return s; + } + + public override void Redraw() + { + Console.WriteLine(SUI_ERR_NODRIVER); + } + + public override void SetPixel(int x, int y, Color col) + { + Console.WriteLine(SUI_ERR_NODRIVER); + } + } + + internal class XplatUICosmos : XplatUIDriver + { +#region Local Variables + private CosmosInterface cosmos = new DefaultCosmosInterface(); + private static XplatUICosmos instance; + private static int ref_count; + private static IntPtr FosterParentLast; + + internal static MouseButtons mouse_state; + internal static Point mouse_position; + internal static bool grab_confined; + internal static IntPtr grab_hwnd; + internal static Rectangle grab_area; + internal static WndProc wnd_proc; + internal static IntPtr prev_mouse_hwnd; + internal static bool caret_visible; + + internal static bool themes_enabled; + private Hashtable timer_list; + private static Queue message_queue; + private static IntPtr clip_magic = new IntPtr(27051977); + private static int scroll_width; + private static int scroll_height; + private static Hashtable wm_nc_registered; + private static Rectangle clipped_cursor_rect; + private Hashtable registered_classes; + private Hwnd HwndCreating; // the Hwnd we are currently creating (see CreateWindow) + +#endregion // Local Variables + +#region Constructor & Destructor + private XplatUICosmos() + { + // Handle singleton stuff first + ref_count = 0; + + mouse_state = MouseButtons.None; + mouse_position = Point.Empty; + + grab_confined = false; + grab_area = Rectangle.Empty; + + message_queue = new List<CosmosMessage>(); + + themes_enabled = true; + + FosterParentLast = IntPtr.Zero; + + scroll_height = 25; + scroll_width = 25; + + timer_list = new Hashtable(); + registered_classes = new Hashtable(); + } +#endregion // Constructor & Destructor + +#region Private Support Methods + + private IntPtr GetFosterParent() + { + if (!cosmos.IsWindow(FosterParentLast)) + { + FosterParentLast = cosmos.CreateWindow("Foster Parent", BorderStyle.None, 0, 0, 0, 0, IntPtr.Zero); + + if (FosterParentLast == IntPtr.Zero) + { + MessageBox.Show("Could not create foster window, system error \"" + cosmos.GetLastError().ToString() = "\".", "Fatal error."); + } + } + return FosterParentLast; + } + +#region Static Properties + internal override int ActiveWindowTrackingDelay + { + get { return 0; } + } + + internal override int CaretWidth + { + get + { + return Application.CurrentSkin.CaretWidth; + } + } + + internal override int FontSmoothingContrast + { + get + { + return 0; + } + } + + internal override int FontSmoothingType + { + get + { + return 0; + } + } + + internal override int HorizontalResizeBorderThickness + { + get { return 5; } + } + + internal override bool IsActiveWindowTrackingEnabled + { + get { return false; } + } + + internal override bool IsComboBoxAnimationEnabled + { + get { return false; } + } + + internal override bool IsDropShadowEnabled + { + get + { + return false; + } + } + + internal override bool IsFontSmoothingEnabled + { + get { return false; } + } + + internal override bool IsHotTrackingEnabled + { + get { return true; } + } + + internal override bool IsIconTitleWrappingEnabled + { + get { return true; } + } + + internal override bool IsKeyboardPreferred + { + get { return false; } + } + + internal override bool IsListBoxSmoothScrollingEnabled + { + get { return false; } + } + + internal override bool IsMenuAnimationEnabled + { + get { return false; } + } + + internal override bool IsMenuFadeEnabled + { + get { return false; } + } + + internal override bool IsMinimizeRestoreAnimationEnabled + { + get + { + return false; + } + } + + internal override bool IsSelectionFadeEnabled + { + get { return false; } + } + + internal override bool IsSnapToDefaultEnabled + { + get { return false; } + } + + internal override bool IsTitleBarGradientEnabled + { + get { return false; } + } + + internal override bool IsToolTipAnimationEnabled + { + get { return false; } + } + + internal override Size MenuBarButtonSize + { + get + { + return new Size(32, 32); + } + } + + public override Size MenuButtonSize + { + get + { + return new Size(32, 32); + } + } + + internal override int MenuShowDelay + { + get { return 0; } + } + + internal override int MouseSpeed + { + get { return Application.CurrentSkin.MouseSpeed; } + } + + internal override LeftRightAlignment PopupMenuAlignment + { + get { return LeftRightAlignment.Left; } + } + + internal override PowerStatus PowerStatus + { + get + { + //Cosmos doesn't have power management. Sadly. + return new PowerStatus(BatteryChargeStatus.Unknown, "No power status for you.".Length, 0.0, 0, PowerLineStatus.Unknown); + } + } + + internal override int SizingBorderWidth + { + get { return Application.CurrentSkin.SizeBorderWidth; } + } + + internal override Size SmallCaptionButtonSize + { + get + { + return new Size(32, 32); + } + } + + internal override bool UIEffectsEnabled + { + get { return false; } + } + + internal override int VerticalResizeBorderThickness + { + get { return 5; } + } + + internal override void RaiseIdle(EventArgs e) + { + if (Idle != null) + Idle(this, e); + } + + internal override Keys ModifierKeys + { + get + { + short state; + Keys key_state; + + key_state = Keys.None; + + return key_state; + } + } + + internal override MouseButtons MouseButtons + { + get + { + return cosmos.MouseState; + } + } + + internal override Point MousePosition + { + get + { + return new Point(cosmos.MouseX, cosmos.MouseY); + } + } + + internal override Size MouseHoverSize + { + get + { + int width = 4; + int height = 4; + return new Size(width, height); + } + } + + internal override int MouseHoverTime + { + get + { + int time = 500; + return time; + } + } + + internal override int MouseWheelScrollDelta + { + get + { + int delta = 120; + return delta; + } + } + + internal override int HorizontalScrollBarHeight + { + get + { + return scroll_height; + } + } + + internal override bool UserClipWontExposeParent + { + get + { + return false; + } + } + + + internal override int VerticalScrollBarWidth + { + get + { + return scroll_width; + } + } + + internal override int MenuHeight + { + get + { + return 32; + } + } + + internal override Size Border3DSize + { + get + { + return new Size(2, 2); + } + } + + internal override Size BorderSize + { + get + { + return new Size(2, 2); + } + } + + internal override bool DropTarget + { + get + { + return false; + } + + set + { + if (value) + { + //throw new NotImplementedException("Need to figure out D'n'D for Win32"); + } + } + } + + internal override Size CaptionButtonSize + { + get + { + return new Size(64, 32); + } + } + + internal override int CaptionHeight + { + get + { + return 35; + } + } + + internal override Size CursorSize + { + get + { + return new Size(32, 32); + } + } + + internal override bool DragFullWindows + { + get + { + return false; + } + } + + internal override Size DragSize + { + get + { + return new Size(32, 32); + } + } + + internal override Size DoubleClickSize + { + get + { + return new Size(36, 36); //thanks to @InternetUnexploder from the Cosmos Gitter chat, I know the raw value I need to put here :P + } + } + + internal override int DoubleClickTime + { + get + { + return 1000; + } + } + + internal override Size FixedFrameBorderSize + { + get + { + return new Size(2, 2); + } + } + + internal override Size FrameBorderSize + { + get + { + return new Size(4, 4); + } + } + + internal override Size IconSize + { + get + { + return new Size(16, 16); + } + } + + internal override Size MaxWindowTrackSize + { + get + { + return new Size(59, 60); + } + } + + internal override bool MenuAccessKeysUnderlined + { + get + { + return false; + } + } + + internal override Size MinimizedWindowSize + { + get + { + return new Size(0, 0); + } + } + + internal override Size MinimizedWindowSpacingSize + { + get + { + return new Size(0, 0); + } + } + + internal override Size MinimumWindowSize + { + get + { + return new Size(50, 50); + } + } + + internal override Size MinWindowTrackSize + { + get + { + return new Size(50, 50); + } + } + + internal override Size SmallIconSize + { + get + { + return new Size(8, 8); + } + } + + internal override int MouseButtonCount + { + get + { + return 3; + } + } + + internal override bool MouseButtonsSwapped + { + get + { + return false; + } + } + + internal override bool MouseWheelPresent + { + get + { + return cosmos.MouseWheelPressed; + } + } + + internal override Rectangle VirtualScreen + { + get + { + var s = cosmos.GetScreenInfo(); + return new Rectangle(s.X, s.Y, s.Width, s.Height); + } + } + + internal override Rectangle WorkingArea + { + get + { + return VirtualScreen; + } + } + + [MonoTODO] + internal override Screen[] AllScreens + { + get + { + // Can't use this sadly. + return null; + } + } + + internal override bool ThemesEnabled + { + get + { + return true; + } + } + + internal override bool RequiresPositiveClientAreaSize + { + get + { + return false; + } + } + + public override int ToolWindowCaptionHeight + { + get + { + return 35; //Drawing will be done entirely by the developer itself. Do we really care about the tool window size? + } + } + + public override Size ToolWindowCaptionButtonSize + { + get + { + return new Size(32, 32); + } + } +#endregion // Static Properties + +#region Singleton Specific Code + public static XplatUICosmos GetInstance() + { + if (instance == null) + { + instance = new XplatUICosmos(); + } + ref_count++; + return instance; + } + + public int Reference + { + get + { + return ref_count; + } + } +#endregion + +#region Public Static Methods + internal override IntPtr InitializeDriver() + { + cosmos.OnInit(); + return IntPtr.Zero; + } + + internal override void ShutdownDriver(IntPtr token) + { + Console.WriteLine("[ShiftUI] Stopping Cosmos driver..."); + cosmos.OnShutdown(); + } + + + internal void Version() + { + Console.WriteLine($"ShiftUI version {Application.ShiftUIVersionString}, running in the cosmos, on {cosmos.OSName} version {cosmos.OSVersionString}."); + } + + string GetSoundAlias(AlertType alert) + { + return ""; + } + + internal override void AudibleAlert(AlertType alert) + { + //Cosmos cannot do audio. + } + + internal override void BeginMoveResize(IntPtr handle) + { + //If the Mono devs that worked on the Win32 driver didn't know what this did, what + //makes you think I will? + } + + internal override void GetDisplaySize(out Size size) + { + //get screen metrics from OS + var screen = cosmos.GetScreenInfo(); + //push the data out. + size = new Size(screen.Width, screen.Height); + } + + internal override void EnableThemes() + { + //Themes will forever be enabled. + } + + //[MichaelComment(Message = "Yay. I just LOVE messing with Win32 stuff and porting it to Cosmos.")] + internal override IntPtr CreateWindow(CreateParams cp) + { + //I think I'll let this do it's thing it's own way but just change where the new Hwnd gets placed. + if (cosmos.Windows == null) + cosmos.Windows = new List<Hwnd>(); + IntPtr WindowHandle; + IntPtr ParentHandle; + Hwnd hwnd; + + hwnd = new Hwnd(); + + ParentHandle = cp.Parent; + + if ((ParentHandle == IntPtr.Zero) && (cp.Style & (int)(WindowStyles.WS_CHILD)) != 0) + { + // We need to use our foster parent window until this poor child gets it's parent assigned + ParentHandle = GetFosterParent(); + } + + if (((cp.Style & (int)(WindowStyles.WS_CHILD | WindowStyles.WS_POPUP)) == 0) && ((cp.ExStyle & (int)WindowExStyles.WS_EX_APPWINDOW) == 0)) + { + // If we want to be hidden from the taskbar we need to be 'owned' by + // something not on the taskbar. FosterParent is just that + ParentHandle = GetFosterParent(); + } + + Point location; + if (cp.HasWindowManager) + { + location = Hwnd.GetNextStackedFormLocation(cp, Hwnd.ObjectFromHandle(cp.Parent)); + } + else + { + location = new Point(cp.X, cp.Y); + } + + string class_name = RegisterWindowClass(cp.ClassStyle); + HwndCreating = hwnd; + + // We cannot actually send the WS_EX_MDICHILD flag to Windows because we + // are faking MDI, not uses Windows' version. + if ((cp.WindowExStyle & WindowExStyles.WS_EX_MDICHILD) == WindowExStyles.WS_EX_MDICHILD) + cp.WindowExStyle ^= WindowExStyles.WS_EX_MDICHILD; + + WindowHandle = cosmos.Windows.Count + 1; + + HwndCreating = null; + + if (WindowHandle == IntPtr.Zero) + { + MessageBox.Show("An error happened while showing a window... Fascinating.", "Fatal error."); + } + + hwnd.ClientWindow = WindowHandle; + hwnd.Mapped = true; + cosmos.Windows.Add(hwnd); + + return WindowHandle; + } + + internal override IntPtr CreateWindow(IntPtr Parent, int X, int Y, int Width, int Height) + { + CreateParams create_params = new CreateParams(); + + create_params.Caption = ""; + create_params.X = X; + create_params.Y = Y; + create_params.Width = Width; + create_params.Height = Height; + + create_params.ClassName = XplatUI.GetDefaultClassName(GetType()); + create_params.ClassStyle = 0; + create_params.ExStyle = 0; + create_params.Parent = IntPtr.Zero; + create_params.Param = 0; + + return CreateWindow(create_params); + } + + internal override void DestroyWindow(IntPtr handle) + { + Hwnd hwnd; + + foreach(var win in cosmos.Windows) + { + if (win.Handle == handle) + hwnd = win; + } + if (hwnd == null) + MessageBox.Show("An error occurred while destroying a window.", "Fatal error."); + cosmos.Windows.Remove(hwnd); + cosmos.OnDestroyWindow(hwnd); //tell the OS to redraw that area... + hwnd.Dispose(); + return; + } + + internal override void SetWindowMinMax(IntPtr handle, Rectangle maximized, Size min, Size max) + { + // We do nothing, Form has to handle WM_GETMINMAXINFO + } + + + internal override FormWindowState GetWindowState(IntPtr handle) + { + CosmosWindowStyle style; + + style = cosmos.GetWindowState(handle); + switch(style) + { + case CosmosWindowStyle.Maximized: + return FormWindowState.Maximized; + case CosmosWindowStyle.Minimized: + return FormWindowState.Minimized; + } + return FormWindowState.Normal; + } + + internal override void SetWindowState(IntPtr hwnd, FormWindowState state) + { + switch (state) + { + case FormWindowState.Normal: + { + Win32ShowWindow(hwnd, WindowPlacementFlags.SW_RESTORE); + return; + } + + case FormWindowState.Minimized: + { + Win32ShowWindow(hwnd, WindowPlacementFlags.SW_MINIMIZE); + return; + } + + case FormWindowState.Maximized: + { + Win32ShowWindow(hwnd, WindowPlacementFlags.SW_MAXIMIZE); + return; + } + } + } + + internal override void SetWindowStyle(IntPtr handle, CreateParams cp) + { + + Win32SetWindowLong(handle, WindowLong.GWL_STYLE, (uint)cp.Style); + Win32SetWindowLong(handle, WindowLong.GWL_EXSTYLE, (uint)cp.ExStyle); + + // From MSDN: + // Certain window data is cached, so changes you make using SetWindowLong + // will not take effect until you call the SetWindowPos function. Specifically, + // if you change any of the frame styles, you must call SetWindowPos with + // the SWP_FRAMECHANGED flag for the cache to be updated properly. + if (cp.control is Form) + XplatUI.RequestNCRecalc(handle); + } + + internal override double GetWindowTransparency(IntPtr handle) + { + LayeredWindowAttributes lwa; + COLORREF clrRef; + byte alpha; + + if (0 == Win32GetLayeredWindowAttributes(handle, out clrRef, out alpha, out lwa)) + return 1.0; + + return ((double)alpha) / 255.0; + } + + internal override void SetWindowTransparency(IntPtr handle, double transparency, Color key) + { + LayeredWindowAttributes lwa = LayeredWindowAttributes.LWA_ALPHA; + byte opacity = (byte)(transparency * 255); + COLORREF clrRef = new COLORREF(); + if (key != Color.Empty) + { + clrRef.R = key.R; + clrRef.G = key.G; + clrRef.B = key.B; + lwa = (LayeredWindowAttributes)((int)lwa | (int)LayeredWindowAttributes.LWA_COLORKEY); + } + RECT rc; + rc.right = 1000; + rc.bottom = 1000; + Win32SetLayeredWindowAttributes(handle, clrRef, opacity, lwa); + } + + TransparencySupport support; + bool queried_transparency_support; + internal override TransparencySupport SupportsTransparency() + { + if (queried_transparency_support) + return support; + + bool flag; + support = TransparencySupport.None; + + flag = true; + try + { + Win32SetLayeredWindowAttributes(IntPtr.Zero, new COLORREF(), 255, LayeredWindowAttributes.LWA_ALPHA); + } + catch (EntryPointNotFoundException) { flag = false; } + catch { /* swallow everything else */ } + + if (flag) support |= TransparencySupport.Set; + + flag = true; + try + { + LayeredWindowAttributes lwa; + COLORREF clrRef; + byte alpha; + + Win32GetLayeredWindowAttributes(IntPtr.Zero, out clrRef, out alpha, out lwa); + } + catch (EntryPointNotFoundException) { flag = false; } + catch { /* swallow everything else */ } + + if (flag) support |= TransparencySupport.Get; + + queried_transparency_support = true; + return support; + } + + internal override void UpdateWindow(IntPtr handle) + { + Win32UpdateWindow(handle); + } + + internal override PaintEventArgs PaintEventStart(ref Message msg, IntPtr handle, bool client) + { + IntPtr hdc; + PAINTSTRUCT ps; + PaintEventArgs paint_event; + RECT rect; + Rectangle clip_rect; + Hwnd hwnd; + + clip_rect = new Rectangle(); + rect = new RECT(); + ps = new PAINTSTRUCT(); + + hwnd = Hwnd.ObjectFromHandle(msg.HWnd); + + if (client) + { + if (Win32GetUpdateRect(msg.HWnd, ref rect, false)) + { + if (handle != msg.HWnd) + { + // We need to validate the window where the paint message + // was generated, otherwise we'll never stop getting paint + // messages. + Win32GetClientRect(msg.HWnd, out rect); + Win32ValidateRect(msg.HWnd, ref rect); + hdc = Win32GetDC(handle); + } + else + { + hdc = Win32BeginPaint(handle, ref ps); + rect = ps.rcPaint; + } + } + else + { + hdc = Win32GetDC(handle); + } + clip_rect = rect.ToRectangle(); + } + else + { + hdc = Win32GetWindowDC(handle); + + // HACK this in for now + Win32GetWindowRect(handle, out rect); + clip_rect = new Rectangle(0, 0, rect.Width, rect.Height); + } + + // If we called BeginPaint, store the PAINTSTRUCT, + // otherwise store hdc, so that PaintEventEnd can know + // whether to call EndPaint or ReleaseDC. + if (ps.hdc != IntPtr.Zero) + { + hwnd.drawing_stack.Push(ps); + } + else + { + hwnd.drawing_stack.Push(hdc); + } + + Graphics dc = Graphics.FromHdc(hdc); + hwnd.drawing_stack.Push(dc); + + paint_event = new PaintEventArgs(dc, clip_rect); + + return paint_event; + } + + internal override void PaintEventEnd(ref Message m, IntPtr handle, bool client) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(m.HWnd); + + Graphics dc = (Graphics)hwnd.drawing_stack.Pop(); + dc.Dispose(); + + object o = hwnd.drawing_stack.Pop(); + if (o is IntPtr) + { + IntPtr hdc = (IntPtr)o; + Win32ReleaseDC(handle, hdc); + } + else if (o is PAINTSTRUCT) + { + PAINTSTRUCT ps = (PAINTSTRUCT)o; + Win32EndPaint(handle, ref ps); + } + } + + + internal override void SetWindowPos(IntPtr handle, int x, int y, int width, int height) + { + Win32MoveWindow(handle, x, y, width, height, true); + return; + } + + internal override void GetWindowPos(IntPtr handle, bool is_toplevel, out int x, out int y, out int width, out int height, out int client_width, out int client_height) + { + IntPtr parent; + RECT rect; + POINT pt; + + Win32GetWindowRect(handle, out rect); + width = rect.right - rect.left; + height = rect.bottom - rect.top; + + pt.x = rect.left; + pt.y = rect.top; + + parent = Win32GetAncestor(handle, AncestorType.GA_PARENT); + if (parent != IntPtr.Zero && parent != Win32GetDesktopWindow()) + Win32ScreenToClient(parent, ref pt); + + x = pt.x; + y = pt.y; + + Win32GetClientRect(handle, out rect); + client_width = rect.right - rect.left; + client_height = rect.bottom - rect.top; + return; + } + + internal override void Activate(IntPtr handle) + { + Win32SetActiveWindow(handle); + // delayed timer enabled + lock (timer_list) + { + foreach (Timer t in timer_list.Values) + { + if (t.Enabled && t.window == IntPtr.Zero) + { + t.window = handle; + int id = t.GetHashCode(); + Win32SetTimer(handle, id, (uint)t.Interval, IntPtr.Zero); + } + } + } + } + + internal override void Invalidate(IntPtr handle, Rectangle rc, bool clear) + { + cosmos.Redraw(); //I don't want to make it too hard for devs to deal with this... + } + + + internal override void InvalidateNC(IntPtr handle) + { + cosmos.Redraw(); + } + + private IntPtr InternalWndProc(IntPtr hWnd, Msg msg, IntPtr wParam, IntPtr lParam) + { + if (HwndCreating != null && HwndCreating.ClientWindow == IntPtr.Zero) + HwndCreating.ClientWindow = hWnd; + return NativeWindow.WndProc(hWnd, msg, wParam, lParam); + } + + internal override IntPtr DefWndProc(ref Message msg) + { + msg.Result = Win32DefWindowProc(msg.HWnd, (Msg)msg.Msg, msg.WParam, msg.LParam); + return msg.Result; + } + + internal override void HandleException(Exception e) + { + StackTrace st = new StackTrace(e); + Win32MessageBox(IntPtr.Zero, e.Message + st.ToString(), "Exception", 0); + Console.WriteLine("{0}{1}", e.Message, st.ToString()); + } + + internal override void DoEvents() + { + MSG msg = new MSG(); + + while (GetMessage(ref msg, IntPtr.Zero, 0, 0, false)) + { + Message m = Message.Create(msg.hwnd, (int)msg.message, msg.wParam, msg.lParam); + + if (Application.FilterMessage(ref m)) + continue; + + XplatUI.TranslateMessage(ref msg); + XplatUI.DispatchMessage(ref msg); + } + } + + internal override bool PeekMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags) + { + return Win32PeekMessage(ref msg, hWnd, wFilterMin, wFilterMax, flags); + } + + internal override void PostQuitMessage(int exitCode) + { + Win32PostQuitMessage(exitCode); + } + + internal override void RequestAdditionalWM_NCMessages(IntPtr hwnd, bool hover, bool leave) + { + if (wm_nc_registered == null) + wm_nc_registered = new Hashtable(); + + TMEFlags flags = TMEFlags.TME_NONCLIENT; + if (hover) + flags |= TMEFlags.TME_HOVER; + if (leave) + flags |= TMEFlags.TME_LEAVE; + + if (flags == TMEFlags.TME_NONCLIENT) + { + if (wm_nc_registered.Contains(hwnd)) + { + wm_nc_registered.Remove(hwnd); + } + } + else + { + if (!wm_nc_registered.Contains(hwnd)) + { + wm_nc_registered.Add(hwnd, flags); + } + else + { + wm_nc_registered[hwnd] = flags; + } + } + } + + internal override void RequestNCRecalc(IntPtr handle) + { + Win32SetWindowPos(handle, IntPtr.Zero, 0, 0, 0, 0, SetWindowPosFlags.SWP_FRAMECHANGED | SetWindowPosFlags.SWP_NOOWNERZORDER | SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE); + } + + internal override void ResetMouseHover(IntPtr handle) + { + TRACKMOUSEEVENT tme; + + tme = new TRACKMOUSEEVENT(); + tme.size = Marshal.SizeOf(tme); + tme.hWnd = handle; + tme.dwFlags = TMEFlags.TME_LEAVE | TMEFlags.TME_HOVER; + Win32TrackMouseEvent(ref tme); + } + + + internal override bool GetMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax) + { + return GetMessage(ref msg, hWnd, wFilterMin, wFilterMax, true); + } + + private bool GetMessage(ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, bool blocking) + { + bool result; + + msg.refobject = 0; + if (RetrieveMessage(ref msg)) + { + return true; + } + + if (blocking) + { + result = Win32GetMessage(ref msg, hWnd, wFilterMin, wFilterMax); + } + else + { + result = Win32PeekMessage(ref msg, hWnd, wFilterMin, wFilterMax, (uint)PeekMessageFlags.PM_REMOVE); + if (!result) + { + return false; + } + } + + // We need to fake WM_MOUSE_ENTER + switch (msg.message) + { + case Msg.WM_LBUTTONDOWN: + { + mouse_state |= MouseButtons.Left; + break; + } + + case Msg.WM_MBUTTONDOWN: + { + mouse_state |= MouseButtons.Middle; + break; + } + + case Msg.WM_RBUTTONDOWN: + { + mouse_state |= MouseButtons.Right; + break; + } + + case Msg.WM_LBUTTONUP: + { + mouse_state &= ~MouseButtons.Left; + break; + } + + case Msg.WM_MBUTTONUP: + { + mouse_state &= ~MouseButtons.Middle; + break; + } + + case Msg.WM_RBUTTONUP: + { + mouse_state &= ~MouseButtons.Right; + break; + } + + case Msg.WM_ASYNC_MESSAGE: + { + XplatUIDriverSupport.ExecuteClientMessage((GCHandle)msg.lParam); + break; + } + + case Msg.WM_MOUSEMOVE: + { + if (msg.hwnd != prev_mouse_hwnd) + { + TRACKMOUSEEVENT tme; + + mouse_state = Widget.FromParamToMouseButtons((int)msg.lParam.ToInt32()); + + // The current message will be sent out next time around + StoreMessage(ref msg); + + // This is the message we want to send at this point + msg.message = Msg.WM_MOUSE_ENTER; + + prev_mouse_hwnd = msg.hwnd; + + tme = new TRACKMOUSEEVENT(); + tme.size = Marshal.SizeOf(tme); + tme.hWnd = msg.hwnd; + tme.dwFlags = TMEFlags.TME_LEAVE | TMEFlags.TME_HOVER; + Win32TrackMouseEvent(ref tme); + return result; + } + break; + } + + case Msg.WM_NCMOUSEMOVE: + { + if (wm_nc_registered == null || !wm_nc_registered.Contains(msg.hwnd)) + break; + + mouse_state = Widget.FromParamToMouseButtons((int)msg.lParam.ToInt32()); + + TRACKMOUSEEVENT tme; + + tme = new TRACKMOUSEEVENT(); + tme.size = Marshal.SizeOf(tme); + tme.hWnd = msg.hwnd; + tme.dwFlags = (TMEFlags)wm_nc_registered[msg.hwnd]; + Win32TrackMouseEvent(ref tme); + return result; + } + + case Msg.WM_DROPFILES: + { + return Win32DnD.HandleWMDropFiles(ref msg); + } + + case Msg.WM_MOUSELEAVE: + { + prev_mouse_hwnd = IntPtr.Zero; + break; + } + + case Msg.WM_TIMER: + { + Timer timer = (Timer)timer_list[(int)msg.wParam]; + + if (timer != null) + { + timer.FireTick(); + } + break; + } + } + + return result; + } + + internal override bool TranslateMessage(ref MSG msg) + { + return Win32TranslateMessage(ref msg); + } + + internal override IntPtr DispatchMessage(ref MSG msg) + { + return Win32DispatchMessage(ref msg); + } + + internal override bool SetZOrder(IntPtr hWnd, IntPtr AfterhWnd, bool Top, bool Bottom) + { + if (Top) + { + Win32SetWindowPos(hWnd, SetWindowPosZOrder.HWND_TOP, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE); + return true; + } + else if (!Bottom) + { + Win32SetWindowPos(hWnd, AfterhWnd, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE); + } + else + { + Win32SetWindowPos(hWnd, (IntPtr)SetWindowPosZOrder.HWND_BOTTOM, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE); + return true; + } + return false; + } + + internal override bool SetTopmost(IntPtr hWnd, bool Enabled) + { + if (Enabled) + { + Win32SetWindowPos(hWnd, SetWindowPosZOrder.HWND_TOPMOST, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOACTIVATE); + return true; + } + else + { + Win32SetWindowPos(hWnd, SetWindowPosZOrder.HWND_NOTOPMOST, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOACTIVATE); + return true; + } + } + + internal override bool SetOwner(IntPtr hWnd, IntPtr hWndOwner) + { + Win32SetWindowLong(hWnd, WindowLong.GWL_HWNDPARENT, (uint)hWndOwner); + return true; + } + + internal override bool Text(IntPtr handle, string text) + { + Win32SetWindowText(handle, text); + return true; + } + + internal override bool GetText(IntPtr handle, out string text) + { + StringBuilder sb; + + sb = new StringBuilder(256); + Win32GetWindowText(handle, sb, sb.Capacity); + text = sb.ToString(); + return true; + } + + internal override bool SetVisible(IntPtr handle, bool visible, bool activate) + { + if (visible) + { + Widget c = Widget.FromHandle(handle); + if (c is Form) + { + Form f; + + f = (Form)Widget.FromHandle(handle); + WindowPlacementFlags flags = WindowPlacementFlags.SW_SHOWNORMAL; + switch (f.WindowState) + { + case FormWindowState.Normal: flags = WindowPlacementFlags.SW_SHOWNORMAL; break; + case FormWindowState.Minimized: flags = WindowPlacementFlags.SW_MINIMIZE; break; + case FormWindowState.Maximized: flags = WindowPlacementFlags.SW_MAXIMIZE; break; + } + + if (!f.ActivateOnShow) + flags = WindowPlacementFlags.SW_SHOWNOACTIVATE; + + Win32ShowWindow(handle, flags); + } + else + { + if (c.ActivateOnShow) + Win32ShowWindow(handle, WindowPlacementFlags.SW_SHOWNORMAL); + else + Win32ShowWindow(handle, WindowPlacementFlags.SW_SHOWNOACTIVATE); + } + } + else + { + Win32ShowWindow(handle, WindowPlacementFlags.SW_HIDE); + } + return true; + } + + internal override bool IsEnabled(IntPtr handle) + { + return IsWindowEnabled(handle); + } + + internal override bool IsKeyLocked(VirtualKeys key) + { + return (Win32GetKeyState(key) & 1) == 1; + } + + internal override bool IsVisible(IntPtr handle) + { + return IsWindowVisible(handle); + } + + internal override IntPtr SetParent(IntPtr handle, IntPtr parent) + { + Widget c = Widget.FromHandle(handle); + if (parent == IntPtr.Zero) + { + if (!(c is Form)) + { + Win32ShowWindow(handle, WindowPlacementFlags.SW_HIDE); + } + } + else + { + if (!(c is Form)) + { + SetVisible(handle, c.is_visible, true); + } + } + // The Win32SetParent is lame, it can very well move the window + // ref: http://groups.google.com/group/microsoft.public.vb.winapi/browse_thread/thread/1b82ccc54231ecee/afa82835bfc0422a%23afa82835bfc0422a + // Here we save the position before changing the parent, and if it has changed afterwards restore it. + // Another possibility would be to intercept WM_WINDOWPOSCHANGING and restore the coords there, but this would require plumbing in weird places + // (either inside Widget or add handling to InternalWndProc) + // We also need to remove WS_CHILD if making the window parent-less, and add it if we're parenting it. + RECT rect, rect2; + IntPtr result; + WindowStyles style, new_style; + + Win32GetWindowRect(handle, out rect); + style = (WindowStyles)Win32GetWindowLong(handle, WindowLong.GWL_STYLE); + + if (parent == IntPtr.Zero) + { + new_style = style & ~WindowStyles.WS_CHILD; + result = Win32SetParent(handle, GetFosterParent()); + } + else + { + new_style = style | WindowStyles.WS_CHILD; + result = Win32SetParent(handle, parent); + } + if (style != new_style && c is Form) + { + Win32SetWindowLong(handle, WindowLong.GWL_STYLE, (uint)new_style); + } + Win32GetWindowRect(handle, out rect2); + if (rect.top != rect2.top && rect.left != rect2.left && c is Form) + { + Win32SetWindowPos(handle, IntPtr.Zero, rect.top, rect.left, rect.Width, rect.Height, SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOREDRAW | SetWindowPosFlags.SWP_NOOWNERZORDER | SetWindowPosFlags.SWP_NOENDSCHANGING | SetWindowPosFlags.SWP_NOACTIVATE); + } + return result; + } + + // If we ever start using this, we should probably replace FosterParent with IntPtr.Zero + internal override IntPtr GetParent(IntPtr handle) + { + return Win32GetParent(handle); + } + + // This is a nop on win32 and x11 + internal override IntPtr GetPreviousWindow(IntPtr handle) + { + return handle; + } + + internal override void GrabWindow(IntPtr hWnd, IntPtr ConfineToHwnd) + { + grab_hwnd = hWnd; + Win32SetCapture(hWnd); + + if (ConfineToHwnd != IntPtr.Zero) + { + RECT window_rect; + Win32GetWindowRect(ConfineToHwnd, out window_rect); + Win32GetClipCursor(out clipped_cursor_rect); + Win32ClipCursor(ref window_rect); + } + } + + internal override void GrabInfo(out IntPtr hWnd, out bool GrabConfined, out Rectangle GrabArea) + { + hWnd = grab_hwnd; + GrabConfined = grab_confined; + GrabArea = grab_area; + } + + internal override void UngrabWindow(IntPtr hWnd) + { + if (!(clipped_cursor_rect.top == 0 && clipped_cursor_rect.bottom == 0 && clipped_cursor_rect.left == 0 && clipped_cursor_rect.right == 0)) + { + Win32ClipCursor(ref clipped_cursor_rect); + clipped_cursor_rect = new RECT(); + } + + Win32ReleaseCapture(); + grab_hwnd = IntPtr.Zero; + } + + internal override bool CalculateWindowRect(ref Rectangle ClientRect, CreateParams cp, Menu menu, out Rectangle WindowRect) + { + RECT rect; + + rect.left = ClientRect.Left; + rect.top = ClientRect.Top; + rect.right = ClientRect.Right; + rect.bottom = ClientRect.Bottom; + + if (!Win32AdjustWindowRectEx(ref rect, cp.Style, menu != null, cp.ExStyle)) + { + WindowRect = new Rectangle(ClientRect.Left, ClientRect.Top, ClientRect.Width, ClientRect.Height); + return false; + } + + WindowRect = new Rectangle(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top); + return true; + } + + internal override void SetCursor(IntPtr window, IntPtr cursor) + { + Win32SetCursor(cursor); + return; + } + + internal override void ShowCursor(bool show) + { + Win32ShowCursor(show); + } + + internal override void OverrideCursor(IntPtr cursor) + { + Win32SetCursor(cursor); + } + + internal override IntPtr DefineCursor(Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot) + { + IntPtr cursor; + Bitmap cursor_bitmap; + Bitmap cursor_mask; + Byte[] cursor_bits; + Byte[] mask_bits; + Color pixel; + int width; + int height; + + // Win32 only allows creation cursors of a certain size + if ((bitmap.Width != Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR)) || (bitmap.Width != Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR))) + { + cursor_bitmap = new Bitmap(bitmap, new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR), Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR))); + cursor_mask = new Bitmap(mask, new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR), Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR))); + } + else + { + cursor_bitmap = bitmap; + cursor_mask = mask; + } + + width = cursor_bitmap.Width; + height = cursor_bitmap.Height; + + cursor_bits = new Byte[(width / 8) * height]; + mask_bits = new Byte[(width / 8) * height]; + + for (int y = 0; y < height; y++) + { + for (int x = 0; x < width; x++) + { + pixel = cursor_bitmap.GetPixel(x, y); + + if (pixel == cursor_pixel) + { + cursor_bits[y * width / 8 + x / 8] |= (byte)(0x80 >> (x % 8)); + } + + pixel = cursor_mask.GetPixel(x, y); + + if (pixel == mask_pixel) + { + mask_bits[y * width / 8 + x / 8] |= (byte)(0x80 >> (x % 8)); + } + } + } + + cursor = Win32CreateCursor(IntPtr.Zero, xHotSpot, yHotSpot, width, height, mask_bits, cursor_bits); + + return cursor; + } + + internal override Bitmap DefineStdCursorBitmap(StdCursor id) + { + // We load the cursor, create a bitmap, draw the cursor onto the bitmap and return the bitmap. + IntPtr cursor = DefineStdCursor(id); + // Windows only have one possible cursor size! + int width = Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR); + int height = Win32GetSystemMetrics(SystemMetrics.SM_CYCURSOR); + Bitmap bmp = new Bitmap(width, height); + Graphics gc = Graphics.FromImage(bmp); + IntPtr hdc = gc.GetHdc(); + Win32DrawIcon(hdc, 0, 0, cursor); + gc.ReleaseHdc(hdc); + gc.Dispose(); + return bmp; + } + + [MonoTODO("Define the missing cursors")] + internal override IntPtr DefineStdCursor(StdCursor id) + { + switch (id) + { + case StdCursor.AppStarting: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_APPSTARTING); + case StdCursor.Arrow: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); + case StdCursor.Cross: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_CROSS); + case StdCursor.Default: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); + case StdCursor.Hand: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_HAND); + case StdCursor.Help: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_HELP); + case StdCursor.HSplit: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.IBeam: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_IBEAM); + case StdCursor.No: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_NO); + case StdCursor.NoMove2D: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.NoMoveHoriz: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.NoMoveVert: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanEast: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanNE: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanNorth: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanNW: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanSE: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanSouth: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanSW: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanWest: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.SizeAll: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZEALL); + case StdCursor.SizeNESW: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZENESW); + case StdCursor.SizeNS: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZENS); + case StdCursor.SizeNWSE: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZENWSE); + case StdCursor.SizeWE: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZEWE); + case StdCursor.UpArrow: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_UPARROW); + case StdCursor.VSplit: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.WaitCursor: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_WAIT); + } + throw new NotImplementedException(); + } + + internal override void DestroyCursor(IntPtr cursor) + { + if ((cursor.ToInt32() < (int)LoadCursorType.First) || (cursor.ToInt32() > (int)LoadCursorType.Last)) + { + Win32DestroyCursor(cursor); + } + } + + [MonoTODO] + internal override void GetCursorInfo(IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y) + { + ICONINFO ii = new ICONINFO(); + + if (!Win32GetIconInfo(cursor, out ii)) + throw new Win32Exception(); + + width = 20; + height = 20; + hotspot_x = ii.xHotspot; + hotspot_y = ii.yHotspot; + } + + internal override void SetCursorPos(IntPtr handle, int x, int y) + { + Win32SetCursorPos(x, y); + } + + internal override Region GetClipRegion(IntPtr hwnd) + { + Region region; + + region = new Region(); + + Win32GetWindowRgn(hwnd, region.GetHrgn(Graphics.FromHwnd(hwnd))); + + return region; + } + + internal override void SetClipRegion(IntPtr hwnd, Region region) + { + if (region == null) + Win32SetWindowRgn(hwnd, IntPtr.Zero, true); + else + Win32SetWindowRgn(hwnd, region.GetHrgn(Graphics.FromHwnd(hwnd)), true); + } + + internal override void EnableWindow(IntPtr handle, bool Enable) + { + Win32EnableWindow(handle, Enable); + } + + internal override void EndLoop(System.Threading.Thread thread) + { + // Nothing to do + } + + internal override object StartLoop(System.Threading.Thread thread) + { + return null; + } + + internal override void SetModal(IntPtr handle, bool Modal) + { + // we do nothing on Win32 + } + + internal override void GetCursorPos(IntPtr handle, out int x, out int y) + { + POINT pt; + + Win32GetCursorPos(out pt); + + if (handle != IntPtr.Zero) + { + Win32ScreenToClient(handle, ref pt); + } + + x = pt.x; + y = pt.y; + } + + internal override void ScreenToClient(IntPtr handle, ref int x, ref int y) + { + POINT pnt = new POINT(); + + pnt.x = x; + pnt.y = y; + Win32ScreenToClient(handle, ref pnt); + + x = pnt.x; + y = pnt.y; + } + + internal override void ClientToScreen(IntPtr handle, ref int x, ref int y) + { + POINT pnt = new POINT(); + + pnt.x = x; + pnt.y = y; + + Win32ClientToScreen(handle, ref pnt); + + x = pnt.x; + y = pnt.y; + } + + internal override void ScreenToMenu(IntPtr handle, ref int x, ref int y) + { + RECT rect; + + Win32GetWindowRect(handle, out rect); + x -= rect.left + SystemInformation.FrameBorderSize.Width; + y -= rect.top + SystemInformation.FrameBorderSize.Height; + + WindowStyles style = (WindowStyles)Win32GetWindowLong(handle, WindowLong.GWL_STYLE); + if (CreateParams.IsSet(style, WindowStyles.WS_CAPTION)) + { + y -= ThemeEngine.Current.CaptionHeight; + } + } + + internal override void MenuToScreen(IntPtr handle, ref int x, ref int y) + { + RECT rect; + + Win32GetWindowRect(handle, out rect); + x += rect.left + SystemInformation.FrameBorderSize.Width; + y += rect.top + SystemInformation.FrameBorderSize.Height + ThemeEngine.Current.CaptionHeight; + return; + } + + internal override void SendAsyncMethod(AsyncMethodData method) + { + Win32PostMessage(GetFosterParent(), Msg.WM_ASYNC_MESSAGE, IntPtr.Zero, (IntPtr)GCHandle.Alloc(method)); + } + + internal override void SetTimer(Timer timer) + { + IntPtr FosterParent = GetFosterParent(); + int index; + + index = timer.GetHashCode(); + + lock (timer_list) + { + timer_list[index] = timer; + } + + if (Win32SetTimer(FosterParent, index, (uint)timer.Interval, IntPtr.Zero) != IntPtr.Zero) + timer.window = FosterParent; + else + timer.window = IntPtr.Zero; + } + + internal override void KillTimer(Timer timer) + { + int index; + + index = timer.GetHashCode(); + + Win32KillTimer(timer.window, index); + + lock (timer_list) + { + timer_list.Remove(index); + } + } + + internal override void CreateCaret(IntPtr hwnd, int width, int height) + { + Win32CreateCaret(hwnd, IntPtr.Zero, width, height); + caret_visible = false; + } + + internal override void DestroyCaret(IntPtr hwnd) + { + Win32DestroyCaret(); + } + + internal override void SetCaretPos(IntPtr hwnd, int x, int y) + { + Win32SetCaretPos(x, y); + } + + internal override void CaretVisible(IntPtr hwnd, bool visible) + { + if (visible) + { + if (!caret_visible) + { + Win32ShowCaret(hwnd); + caret_visible = true; + } + } + else + { + if (caret_visible) + { + Win32HideCaret(hwnd); + caret_visible = false; + } + } + } + + internal override IntPtr GetFocus() + { + return Win32GetFocus(); + } + + internal override void SetFocus(IntPtr hwnd) + { + Win32SetFocus(hwnd); + } + + internal override IntPtr GetActive() + { + return Win32GetActiveWindow(); + } + + internal override bool GetFontMetrics(Graphics g, Font font, out int ascent, out int descent) + { + IntPtr dc; + IntPtr prevobj; + TEXTMETRIC tm; + + tm = new TEXTMETRIC(); + + dc = Win32GetDC(IntPtr.Zero); + prevobj = Win32SelectObject(dc, font.ToHfont()); + + if (Win32GetTextMetrics(dc, ref tm) == false) + { + prevobj = Win32SelectObject(dc, prevobj); + Win32DeleteObject(prevobj); + Win32ReleaseDC(IntPtr.Zero, dc); + ascent = 0; + descent = 0; + return false; + } + prevobj = Win32SelectObject(dc, prevobj); + Win32DeleteObject(prevobj); + Win32ReleaseDC(IntPtr.Zero, dc); + + ascent = tm.tmAscent; + descent = tm.tmDescent; + + return true; + } + + internal override void ScrollWindow(IntPtr hwnd, Rectangle rectangle, int XAmount, int YAmount, bool with_children) + { + RECT rect; + + rect = new RECT(); + rect.left = rectangle.X; + rect.top = rectangle.Y; + rect.right = rectangle.Right; + rect.bottom = rectangle.Bottom; + + Win32ScrollWindowEx(hwnd, XAmount, YAmount, IntPtr.Zero, ref rect, IntPtr.Zero, IntPtr.Zero, ScrollWindowExFlags.SW_INVALIDATE | ScrollWindowExFlags.SW_ERASE | (with_children ? ScrollWindowExFlags.SW_SCROLLCHILDREN : ScrollWindowExFlags.SW_NONE)); + Win32UpdateWindow(hwnd); + } + + internal override void ScrollWindow(IntPtr hwnd, int XAmount, int YAmount, bool with_children) + { + Win32ScrollWindowEx(hwnd, XAmount, YAmount, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, ScrollWindowExFlags.SW_INVALIDATE | ScrollWindowExFlags.SW_ERASE | (with_children ? ScrollWindowExFlags.SW_SCROLLCHILDREN : ScrollWindowExFlags.SW_NONE)); + } + + internal override bool SystrayAdd(IntPtr hwnd, string tip, Icon icon, out ToolTip tt) + { + NOTIFYICONDATA nid; + + nid = new NOTIFYICONDATA(); + + nid.cbSize = (uint)Marshal.SizeOf(nid); + nid.hWnd = hwnd; + nid.uID = 1; + nid.uCallbackMessage = (uint)Msg.WM_USER; + nid.uFlags = NotifyIconFlags.NIF_MESSAGE; + + if (tip != null) + { + nid.szTip = tip; + nid.uFlags |= NotifyIconFlags.NIF_TIP; + } + + if (icon != null) + { + nid.hIcon = icon.Handle; + nid.uFlags |= NotifyIconFlags.NIF_ICON; + } + + tt = null; + + return Win32Shell_NotifyIcon(NotifyIconMessage.NIM_ADD, ref nid); + } + + internal override bool SystrayChange(IntPtr hwnd, string tip, Icon icon, ref ToolTip tt) + { + NOTIFYICONDATA nid; + + nid = new NOTIFYICONDATA(); + + nid.cbSize = (uint)Marshal.SizeOf(nid); + nid.hIcon = icon.Handle; + nid.hWnd = hwnd; + nid.uID = 1; + nid.uCallbackMessage = (uint)Msg.WM_USER; + nid.uFlags = NotifyIconFlags.NIF_MESSAGE; + + if (tip != null) + { + nid.szTip = tip; + nid.uFlags |= NotifyIconFlags.NIF_TIP; + } + + if (icon != null) + { + nid.hIcon = icon.Handle; + nid.uFlags |= NotifyIconFlags.NIF_ICON; + } + + return Win32Shell_NotifyIcon(NotifyIconMessage.NIM_MODIFY, ref nid); + } + + internal override void SystrayRemove(IntPtr hwnd, ref ToolTip tt) + { + NOTIFYICONDATA nid; + + nid = new NOTIFYICONDATA(); + + nid.cbSize = (uint)Marshal.SizeOf(nid); + nid.hWnd = hwnd; + nid.uID = 1; + nid.uFlags = 0; + + Win32Shell_NotifyIcon(NotifyIconMessage.NIM_DELETE, ref nid); + } + + internal override void SystrayBalloon(IntPtr hwnd, int timeout, string title, string text, ToolTipIcon icon) + { + NOTIFYICONDATA nid; + + nid = new NOTIFYICONDATA(); + + nid.cbSize = (uint)Marshal.SizeOf(nid); + nid.hWnd = hwnd; + nid.uID = 1; + nid.uFlags = NotifyIconFlags.NIF_INFO; + nid.uTimeoutOrVersion = timeout; + nid.szInfoTitle = title; + nid.szInfo = text; + nid.dwInfoFlags = icon; + + Win32Shell_NotifyIcon(NotifyIconMessage.NIM_MODIFY, ref nid); + } + + internal override void SetBorderStyle(IntPtr handle, FormBorderStyle border_style) + { + // Nothing to do on Win32 + } + + internal override void SetMenu(IntPtr handle, Menu menu) + { + // Trigger WM_NCCALC + Win32SetWindowPos(handle, IntPtr.Zero, 0, 0, 0, 0, SetWindowPosFlags.SWP_FRAMECHANGED | SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE); + } + + internal override Point GetMenuOrigin(IntPtr handle) + { + Form form = Widget.FromHandle(handle) as Form; + + if (form != null) + { + if (form.FormBorderStyle == FormBorderStyle.None) + return Point.Empty; + + int bordersize = (form.Width - form.ClientSize.Width) / 2; + + if (form.FormBorderStyle == FormBorderStyle.FixedToolWindow || form.FormBorderStyle == FormBorderStyle.SizableToolWindow) + return new Point(bordersize, bordersize + SystemInformation.ToolWindowCaptionHeight); + else + return new Point(bordersize, bordersize + SystemInformation.CaptionHeight); + } + + return new Point(SystemInformation.FrameBorderSize.Width, SystemInformation.FrameBorderSize.Height + ThemeEngine.Current.CaptionHeight); + } + + internal override void SetIcon(IntPtr hwnd, Icon icon) + { + Win32SendMessage(hwnd, Msg.WM_SETICON, (IntPtr)1, icon == null ? IntPtr.Zero : icon.Handle); // 1 = large icon (0 would be small) + } + + internal override void ClipboardClose(IntPtr handle) + { + if (handle != clip_magic) + { + throw new ArgumentException("handle is not a valid clipboard handle"); + } + Win32CloseClipboard(); + } + + internal override int ClipboardGetID(IntPtr handle, string format) + { + if (handle != clip_magic) + { + throw new ArgumentException("handle is not a valid clipboard handle"); + } + if (format == "Text") return 1; + else if (format == "Bitmap") return 2; + else if (format == "MetaFilePict") return 3; + else if (format == "SymbolicLink") return 4; + else if (format == "DataInterchangeFormat") return 5; + else if (format == "Tiff") return 6; + else if (format == "OEMText") return 7; + else if (format == "DeviceIndependentBitmap") return 8; + else if (format == "Palette") return 9; + else if (format == "PenData") return 10; + else if (format == "RiffAudio") return 11; + else if (format == "WaveAudio") return 12; + else if (format == "UnicodeText") return 13; + else if (format == "EnhancedMetafile") return 14; + else if (format == "FileDrop") return 15; + else if (format == "Locale") return 16; + + return (int)Win32RegisterClipboardFormat(format); + } + + internal override IntPtr ClipboardOpen(bool primary_selection) + { + // Win32 does not have primary selection + Win32OpenClipboard(GetFosterParent()); + return clip_magic; + } + + internal override int[] ClipboardAvailableFormats(IntPtr handle) + { + uint format; + int[] result; + int count; + + if (handle != clip_magic) + { + return null; + } + + // Count first + count = 0; + format = 0; + do + { + format = Win32EnumClipboardFormats(format); + if (format != 0) + { + count++; + } + } while (format != 0); + + // Now assign + result = new int[count]; + count = 0; + format = 0; + do + { + format = Win32EnumClipboardFormats(format); + if (format != 0) + { + result[count++] = (int)format; + } + } while (format != 0); + + return result; + } + + + internal override object ClipboardRetrieve(IntPtr handle, int type, XplatUI.ClipboardToObject converter) + { + IntPtr hmem; + IntPtr data; + object obj; + + if (handle != clip_magic) + { + throw new ArgumentException("handle is not a valid clipboard handle"); + } + + hmem = Win32GetClipboardData((uint)type); + if (hmem == IntPtr.Zero) + { + return null; + } + + data = Win32GlobalLock(hmem); + if (data == IntPtr.Zero) + { + uint error = Win32GetLastError(); + Console.WriteLine("Error: {0}", error); + return null; + } + + obj = null; + + if (type == DataFormats.GetFormat(DataFormats.Rtf).Id) + { + obj = AnsiToString(data); + } + else switch ((ClipboardFormats)type) + { + case ClipboardFormats.CF_TEXT: + { + obj = AnsiToString(data); + break; + } + + case ClipboardFormats.CF_DIB: + { + obj = DIBtoImage(data); + break; + } + + case ClipboardFormats.CF_UNICODETEXT: + { + obj = UnicodeToString(data); + break; + } + + default: + { + if (converter != null && !converter(type, data, out obj)) + { + obj = null; + } + break; + } + } + Win32GlobalUnlock(hmem); + + return obj; + + } + + internal override void ClipboardStore(IntPtr handle, object obj, int type, XplatUI.ObjectToClipboard converter, bool copy) + { + byte[] data = null; + + if (handle != clip_magic) + { + throw new ArgumentException("handle is not a valid clipboard handle"); + } + + if (obj == null) + { + // Just clear it + if (!Win32EmptyClipboard()) + throw new ExternalException("Win32EmptyClipboard"); + return; + } + + if (type == -1) + { + if (obj is string) + { + type = (int)ClipboardFormats.CF_UNICODETEXT; + } + else if (obj is Image) + { + type = (int)ClipboardFormats.CF_DIB; + } + } + + if (type == DataFormats.GetFormat(DataFormats.Rtf).Id) + { + data = StringToAnsi((string)obj); + } + else switch ((ClipboardFormats)type) + { + case ClipboardFormats.CF_UNICODETEXT: + { + data = StringToUnicode((string)obj); + break; + } + + case ClipboardFormats.CF_TEXT: + { + data = StringToAnsi((string)obj); + break; + } + + case ClipboardFormats.CF_BITMAP: + case ClipboardFormats.CF_DIB: + { + data = ImageToDIB((Image)obj); + type = (int)ClipboardFormats.CF_DIB; + break; + } + + default: + { + if (converter != null && !converter(ref type, obj, out data)) + { + data = null; // ensure that a failed conversion leaves null. + } + break; + } + } + if (data != null) + { + SetClipboardData((uint)type, data); + } + } + + internal static byte[] StringToUnicode(string text) + { + return Encoding.Unicode.GetBytes(text + "\0"); + } + + internal static byte[] StringToAnsi(string text) + { + // FIXME, follow the behaviour of the previous code using UTF-8, + // but this should be 'ANSI' on Windows, i.e. the current code page. + // Does Encoding.Default work on Windows? + return Encoding.UTF8.GetBytes(text + "\0"); + } + + private void SetClipboardData(uint type, byte[] data) + { + if (data.Length == 0) + // Shouldn't call Win32SetClipboard with NULL, as, from MSDN: + // "This parameter can be NULL, indicating that the window provides data + // in the specified clipboard format (renders the format) upon request." + // and I don't think we support that... + // Note this is unrelated to the fact that passing a null obj to + // ClipboardStore is actually a request to empty the clipboard! + return; + IntPtr hmem = CopyToMoveableMemory(data); + if (hmem == IntPtr.Zero) + // As above, should not call with null. + // (Not that CopyToMoveableMemory should ever return null!) + throw new ExternalException("CopyToMoveableMemory failed."); + if (Win32SetClipboardData(type, hmem) == IntPtr.Zero) + throw new ExternalException("Win32SetClipboardData"); + } + + /// <summary> + /// Creates a memory block with GlobalAlloc(GMEM_MOVEABLE), copies the data + /// into it, and returns the handle to the memory. + /// </summary> + /// - + /// <param name="data">The data. Must not be null or zero-length — + /// see the exception notes.</param> + /// - + /// <returns>The *handle* to the allocated GMEM_MOVEABLE block.</returns> + /// - + /// <exception cref="T:System.ArgumentException">The data was null or zero + /// length. This is disallowed since a zero length allocation can't be made + /// </exception> + /// <exception cref="T:System.ComponentModel.Win32Exception">The allocation, + /// or locking (handle->pointer) failed. + /// Either out of memory or the handle table is full (256 max currently). + /// Note Win32Exception is a subclass of ExternalException so this is OK in + /// the documented Clipboard interface. + /// </exception> + internal static IntPtr CopyToMoveableMemory(byte[] data) + { + if (data == null || data.Length == 0) + // detect this before GlobalAlloc does. + throw new ArgumentException("Can't create a zero length memory block."); + + IntPtr hmem = Win32GlobalAlloc(GAllocFlags.GMEM_MOVEABLE | GAllocFlags.GMEM_DDESHARE, data.Length); + if (hmem == IntPtr.Zero) + throw new Win32Exception(); + IntPtr hmem_ptr = Win32GlobalLock(hmem); + if (hmem_ptr == IntPtr.Zero) // If the allocation was valid this shouldn't occur. + throw new Win32Exception(); + Marshal.Copy(data, 0, hmem_ptr, data.Length); + Win32GlobalUnlock(hmem); + return hmem; + } + + + internal override void SetAllowDrop(IntPtr hwnd, bool allowed) + { + if (allowed) + { + Win32DnD.RegisterDropTarget(hwnd); + } + else + { + Win32DnD.UnregisterDropTarget(hwnd); + } + } + + internal override DragDropEffects StartDrag(IntPtr hwnd, object data, DragDropEffects allowedEffects) + { + return Win32DnD.StartDrag(hwnd, data, allowedEffects); + } + + // XXX this doesn't work at all for FrameStyle.Dashed - it draws like Thick, and in the Thick case + // the corners are drawn incorrectly. + internal override void DrawReversibleFrame(Rectangle rectangle, Color backColor, FrameStyle style) + { + IntPtr hdc; + IntPtr pen; + IntPtr oldpen; + COLORREF clrRef = new COLORREF(); + + // If we want the standard hatch pattern we would + // need to create a brush + + clrRef.R = backColor.R; + clrRef.G = backColor.G; + clrRef.B = backColor.B; + + // Grab a pen + pen = Win32CreatePen(style == FrameStyle.Thick ? PenStyle.PS_SOLID : PenStyle.PS_DASH, + style == FrameStyle.Thick ? 4 : 2, ref clrRef); + + hdc = Win32GetDC(IntPtr.Zero); + Win32SetROP2(hdc, ROP2DrawMode.R2_NOT); + oldpen = Win32SelectObject(hdc, pen); + + Win32MoveToEx(hdc, rectangle.Left, rectangle.Top, IntPtr.Zero); + if ((rectangle.Width > 0) && (rectangle.Height > 0)) + { + Win32LineTo(hdc, rectangle.Right, rectangle.Top); + Win32LineTo(hdc, rectangle.Right, rectangle.Bottom); + Win32LineTo(hdc, rectangle.Left, rectangle.Bottom); + Win32LineTo(hdc, rectangle.Left, rectangle.Top); + } + else + { + if (rectangle.Width > 0) + { + Win32LineTo(hdc, rectangle.Right, rectangle.Top); + } + else + { + Win32LineTo(hdc, rectangle.Left, rectangle.Bottom); + } + } + + Win32SelectObject(hdc, oldpen); + Win32DeleteObject(pen); + + Win32ReleaseDC(IntPtr.Zero, hdc); + } + + internal override void DrawReversibleLine(Point start, Point end, Color backColor) + { + IntPtr hdc; + IntPtr pen; + IntPtr oldpen; + POINT pt; + COLORREF clrRef = new COLORREF(); + + pt = new POINT(); + pt.x = 0; + pt.y = 0; + Win32ClientToScreen(IntPtr.Zero, ref pt); + + // If we want the standard hatch pattern we would + // need to create a brush + + clrRef.R = backColor.R; + clrRef.G = backColor.G; + clrRef.B = backColor.B; + + // Grab a pen + pen = Win32CreatePen(PenStyle.PS_SOLID, 1, ref clrRef); + + hdc = Win32GetDC(IntPtr.Zero); + Win32SetROP2(hdc, ROP2DrawMode.R2_NOT); + oldpen = Win32SelectObject(hdc, pen); + + Win32MoveToEx(hdc, pt.x + start.X, pt.y + start.Y, IntPtr.Zero); + Win32LineTo(hdc, pt.x + end.X, pt.y + end.Y); + + Win32SelectObject(hdc, oldpen); + Win32DeleteObject(pen); + + Win32ReleaseDC(IntPtr.Zero, hdc); + } + + internal override void FillReversibleRectangle(Rectangle rectangle, Color backColor) + { + RECT rect; + + rect = new RECT(); + rect.left = rectangle.Left; + rect.top = rectangle.Top; + rect.right = rectangle.Right; + rect.bottom = rectangle.Bottom; + + IntPtr hdc; + IntPtr brush; + IntPtr oldbrush; + COLORREF clrRef = new COLORREF(); + + clrRef.R = backColor.R; + clrRef.G = backColor.G; + clrRef.B = backColor.B; + + // Grab a brush + brush = Win32CreateSolidBrush(clrRef); + + hdc = Win32GetDC(IntPtr.Zero); + oldbrush = Win32SelectObject(hdc, brush); + + Win32PatBlt(hdc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height, PatBltRop.DSTINVERT); + + Win32SelectObject(hdc, oldbrush); + Win32DeleteObject(brush); + + Win32ReleaseDC(IntPtr.Zero, hdc); + } + + internal override void DrawReversibleRectangle(IntPtr handle, Rectangle rect, int line_width) + { + IntPtr hdc; + IntPtr pen; + IntPtr oldpen; + POINT pt; + + pt = new POINT(); + pt.x = 0; + pt.y = 0; + Win32ClientToScreen(handle, ref pt); + + // If we want the standard hatch pattern we would + // need to create a brush + + // Grab a pen + pen = Win32CreatePen(PenStyle.PS_SOLID, line_width, IntPtr.Zero); + + hdc = Win32GetDC(IntPtr.Zero); + Win32SetROP2(hdc, ROP2DrawMode.R2_NOT); + oldpen = Win32SelectObject(hdc, pen); + + Widget c = Widget.FromHandle(handle); + if (c != null) + { + RECT window_rect; + Win32GetWindowRect(c.Handle, out window_rect); + Region r = new Region(new Rectangle(window_rect.left, window_rect.top, window_rect.right - window_rect.left, window_rect.bottom - window_rect.top)); + Win32ExtSelectClipRgn(hdc, r.GetHrgn(Graphics.FromHdc(hdc)), (int)ClipCombineMode.RGN_AND); + } + + Win32MoveToEx(hdc, pt.x + rect.Left, pt.y + rect.Top, IntPtr.Zero); + if ((rect.Width > 0) && (rect.Height > 0)) + { + Win32LineTo(hdc, pt.x + rect.Right, pt.y + rect.Top); + Win32LineTo(hdc, pt.x + rect.Right, pt.y + rect.Bottom); + Win32LineTo(hdc, pt.x + rect.Left, pt.y + rect.Bottom); + Win32LineTo(hdc, pt.x + rect.Left, pt.y + rect.Top); + } + else + { + if (rect.Width > 0) + { + Win32LineTo(hdc, pt.x + rect.Right, pt.y + rect.Top); + } + else + { + Win32LineTo(hdc, pt.x + rect.Left, pt.y + rect.Bottom); + } + } + + Win32SelectObject(hdc, oldpen); + Win32DeleteObject(pen); + if (c != null) + Win32ExtSelectClipRgn(hdc, IntPtr.Zero, (int)ClipCombineMode.RGN_COPY); + + Win32ReleaseDC(IntPtr.Zero, hdc); + } + + internal override SizeF GetAutoScaleSize(Font font) + { + Graphics g; + float width; + string magic_string = "The quick brown fox jumped over the lazy dog."; + double magic_number = 44.549996948242189; + + g = Graphics.FromHwnd(GetFosterParent()); + + width = (float)(g.MeasureString(magic_string, font).Width / magic_number); + return new SizeF(width, font.Height); + } + + internal override IntPtr SendMessage(IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam) + { + return Win32SendMessage(hwnd, message, wParam, lParam); + } + + internal override bool PostMessage(IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam) + { + return Win32PostMessage(hwnd, message, wParam, lParam); + } + + internal override int SendInput(IntPtr hwnd, Queue keys) + { + INPUT[] inputs = new INPUT[keys.Count]; + const Int32 INPUT_KEYBOARD = 1; + uint returns = 0; + int i = 0; + while (keys.Count > 0) + { + MSG msg = (MSG)keys.Dequeue(); + + + inputs[i].ki.wScan = 0; + inputs[i].ki.time = 0; + inputs[i].ki.dwFlags = (Int32)(msg.message == Msg.WM_KEYUP ? InputFlags.KEYEVENTF_KEYUP : 0); + inputs[i].ki.wVk = (short)msg.wParam.ToInt32(); + inputs[i].type = INPUT_KEYBOARD; + i++; + } + returns = Win32SendInput((UInt32)inputs.Length, inputs, Marshal.SizeOf(typeof(INPUT))); + + return (int)returns; + } + + internal override int KeyboardSpeed + { + get + { + int speed = 0; + Win32SystemParametersInfo(SPIAction.SPI_GETKEYBOARDSPEED, 0, ref speed, 0); + // + // Return values range from 0 to 31 which map to 2.5 to 30 repetitions per second. + // + return speed; + } + } + + internal override int KeyboardDelay + { + get + { + int delay = 1; + Win32SystemParametersInfo(SPIAction.SPI_GETKEYBOARDDELAY, 0, ref delay, 0); + // + // Return values must range from 0 to 4, 0 meaning 250ms, + // and 4 meaning 1000 ms. + // + return delay; + } + } + + private class WinBuffer + { + public IntPtr hdc; + public IntPtr bitmap; + + public WinBuffer(IntPtr hdc, IntPtr bitmap) + { + this.hdc = hdc; + this.bitmap = bitmap; + } + } + + internal override void CreateOffscreenDrawable(IntPtr handle, int width, int height, out object offscreen_drawable) + { + Graphics destG = Graphics.FromHwnd(handle); + IntPtr destHdc = destG.GetHdc(); + + IntPtr srcHdc = Win32CreateCompatibleDC(destHdc); + IntPtr srcBmp = Win32CreateCompatibleBitmap(destHdc, width, height); + Win32SelectObject(srcHdc, srcBmp); + + offscreen_drawable = new WinBuffer(srcHdc, srcBmp); + + destG.ReleaseHdc(destHdc); + } + + internal override Graphics GetOffscreenGraphics(object offscreen_drawable) + { + return Graphics.FromHdc(((WinBuffer)offscreen_drawable).hdc); + } + + internal override void BlitFromOffscreen(IntPtr dest_handle, Graphics dest_dc, object offscreen_drawable, Graphics offscreen_dc, Rectangle r) + { + WinBuffer wb = (WinBuffer)offscreen_drawable; + + IntPtr destHdc = dest_dc.GetHdc(); + Win32BitBlt(destHdc, r.Left, r.Top, r.Width, r.Height, wb.hdc, r.Left, r.Top, TernaryRasterOperations.SRCCOPY); + dest_dc.ReleaseHdc(destHdc); + } + + internal override void DestroyOffscreenDrawable(object offscreen_drawable) + { + WinBuffer wb = (WinBuffer)offscreen_drawable; + + Win32DeleteObject(wb.bitmap); + Win32DeleteDC(wb.hdc); + } + + internal override void SetForegroundWindow(IntPtr handle) + { + Win32SetForegroundWindow(handle); + } + + internal override event EventHandler Idle; +#endregion // Public Static Methods + + } +} +#endregion +#endif
\ No newline at end of file diff --git a/source/ShiftUI/Internal/XplatUIDriver.cs b/source/ShiftUI/Internal/XplatUIDriver.cs new file mode 100644 index 0000000..c3f5e0d --- /dev/null +++ b/source/ShiftUI/Internal/XplatUIDriver.cs @@ -0,0 +1,532 @@ +// 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) 2004-2006 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// Sebastien Pouliot [email protected] +// + +// COMPLETE + +using System.Drawing; +using System.Threading; +using System.Runtime.InteropServices; +using System; + +namespace ShiftUI { + internal abstract class XplatUIDriver { + internal abstract IntPtr InitializeDriver(); + internal abstract void ShutdownDriver(IntPtr token); + internal delegate IntPtr WndProc(IntPtr hwnd, Msg msg, IntPtr wParam, IntPtr lParam); + + + #region XplatUI Driver Properties + internal virtual int ActiveWindowTrackingDelay { get { return 0; } } + + internal virtual Color ForeColor { + get { + return ThemeEngine.Current.DefaultWindowForeColor; + } + } + + internal virtual Color BackColor { + get { + return ThemeEngine.Current.DefaultWindowBackColor; + } + } + + internal virtual Size Border3DSize { + get { + return new Size (2, 2); + } + } + + internal virtual Size BorderSize { + get { + return new Size (1, 1); + } + } + + internal virtual Size CaptionButtonSize { + get { + return new Size (18, 18); + } + } + + internal virtual int CaretBlinkTime { get { return 530; } } + internal virtual int CaretWidth { get { return 10; } } + + internal virtual Size DoubleClickSize { + get { + return new Size (4, 4); + } + } + + internal virtual int DoubleClickTime { + get { + return 500; + } + } + + internal virtual Size FixedFrameBorderSize { + get { + return new Size (3, 3); + } + } + + internal virtual Font Font { + get { + return ThemeEngine.Current.DefaultFont; + } + } + + internal virtual int FontSmoothingContrast { get { return 1400; } } + internal virtual int FontSmoothingType { get { return 1; } } + internal virtual int HorizontalResizeBorderThickness { get { return 8; } } + internal virtual bool IsActiveWindowTrackingEnabled { get { return false; } } + internal virtual bool IsComboBoxAnimationEnabled { get { return false; } } + internal virtual bool IsDropShadowEnabled { get { return false; } } + internal virtual bool IsFontSmoothingEnabled { get { return true; } } + internal virtual bool IsHotTrackingEnabled { get { return false; } } + internal virtual bool IsIconTitleWrappingEnabled { get { return true; } } + internal virtual bool IsKeyboardPreferred { get { return false; } } + internal virtual bool IsListBoxSmoothScrollingEnabled { get { return true; } } + internal virtual bool IsMenuAnimationEnabled { get { return false; } } + internal virtual bool IsMenuFadeEnabled { get { return true; } } + internal virtual bool IsMinimizeRestoreAnimationEnabled { get { return false; } } + internal virtual bool IsSelectionFadeEnabled { get { return false; } } + internal virtual bool IsSnapToDefaultEnabled { get { return false; } } + internal virtual bool IsTitleBarGradientEnabled { get { return false; } } + internal virtual bool IsToolTipAnimationEnabled { get { return false; } } + internal virtual Size MenuBarButtonSize { get { return new Size (19, 19); } } + public virtual Size MenuButtonSize { + get { + return new Size(18, 18); + } + } + internal virtual int MenuShowDelay { get { return 0; } } + + internal virtual Keys ModifierKeys { + get { + return Keys.None; + } + } + + internal virtual MouseButtons MouseButtons { + get { + return MouseButtons.None; + } + } + + internal virtual Size MouseHoverSize { + get { + return new Size (1, 1); + } + } + + internal virtual int MouseHoverTime { + get { + return 500; + } + } + + internal virtual int MouseSpeed { + get { return 10; } + } + + internal virtual int MouseWheelScrollDelta { + get { + return 120; + } + } + + internal virtual Point MousePosition { + get { + return Point.Empty; + } + } + + internal virtual int MenuHeight { + get { + return 19; + } + } + + internal virtual LeftRightAlignment PopupMenuAlignment { + get { return LeftRightAlignment.Left; } + } + + internal virtual PowerStatus PowerStatus { + get { throw new NotImplementedException ("Has not been implemented yet for this platform."); } + } + + internal virtual int SizingBorderWidth { + get { return 4; } + } + + internal virtual Size SmallCaptionButtonSize { + get { return new Size (15, 15); } + } + + internal virtual bool UIEffectsEnabled { + get { return false; } + } + + internal virtual bool DropTarget { + get { + return false; + } + + set { + } + } + + internal virtual int HorizontalScrollBarHeight { + get { + return 16; + } + } + + internal virtual bool UserClipWontExposeParent { + get { + return true; + } + } + + internal virtual int VerticalResizeBorderThickness { get { return 8; } } + + internal virtual int VerticalScrollBarWidth { + get { + return 16; + } + } + + internal abstract int CaptionHeight { get; } + internal abstract Size CursorSize { get; } + internal abstract bool DragFullWindows { get; } + internal abstract Size DragSize { get; } + internal abstract Size FrameBorderSize { get; } + internal abstract Size IconSize { get; } + internal abstract Size MaxWindowTrackSize { get; } + internal abstract bool MenuAccessKeysUnderlined { get; } + internal virtual Size MinimizedWindowSize { + get { + const int BorderWidth = 3; + return new Size (154 + 2 * BorderWidth, SystemInformation.CaptionHeight + 2 * BorderWidth - 1); + } + } + internal abstract Size MinimizedWindowSpacingSize { get; } + internal abstract Size MinimumWindowSize { get; } + internal virtual Size MinimumFixedToolWindowSize { get { return Size.Empty; } } + internal virtual Size MinimumSizeableToolWindowSize { get { return Size.Empty; } } + internal virtual Size MinimumNoBorderWindowSize { get { return Size.Empty; } } + internal virtual Size MinWindowTrackSize { + get { + return new Size (112, 27); + } + } + internal abstract Size SmallIconSize { get; } + internal abstract int MouseButtonCount { get; } + internal abstract bool MouseButtonsSwapped { get; } + internal abstract bool MouseWheelPresent { get; } + internal abstract Rectangle VirtualScreen { get; } + internal abstract Rectangle WorkingArea { get; } + internal abstract Screen[] AllScreens { get; } + internal abstract bool ThemesEnabled { get; } + + internal virtual bool RequiresPositiveClientAreaSize { + get { + return true; + } + } + + public virtual int ToolWindowCaptionHeight { + get { + return 16; + } + } + + public virtual Size ToolWindowCaptionButtonSize { + get { + return new Size (15, 15); + } + } + #endregion // XplatUI Driver Properties + + internal abstract event EventHandler Idle; + + #region XplatUI Driver Methods + internal abstract void AudibleAlert(AlertType alert); + + internal abstract void BeginMoveResize (IntPtr handle); // init a window manager driven resize event + + internal abstract void EnableThemes(); + + internal abstract void GetDisplaySize(out Size size); + + internal abstract IntPtr CreateWindow(CreateParams cp); + internal abstract IntPtr CreateWindow(IntPtr Parent, int X, int Y, int Width, int Height); + internal abstract void DestroyWindow(IntPtr handle); + + internal abstract FormWindowState GetWindowState(IntPtr handle); + internal abstract void SetWindowState(IntPtr handle, FormWindowState state); + internal abstract void SetWindowMinMax(IntPtr handle, Rectangle maximized, Size min, Size max); + + internal abstract void SetWindowStyle(IntPtr handle, CreateParams cp); + + internal abstract double GetWindowTransparency(IntPtr handle); + internal abstract void SetWindowTransparency(IntPtr handle, double transparency, Color key); + internal abstract TransparencySupport SupportsTransparency(); + + internal virtual void SetAllowDrop (IntPtr handle, bool value) + { + Console.Error.WriteLine ("Drag and Drop is currently " + + "not supported on this platform"); + } + + internal virtual DragDropEffects StartDrag(IntPtr handle, object data, DragDropEffects allowedEffects) { + Console.Error.WriteLine ("Drag and Drop is currently " + + "not supported on this platform"); + return DragDropEffects.None; + } + + internal abstract void SetBorderStyle(IntPtr handle, FormBorderStyle border_style); + internal abstract void SetMenu(IntPtr handle, Menu menu); + + internal abstract bool GetText(IntPtr handle, out string text); + internal abstract bool Text(IntPtr handle, string text); + internal abstract bool SetVisible(IntPtr handle, bool visible, bool activate); + internal abstract bool IsVisible(IntPtr handle); + internal abstract bool IsEnabled(IntPtr handle); + internal virtual bool IsKeyLocked (VirtualKeys key) { return false; } + internal abstract IntPtr SetParent(IntPtr handle, IntPtr parent); + internal abstract IntPtr GetParent(IntPtr handle); + + internal abstract void UpdateWindow(IntPtr handle); + internal abstract PaintEventArgs PaintEventStart (ref Message msg, IntPtr handle, bool client); + internal abstract void PaintEventEnd (ref Message msg, IntPtr handle, bool client); + + internal abstract void SetWindowPos(IntPtr handle, int x, int y, int width, int height); + internal abstract void GetWindowPos(IntPtr handle, bool is_toplevel, out int x, out int y, out int width, out int height, out int client_width, out int client_height); + internal abstract void Activate(IntPtr handle); + internal abstract void EnableWindow(IntPtr handle, bool Enable); + internal abstract void SetModal(IntPtr handle, bool Modal); + internal abstract void Invalidate(IntPtr handle, Rectangle rc, bool clear); + internal abstract void InvalidateNC(IntPtr handle); + internal abstract IntPtr DefWndProc(ref Message msg); + internal abstract void HandleException(Exception e); + internal abstract void DoEvents(); + internal abstract bool PeekMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags); + internal abstract void PostQuitMessage(int exitCode); + internal abstract bool GetMessage(object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax); + internal abstract bool TranslateMessage(ref MSG msg); + internal abstract IntPtr DispatchMessage(ref MSG msg); + + internal abstract bool SetZOrder(IntPtr hWnd, IntPtr AfterhWnd, bool Top, bool Bottom); + internal abstract bool SetTopmost(IntPtr hWnd, bool Enabled); + internal abstract bool SetOwner(IntPtr hWnd, IntPtr hWndOwner); + + internal abstract bool CalculateWindowRect(ref Rectangle ClientRect, CreateParams cp, Menu menu, out Rectangle WindowRect); + + internal abstract Region GetClipRegion(IntPtr hwnd); + internal abstract void SetClipRegion(IntPtr hwnd, Region region); + + internal abstract void SetCursor(IntPtr hwnd, IntPtr cursor); + internal abstract void ShowCursor(bool show); + internal abstract void OverrideCursor(IntPtr cursor); + internal abstract IntPtr DefineCursor(Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot); + internal abstract IntPtr DefineStdCursor(StdCursor id); + internal abstract Bitmap DefineStdCursorBitmap(StdCursor id); + internal abstract void DestroyCursor(IntPtr cursor); + internal abstract void GetCursorInfo(IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y); + + internal abstract void GetCursorPos(IntPtr hwnd, out int x, out int y); + internal abstract void SetCursorPos(IntPtr hwnd, int x, int y); + + internal abstract void ScreenToClient(IntPtr hwnd, ref int x, ref int y); + internal abstract void ClientToScreen(IntPtr hwnd, ref int x, ref int y); + + internal abstract void GrabWindow(IntPtr hwnd, IntPtr ConfineToHwnd); + internal abstract void GrabInfo(out IntPtr hwnd, out bool GrabConfined, out Rectangle GrabArea); + internal abstract void UngrabWindow(IntPtr hwnd); + + internal abstract void SendAsyncMethod (AsyncMethodData method); + internal abstract void SetTimer (Timer timer); + internal abstract void KillTimer (Timer timer); + + internal abstract void CreateCaret(IntPtr hwnd, int width, int height); + internal abstract void DestroyCaret(IntPtr hwnd); + internal abstract void SetCaretPos(IntPtr hwnd, int x, int y); + internal abstract void CaretVisible(IntPtr hwnd, bool visible); + + internal abstract IntPtr GetFocus(); + internal abstract void SetFocus(IntPtr hwnd); + internal abstract IntPtr GetActive(); + internal abstract IntPtr GetPreviousWindow(IntPtr hwnd); + + internal abstract void ScrollWindow(IntPtr hwnd, Rectangle rectangle, int XAmount, int YAmount, bool with_children); + internal abstract void ScrollWindow(IntPtr hwnd, int XAmount, int YAmount, bool with_children); + + internal abstract bool GetFontMetrics(Graphics g, Font font, out int ascent, out int descent); + + internal abstract bool SystrayAdd(IntPtr hwnd, string tip, Icon icon, out ToolTip tt); + internal abstract bool SystrayChange(IntPtr hwnd, string tip, Icon icon, ref ToolTip tt); + internal abstract void SystrayRemove(IntPtr hwnd, ref ToolTip tt); + internal abstract void SystrayBalloon(IntPtr hwnd, int timeout, string title, string text, ToolTipIcon icon); + + internal abstract Point GetMenuOrigin(IntPtr hwnd); + internal abstract void MenuToScreen(IntPtr hwnd, ref int x, ref int y); + internal abstract void ScreenToMenu(IntPtr hwnd, ref int x, ref int y); + + internal abstract void SetIcon(IntPtr handle, Icon icon); + + internal abstract void ClipboardClose(IntPtr handle); + internal abstract IntPtr ClipboardOpen (bool primary_selection); + internal abstract int ClipboardGetID(IntPtr handle, string format); + internal abstract void ClipboardStore(IntPtr handle, object obj, int id, XplatUI.ObjectToClipboard converter, bool copy); + internal abstract int[] ClipboardAvailableFormats(IntPtr handle); + internal abstract object ClipboardRetrieve(IntPtr handle, int id, XplatUI.ClipboardToObject converter); + + internal abstract void DrawReversibleLine(Point start, Point end, Color backColor); + internal abstract void DrawReversibleRectangle(IntPtr handle, Rectangle rect, int line_width); + internal abstract void FillReversibleRectangle (Rectangle rectangle, Color backColor); + internal abstract void DrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style); + + internal abstract SizeF GetAutoScaleSize(Font font); + + internal abstract IntPtr SendMessage(IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam); + internal abstract bool PostMessage(IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam); + internal abstract int SendInput(IntPtr hwnd, System.Collections.Queue keys); + + internal abstract object StartLoop(Thread thread); + internal abstract void EndLoop(Thread thread); + + internal abstract void RequestNCRecalc(IntPtr hwnd); + internal abstract void ResetMouseHover(IntPtr hwnd); + internal abstract void RequestAdditionalWM_NCMessages(IntPtr hwnd, bool hover, bool leave); + + internal abstract void RaiseIdle (EventArgs e); + + // System information + internal abstract int KeyboardSpeed { get; } + internal abstract int KeyboardDelay { get; } + + + // Double buffering + internal virtual void CreateOffscreenDrawable (IntPtr handle, + int width, int height, + out object offscreen_drawable) + { + Bitmap bmp = new Bitmap (width, height, System.Drawing.Imaging.PixelFormat.Format32bppArgb); + + offscreen_drawable = bmp; + } + + internal virtual void DestroyOffscreenDrawable (object offscreen_drawable) + { + Bitmap bmp = (Bitmap)offscreen_drawable; + + bmp.Dispose (); + } + + internal virtual Graphics GetOffscreenGraphics (object offscreen_drawable) + { + Bitmap bmp = (Bitmap)offscreen_drawable; + return Graphics.FromImage (bmp); + } + + internal virtual void BlitFromOffscreen (IntPtr dest_handle, + Graphics dest_dc, + object offscreen_drawable, + Graphics offscreen_dc, + Rectangle r) + { + dest_dc.DrawImage ((Bitmap)offscreen_drawable, r, r, GraphicsUnit.Pixel); + } + + internal virtual void SetForegroundWindow (IntPtr handle) + { + } + +#endregion // XplatUI Driver Methods + } + + static class XplatUIDriverSupport { + #region XplatUI Driver Support Methods + internal static void ExecutionCallback (AsyncMethodData data) + { + AsyncMethodResult result = data.Result; + + object ret; + try { + ret = data.Method.DynamicInvoke (data.Args); + } catch (Exception ex) { + if (result != null) { + result.CompleteWithException (ex); + return; + } + + throw; + } + + if (result != null) { + result.Complete (ret); + } + } + + static void ExecutionCallbackInContext (object state) + { + AsyncMethodData data = (AsyncMethodData) state; + + if (data.SyncContext == null) { + ExecutionCallback (data); + return; + } + + var oldContext = SynchronizationContext.Current; + SynchronizationContext.SetSynchronizationContext (data.SyncContext); + + try { + ExecutionCallback (data); + } finally { + SynchronizationContext.SetSynchronizationContext (oldContext); + } + } + + internal static void ExecuteClientMessage (GCHandle gchandle) + { + AsyncMethodData data = (AsyncMethodData) gchandle.Target; + try { + if (data.Context == null) { + ExecutionCallback (data); + } else { + data.SyncContext = SynchronizationContext.Current; + ExecutionContext.Run (data.Context, new ContextCallback (ExecutionCallbackInContext), data); + } + } + finally { + gchandle.Free (); + } + } + + #endregion // XplatUI Driver Support Methods + } +} diff --git a/source/ShiftUI/Internal/XplatUIStructs.cs b/source/ShiftUI/Internal/XplatUIStructs.cs new file mode 100644 index 0000000..f0c3bc5 --- /dev/null +++ b/source/ShiftUI/Internal/XplatUIStructs.cs @@ -0,0 +1,1042 @@ +// 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) 2004-2006 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// +// *** When you make some changes to this file, dont forget to update Tests/TestHelper class *** + +// NOT COMPLETE + +using System; +using System.Drawing; +using System.Runtime.InteropServices; + +#if PUBLIC_TYPES +namespace Mono.Winforms +#else +namespace ShiftUI +#endif +{ + [Flags] +#if PUBLIC_TYPES + public +#else + internal +#endif + enum WindowStyles : int { + WS_OVERLAPPED = 0x00000000, + WS_POPUP = unchecked((int)0x80000000), + WS_CHILD = 0x40000000, + WS_MINIMIZE = 0x20000000, + WS_VISIBLE = 0x10000000, + WS_DISABLED = 0x08000000, + WS_CLIPSIBLINGS = 0x04000000, + WS_CLIPCHILDREN = 0x02000000, + WS_MAXIMIZE = 0x01000000, + WS_CAPTION = 0x00C00000, // == WS_BORDER | WS_DLGFRAME + WS_BORDER = 0x00800000, + WS_DLGFRAME = 0x00400000, + WS_VSCROLL = 0x00200000, + WS_HSCROLL = 0x00100000, + WS_SYSMENU = 0x00080000, + WS_THICKFRAME = 0x00040000, + WS_GROUP = 0x00020000, + WS_TABSTOP = 0x00010000, + WS_MINIMIZEBOX = 0x00020000, + WS_MAXIMIZEBOX = 0x00010000, + WS_TILED = 0x00000000, + WS_ICONIC = 0x20000000, + WS_SIZEBOX = 0x00040000, + WS_POPUPWINDOW = unchecked((int)0x80880000), + WS_OVERLAPPEDWINDOW = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX, + WS_TILEDWINDOW = WS_OVERLAPPEDWINDOW, + WS_CHILDWINDOW = WS_CHILD, + } + + [Flags] +#if PUBLIC_TYPES + public +#else + internal +#endif + enum WindowExStyles : int { + // Extended Styles + WS_EX_DLGMODALFRAME = 0x00000001, + WS_EX_DRAGDETECT = 0x00000002, + WS_EX_NOPARENTNOTIFY = 0x00000004, + WS_EX_TOPMOST = 0x00000008, + WS_EX_ACCEPTFILES = 0x00000010, + WS_EX_TRANSPARENT = 0x00000020, + + WS_EX_MDICHILD = 0x00000040, + WS_EX_TOOLWINDOW = 0x00000080, + WS_EX_WINDOWEDGE = 0x00000100, + WS_EX_CLIENTEDGE = 0x00000200, + WS_EX_CONTEXTHELP = 0x00000400, + + WS_EX_RIGHT = 0x00001000, + WS_EX_LEFT = 0x00000000, + WS_EX_RTLREADING = 0x00002000, + WS_EX_LTRREADING = 0x00000000, + WS_EX_LEFTSCROLLBAR = 0x00004000, + WS_EX_LAYERED = 0x00080000, + WS_EX_RIGHTSCROLLBAR = 0x00000000, + + WS_EX_WidgetPARENT = 0x00010000, + WS_EX_STATICEDGE = 0x00020000, + WS_EX_APPWINDOW = 0x00040000, + WS_EX_NOINHERITLAYOUT = 0x00100000, + WS_EX_LAYOUTRTL = 0x00400000, + WS_EX_COMPOSITED = 0x02000000, + WS_EX_NOACTIVATE = 0x08000000, + + WS_EX_OVERLAPPEDWINDOW = WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE, + WS_EX_PALETTEWINDOW = WS_EX_WINDOWEDGE | WS_EX_TOOLWINDOW | WS_EX_TOPMOST + } + + [Flags] +#if PUBLIC_TYPES + public +#else + internal +#endif + enum ToolBarStyles : int { + TBSTYLE_TOOLTIPS = 0x100, + TBSTYLE_FLAT = 0x800, + TBSTYLE_LIST = 0x1000, + TBSTYLE_TRANSPARENT = 0x8000 + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum Msg { + WM_NULL = 0x0000, + WM_CREATE = 0x0001, + WM_DESTROY = 0x0002, + WM_MOVE = 0x0003, + WM_SIZE = 0x0005, + WM_ACTIVATE = 0x0006, + WM_SETFOCUS = 0x0007, + WM_KILLFOCUS = 0x0008, + // public const uint WM_SETVISIBLE = 0x0009; + WM_ENABLE = 0x000A, + WM_SETREDRAW = 0x000B, + WM_SETTEXT = 0x000C, + WM_GETTEXT = 0x000D, + WM_GETTEXTLENGTH = 0x000E, + WM_PAINT = 0x000F, + WM_CLOSE = 0x0010, + WM_QUERYENDSESSION = 0x0011, + WM_QUIT = 0x0012, + WM_QUERYOPEN = 0x0013, + WM_ERASEBKGND = 0x0014, + WM_SYSCOLORCHANGE = 0x0015, + WM_ENDSESSION = 0x0016, + // public const uint WM_SYSTEMERROR = 0x0017; + WM_SHOWWINDOW = 0x0018, + WM_CTLCOLOR = 0x0019, + WM_WININICHANGE = 0x001A, + WM_SETTINGCHANGE = 0x001A, + WM_DEVMODECHANGE = 0x001B, + WM_ACTIVATEAPP = 0x001C, + WM_FONTCHANGE = 0x001D, + WM_TIMECHANGE = 0x001E, + WM_CANCELMODE = 0x001F, + WM_SETCURSOR = 0x0020, + WM_MOUSEACTIVATE = 0x0021, + WM_CHILDACTIVATE = 0x0022, + WM_QUEUESYNC = 0x0023, + WM_GETMINMAXINFO = 0x0024, + WM_PAINTICON = 0x0026, + WM_ICONERASEBKGND = 0x0027, + WM_NEXTDLGCTL = 0x0028, + // public const uint WM_ALTTABACTIVE = 0x0029; + WM_SPOOLERSTATUS = 0x002A, + WM_DRAWITEM = 0x002B, + WM_MEASUREITEM = 0x002C, + WM_DELETEITEM = 0x002D, + WM_VKEYTOITEM = 0x002E, + WM_CHARTOITEM = 0x002F, + WM_SETFONT = 0x0030, + WM_GETFONT = 0x0031, + WM_SETHOTKEY = 0x0032, + WM_GETHOTKEY = 0x0033, + // public const uint WM_FILESYSCHANGE = 0x0034; + // public const uint WM_ISACTIVEICON = 0x0035; + // public const uint WM_QUERYPARKICON = 0x0036; + WM_QUERYDRAGICON = 0x0037, + WM_COMPAREITEM = 0x0039, + // public const uint WM_TESTING = 0x003a; + // public const uint WM_OTHERWINDOWCREATED = 0x003c; + WM_GETOBJECT = 0x003D, + // public const uint WM_ACTIVATESHELLWINDOW = 0x003e; + WM_COMPACTING = 0x0041, + WM_COMMNOTIFY = 0x0044 , + WM_WINDOWPOSCHANGING = 0x0046, + WM_WINDOWPOSCHANGED = 0x0047, + WM_POWER = 0x0048, + WM_COPYDATA = 0x004A, + WM_CANCELJOURNAL = 0x004B, + WM_NOTIFY = 0x004E, + WM_INPUTLANGCHANGEREQUEST = 0x0050, + WM_INPUTLANGCHANGE = 0x0051, + WM_TCARD = 0x0052, + WM_HELP = 0x0053, + WM_USERCHANGED = 0x0054, + WM_NOTIFYFORMAT = 0x0055, + WM_CONTEXTMENU = 0x007B, + WM_STYLECHANGING = 0x007C, + WM_STYLECHANGED = 0x007D, + WM_DISPLAYCHANGE = 0x007E, + WM_GETICON = 0x007F, + + // Non-Client messages + WM_SETICON = 0x0080, + WM_NCCREATE = 0x0081, + WM_NCDESTROY = 0x0082, + WM_NCCALCSIZE = 0x0083, + WM_NCHITTEST = 0x0084, + WM_NCPAINT = 0x0085, + WM_NCACTIVATE = 0x0086, + WM_GETDLGCODE = 0x0087, + WM_SYNCPAINT = 0x0088, + // public const uint WM_SYNCTASK = 0x0089; + WM_NCMOUSEMOVE = 0x00A0, + WM_NCLBUTTONDOWN = 0x00A1, + WM_NCLBUTTONUP = 0x00A2, + WM_NCLBUTTONDBLCLK = 0x00A3, + WM_NCRBUTTONDOWN = 0x00A4, + WM_NCRBUTTONUP = 0x00A5, + WM_NCRBUTTONDBLCLK = 0x00A6, + WM_NCMBUTTONDOWN = 0x00A7, + WM_NCMBUTTONUP = 0x00A8, + WM_NCMBUTTONDBLCLK = 0x00A9, + // public const uint WM_NCXBUTTONDOWN = 0x00ab; + // public const uint WM_NCXBUTTONUP = 0x00ac; + // public const uint WM_NCXBUTTONDBLCLK = 0x00ad; + WM_KEYDOWN = 0x0100, + WM_KEYFIRST = 0x0100, + WM_KEYUP = 0x0101, + WM_CHAR = 0x0102, + WM_DEADCHAR = 0x0103, + WM_SYSKEYDOWN = 0x0104, + WM_SYSKEYUP = 0x0105, + WM_SYSCHAR = 0x0106, + WM_SYSDEADCHAR = 0x0107, + WM_KEYLAST = 0x0108, + WM_IME_STARTCOMPOSITION = 0x010D, + WM_IME_ENDCOMPOSITION = 0x010E, + WM_IME_COMPOSITION = 0x010F, + WM_IME_KEYLAST = 0x010F, + WM_INITDIALOG = 0x0110, + WM_COMMAND = 0x0111, + WM_SYSCOMMAND = 0x0112, + WM_TIMER = 0x0113, + WM_HSCROLL = 0x0114, + WM_VSCROLL = 0x0115, + WM_INITMENU = 0x0116, + WM_INITMENUPOPUP = 0x0117, + // public const uint WM_SYSTIMER = 0x0118; + WM_MENUSELECT = 0x011F, + WM_MENUCHAR = 0x0120, + WM_ENTERIDLE = 0x0121, + WM_MENURBUTTONUP = 0x0122, + WM_MENUDRAG = 0x0123, + WM_MENUGETOBJECT = 0x0124, + WM_UNINITMENUPOPUP = 0x0125, + WM_MENUCOMMAND = 0x0126, + + WM_CHANGEUISTATE = 0x0127, + WM_UPDATEUISTATE = 0x0128, + WM_QUERYUISTATE = 0x0129, + + // public const uint WM_LBTRACKPOINT = 0x0131; + WM_CTLCOLORMSGBOX = 0x0132, + WM_CTLCOLOREDIT = 0x0133, + WM_CTLCOLORLISTBOX = 0x0134, + WM_CTLCOLORBTN = 0x0135, + WM_CTLCOLORDLG = 0x0136, + WM_CTLCOLORSCROLLBAR = 0x0137, + WM_CTLCOLORSTATIC = 0x0138, + WM_MOUSEMOVE = 0x0200, + WM_MOUSEFIRST = 0x0200, + WM_LBUTTONDOWN = 0x0201, + WM_LBUTTONUP = 0x0202, + WM_LBUTTONDBLCLK = 0x0203, + WM_RBUTTONDOWN = 0x0204, + WM_RBUTTONUP = 0x0205, + WM_RBUTTONDBLCLK = 0x0206, + WM_MBUTTONDOWN = 0x0207, + WM_MBUTTONUP = 0x0208, + WM_MBUTTONDBLCLK = 0x0209, + WM_MOUSEWHEEL = 0x020A, + WM_MOUSELAST = 0x020D, + // public const uint WM_XBUTTONDOWN = 0x020B; + // public const uint WM_XBUTTONUP = 0x020C; + // public const uint WM_XBUTTONDBLCLK = 0x020D; + WM_PARENTNOTIFY = 0x0210, + WM_ENTERMENULOOP = 0x0211, + WM_EXITMENULOOP = 0x0212, + WM_NEXTMENU = 0x0213, + WM_SIZING = 0x0214, + WM_CAPTURECHANGED = 0x0215, + WM_MOVING = 0x0216, + // public const uint WM_POWERBROADCAST = 0x0218; + WM_DEVICECHANGE = 0x0219, + WM_MDICREATE = 0x0220, + WM_MDIDESTROY = 0x0221, + WM_MDIACTIVATE = 0x0222, + WM_MDIRESTORE = 0x0223, + WM_MDINEXT = 0x0224, + WM_MDIMAXIMIZE = 0x0225, + WM_MDITILE = 0x0226, + WM_MDICASCADE = 0x0227, + WM_MDIICONARRANGE = 0x0228, + WM_MDIGETACTIVE = 0x0229, + /* D&D messages */ + // public const uint WM_DROPOBJECT = 0x022A; + // public const uint WM_QUERYDROPOBJECT = 0x022B; + // public const uint WM_BEGINDRAG = 0x022C; + // public const uint WM_DRAGLOOP = 0x022D; + // public const uint WM_DRAGSELECT = 0x022E; + // public const uint WM_DRAGMOVE = 0x022F; + WM_MDISETMENU = 0x0230, + WM_ENTERSIZEMOVE = 0x0231, + WM_EXITSIZEMOVE = 0x0232, + WM_DROPFILES = 0x0233, + WM_MDIREFRESHMENU = 0x0234, + WM_IME_SETCONTEXT = 0x0281, + WM_IME_NOTIFY = 0x0282, + WM_IME_Widget = 0x0283, + WM_IME_COMPOSITIONFULL = 0x0284, + WM_IME_SELECT = 0x0285, + WM_IME_CHAR = 0x0286, + WM_IME_REQUEST = 0x0288, + WM_IME_KEYDOWN = 0x0290, + WM_IME_KEYUP = 0x0291, + WM_NCMOUSEHOVER = 0x02A0, + WM_MOUSEHOVER = 0x02A1, + WM_NCMOUSELEAVE = 0x02A2, + WM_MOUSELEAVE = 0x02A3, + WM_CUT = 0x0300, + WM_COPY = 0x0301, + WM_PASTE = 0x0302, + WM_CLEAR = 0x0303, + WM_UNDO = 0x0304, + WM_RENDERFORMAT = 0x0305, + WM_RENDERALLFORMATS = 0x0306, + WM_DESTROYCLIPBOARD = 0x0307, + WM_DRAWCLIPBOARD = 0x0308, + WM_PAINTCLIPBOARD = 0x0309, + WM_VSCROLLCLIPBOARD = 0x030A, + WM_SIZECLIPBOARD = 0x030B, + WM_ASKCBFORMATNAME = 0x030C, + WM_CHANGECBCHAIN = 0x030D, + WM_HSCROLLCLIPBOARD = 0x030E, + WM_QUERYNEWPALETTE = 0x030F, + WM_PALETTEISCHANGING = 0x0310, + WM_PALETTECHANGED = 0x0311, + WM_HOTKEY = 0x0312, + WM_PRINT = 0x0317, + WM_PRINTCLIENT = 0x0318, + WM_HANDHELDFIRST = 0x0358, + WM_HANDHELDLAST = 0x035F, + WM_AFXFIRST = 0x0360, + WM_AFXLAST = 0x037F, + WM_PENWINFIRST = 0x0380, + WM_PENWINLAST = 0x038F, + WM_APP = 0x8000, + WM_USER = 0x0400, + + // Our "private" ones + WM_MOUSE_ENTER = 0x0401, + WM_ASYNC_MESSAGE = 0x0403, + WM_REFLECT = WM_USER + 0x1c00, + WM_CLOSE_INTERNAL = WM_USER + 0x1c01, + + // private messages to support on-the-spot IME editing. + WM_XIM_PREEDITSTART = WM_USER + 0x1d00, + WM_XIM_PREEDITDONE = WM_USER + 0x1d01, + WM_XIM_PREEDITDRAW = WM_USER + 0x1d02, + WM_XIM_PREEDITCARET = WM_USER + 0x1d03, + + // NotifyIcon (Systray) Balloon messages + NIN_BALLOONSHOW = WM_USER + 0x0002, + NIN_BALLOONHIDE = WM_USER + 0x0003, + NIN_BALLOONTIMEOUT = WM_USER + 0x0004, + NIN_BALLOONUSERCLICK = WM_USER + 0x0005 + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum MsgButtons { + MK_LBUTTON = 0x0001, + MK_RBUTTON = 0x0002, + MK_SHIFT = 0x0004, + MK_CONTROL = 0x0008, + MK_MBUTTON = 0x0010, + MK_XBUTTON1 = 0x0020, + MK_XBUTTON2 = 0x0040, + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum MsgUIState { + UIS_SET = 1, + UIS_CLEAR = 2, + UIS_INITIALIZE = 3, + UISF_HIDEFOCUS = 0x1, + UISF_HIDEACCEL = 0x2, + UISF_ACTIVE = 0x4 + } + + [StructLayout(LayoutKind.Sequential)] +#if PUBLIC_TYPES + public +#else + internal +#endif + struct POINT { + public int x; + public int y; + + public POINT (int x, int y) + { + this.x = x; + this.y = y; + } + + public Point ToPoint () + { + return new Point (x, y); + } + + public override string ToString () + { + return "Point {" + x.ToString () + ", " + y.ToString () + "}"; + } + } + + [StructLayout(LayoutKind.Sequential)] +#if PUBLIC_TYPES + public +#else + internal +#endif + struct MSG { + internal IntPtr hwnd; + internal Msg message; + internal IntPtr wParam; + internal IntPtr lParam; + internal uint time; + internal POINT pt; + internal object refobject; + + public override string ToString () + { + return String.Format ("msg=0x{0:x} ({1}) hwnd=0x{2:x} wparam=0x{3:x} lparam=0x{4:x} pt={5}", (int) message, message.ToString (), hwnd.ToInt32 (), wParam.ToInt32 (), lParam.ToInt32 (), pt); + } + } + + [Flags] +#if PUBLIC_TYPES + public +#else + internal +#endif + enum TransparencySupport { + None = 0x00, + Get = 0x01, + Set = 0x02, + GetSet = 0x03 + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum WindowActiveFlags { + WA_INACTIVE = 0, + WA_ACTIVE = 1, + WA_CLICKACTIVE = 2 + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum KeybdEventFlags { + None = 0, + ExtendedKey = 0x0001, + KeyUp = 0x0002 + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum VirtualKeys { + VK_LBUTTON = 0x01, + VK_RBUTTON = 0x02, + VK_CANCEL = 0x03, + VK_MBUTTON = 0x04, + VK_XBUTTON1 = 0x05, + VK_XBUTTON2 = 0x06, + VK_BACK = 0x08, + VK_TAB = 0x09, + VK_CLEAR = 0x0C, + VK_RETURN = 0x0D, + VK_SHIFT = 0x10, + VK_CONTROL = 0x11, + VK_MENU = 0x12, + VK_PAUSE = 0x13, + VK_CAPITAL = 0x14, + VK_ESCAPE = 0x1B, + VK_CONVERT = 0x1C, + VK_NONCONVERT = 0x1D, + VK_SPACE = 0x20, + VK_PRIOR = 0x21, + VK_NEXT = 0x22, + VK_END = 0x23, + VK_HOME = 0x24, + VK_LEFT = 0x25, + VK_UP = 0x26, + VK_RIGHT = 0x27, + VK_DOWN = 0x28, + VK_SELECT = 0x29, + VK_PRINT = 0x2A, + VK_EXECUTE = 0x2B, + VK_SNAPSHOT = 0x2C, + VK_INSERT = 0x2D, + VK_DELETE = 0x2E, + VK_HELP = 0x2F, + VK_0 = 0x30, + VK_1 = 0x31, + VK_2 = 0x32, + VK_3 = 0x33, + VK_4 = 0x34, + VK_5 = 0x35, + VK_6 = 0x36, + VK_7 = 0x37, + VK_8 = 0x38, + VK_9 = 0x39, + VK_A = 0x41, + VK_B = 0x42, + VK_C = 0x43, + VK_D = 0x44, + VK_E = 0x45, + VK_F = 0x46, + VK_G = 0x47, + VK_H = 0x48, + VK_I = 0x49, + VK_J = 0x4A, + VK_K = 0x4B, + VK_L = 0x4C, + VK_M = 0x4D, + VK_N = 0x4E, + VK_O = 0x4F, + VK_P = 0x50, + VK_Q = 0x51, + VK_R = 0x52, + VK_S = 0x53, + VK_T = 0x54, + VK_U = 0x55, + VK_V = 0x56, + VK_W = 0x57, + VK_X = 0x58, + VK_Y = 0x59, + VK_Z = 0x5A, + VK_LWIN = 0x5B, + VK_RWIN = 0x5C, + VK_APPS = 0x5D, + VK_NUMPAD0 = 0x60, + VK_NUMPAD1 = 0x61, + VK_NUMPAD2 = 0x62, + VK_NUMPAD3 = 0x63, + VK_NUMPAD4 = 0x64, + VK_NUMPAD5 = 0x65, + VK_NUMPAD6 = 0x66, + VK_NUMPAD7 = 0x67, + VK_NUMPAD8 = 0x68, + VK_NUMPAD9 = 0x69, + VK_MULTIPLY = 0x6A, + VK_ADD = 0x6B, + VK_SEPARATOR = 0x6C, + VK_SUBTRACT = 0x6D, + VK_DECIMAL = 0x6E, + VK_DIVIDE = 0x6F, + VK_F1 = 0x70, + VK_F2 = 0x71, + VK_F3 = 0x72, + VK_F4 = 0x73, + VK_F5 = 0x74, + VK_F6 = 0x75, + VK_F7 = 0x76, + VK_F8 = 0x77, + VK_F9 = 0x78, + VK_F10 = 0x79, + VK_F11 = 0x7A, + VK_F12 = 0x7B, + VK_F13 = 0x7C, + VK_F14 = 0x7D, + VK_F15 = 0x7E, + VK_F16 = 0x7F, + VK_F17 = 0x80, + VK_F18 = 0x81, + VK_F19 = 0x82, + VK_F20 = 0x83, + VK_F21 = 0x84, + VK_F22 = 0x85, + VK_F23 = 0x86, + VK_F24 = 0x87, + VK_NUMLOCK = 0x90, + VK_SCROLL = 0x91, + VK_LSHIFT = 0xA0, + VK_RSHIFT = 0xA1, + VK_LWidget = 0xA2, + VK_RWidget = 0xA3, + VK_LMENU = 0xA4, + VK_RMENU = 0xA5, + VK_OEM_1 = 0xBA, + VK_OEM_PLUS = 0xBB, + VK_OEM_COMMA = 0xBC, + VK_OEM_MINUS = 0xBD, + VK_OEM_PERIOD = 0xBE, + VK_OEM_2 = 0xBF, + VK_OEM_3 = 0xC0, + VK_OEM_4 = 0xDB, + VK_OEM_5 = 0xDC, + VK_OEM_6 = 0xDD, + VK_OEM_7 = 0xDE, + VK_OEM_8 = 0xDF, + VK_OEM_AX = 0xE1, + VK_OEM_102 = 0xE2, + VK_ICO_HELP = 0xE3, + VK_ICO_00 = 0xE4, + VK_PROCESSKEY = 0xE5, + VK_OEM_ATTN = 0xF0, + VK_OEM_COPY = 0xF2, + VK_OEM_AUTO = 0xF3, + VK_OEM_ENLW = 0xF4, + VK_OEM_BACKTAB = 0xF5, + VK_ATTN = 0xF6, + VK_CRSEL = 0xF7, + VK_EXSEL = 0xF8, + VK_EREOF = 0xF9, + VK_PLAY = 0xFA, + VK_ZOOM = 0xFB, + VK_NONAME = 0xFC, + VK_PA1 = 0xFD, + VK_OEM_CLEAR = 0xFE, + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum TtyKeys { + XK_BackSpace = 0xff08, /* Back space, back char */ + XK_Tab = 0xff09, + XK_Linefeed = 0xff0a, /* Linefeed, LF */ + XK_Clear = 0xff0b, + XK_Return = 0xff0d, /* Return, enter */ + XK_Pause = 0xff13, /* Pause, hold */ + XK_Scroll_Lock = 0xff14, + XK_Sys_Req = 0xff15, + XK_Escape = 0xff1b, + XK_Delete = 0xffff /* Delete, rubout */ + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum MiscKeys { + XK_ISO_Lock = 0xfe01, + XK_ISO_Last_Group_Lock = 0xfe0f, + XK_Select = 0xff60, + XK_Print = 0xff61, + XK_Execute = 0xff62, + XK_Insert = 0xff63, + XK_Undo = 0xff65, + XK_Redo = 0xff66, + XK_Menu = 0xff67, + XK_Find = 0xff68, + XK_Cancel = 0xff69, + XK_Help = 0xff6a, + XK_Break = 0xff6b, + XK_Mode_switch = 0xff7e, + XK_script_switch = 0xff7e, + XK_Num_Lock = 0xff7f + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum KeypadKeys { + XK_KP_Space = 0xff80, + XK_KP_Tab = 0xff89, + XK_KP_Enter = 0xff8d, /* Enter */ + XK_KP_F1 = 0xff91, /* PF1, KP_A, ... */ + XK_KP_F2 = 0xff92, + XK_KP_F3 = 0xff93, + XK_KP_F4 = 0xff94, + XK_KP_Home = 0xff95, + XK_KP_Left = 0xff96, + XK_KP_Up = 0xff97, + XK_KP_Right = 0xff98, + XK_KP_Down = 0xff99, + XK_KP_Prior = 0xff9a, + XK_KP_Page_Up = 0xff9a, + XK_KP_Next = 0xff9b, + XK_KP_Page_Down = 0xff9b, + XK_KP_End = 0xff9c, + XK_KP_Begin = 0xff9d, + XK_KP_Insert = 0xff9e, + XK_KP_Delete = 0xff9f, + XK_KP_Equal = 0xffbd, /* Equals */ + XK_KP_Multiply = 0xffaa, + XK_KP_Add = 0xffab, + XK_KP_Separator = 0xffac, /* Separator, often comma */ + XK_KP_Subtract = 0xffad, + XK_KP_Decimal = 0xffae, + XK_KP_Divide = 0xffaf, + + XK_KP_0 = 0xffb0, + XK_KP_1 = 0xffb1, + XK_KP_2 = 0xffb2, + XK_KP_3 = 0xffb3, + XK_KP_4 = 0xffb4, + XK_KP_5 = 0xffb5, + XK_KP_6 = 0xffb6, + XK_KP_7 = 0xffb7, + XK_KP_8 = 0xffb8, + XK_KP_9 = 0xffb9 + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum DeadKeys { + XK_dead_grave = 0xfe50, + XK_dead_acute = 0xfe51, + XK_dead_circumflex = 0xfe52, + XK_dead_tilde = 0xfe53, + XK_dead_macron = 0xfe54, + XK_dead_breve = 0xfe55, + XK_dead_abovedot = 0xfe56, + XK_dead_diaeresis = 0xfe57, + XK_dead_abovering = 0xfe58, + XK_dead_doubleacute = 0xfe59, + XK_dead_caron = 0xfe5a, + XK_dead_cedilla = 0xfe5b, + XK_dead_ogonek = 0xfe5c, + XK_dead_iota = 0xfe5d, + XK_dead_voiced_sound = 0xfe5e, + XK_dead_semivoiced_sound = 0xfe5f, + XK_dead_belowdot = 0xfe60, + XK_dead_hook = 0xfe61, + XK_dead_horn = 0xfe62 + + } + + [StructLayout(LayoutKind.Sequential)] +#if PUBLIC_TYPES + public +#else + internal +#endif + struct HELPINFO { + internal uint cbSize; + internal int iContextType; + internal int iCtrlId; + internal IntPtr hItemHandle; + internal uint dwContextId; + internal POINT MousePos; + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum PeekMessageFlags { + PM_NOREMOVE = 0x00000000, + PM_REMOVE = 0x00000001, + PM_NOYIELD = 0x00000002 + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum StdCursor { + Default = 0, + AppStarting = 1, + Arrow = 2, + Cross = 3, + Hand = 4, + Help = 5, + HSplit = 6, + IBeam = 7, + No = 8, + NoMove2D = 9, + NoMoveHoriz = 10, + NoMoveVert = 11, + PanEast = 12, + PanNE = 13, + PanNorth = 14, + PanNW = 15, + PanSE = 16, + PanSouth = 17, + PanSW = 18, + PanWest = 19, + SizeAll = 20, + SizeNESW = 21, + SizeNS = 22, + SizeNWSE = 23, + SizeWE = 24, + UpArrow = 25, + VSplit = 26, + WaitCursor = 27 + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum HitTest { + HTERROR = -2, + HTTRANSPARENT = -1, + HTNOWHERE = 0, + HTCLIENT = 1, + HTCAPTION = 2, + HTSYSMENU = 3, + HTGROWBOX = 4, + HTSIZE = HTGROWBOX, + HTMENU = 5, + HTHSCROLL = 6, + HTVSCROLL = 7, + HTMINBUTTON = 8, + HTMAXBUTTON = 9, + HTLEFT = 10, + HTRIGHT = 11, + HTTOP = 12, + HTTOPLEFT = 13, + HTTOPRIGHT = 14, + HTBOTTOM = 15, + HTBOTTOMLEFT = 16, + HTBOTTOMRIGHT = 17, + HTBORDER = 18, + HTREDUCE = HTMINBUTTON, + HTZOOM = HTMAXBUTTON, + HTSIZEFIRST = HTLEFT, + HTSIZELAST = HTBOTTOMRIGHT, + HTOBJECT = 19, + HTCLOSE = 20, + HTHELP = 21 + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum TitleStyle { + None = 0, + Normal = 1, + Tool = 2 + } + + [StructLayout(LayoutKind.Sequential)] +#if PUBLIC_TYPES + public +#else + internal +#endif + struct BITMAPINFOHEADER { + internal uint biSize; + internal int biWidth; + internal int biHeight; + internal ushort biPlanes; + internal ushort biBitCount; + internal uint biCompression; + internal uint biSizeImage; + internal int biXPelsPerMeter; + internal int biYPelsPerMeter; + internal uint biClrUsed; + internal uint biClrImportant; + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum ClipboardFormats : ushort { + CF_TEXT = 1, + CF_BITMAP = 2, + CF_METAFILEPICT = 3, + CF_SYLK = 4, + CF_DIF = 5, + CF_TIFF = 6, + CF_OEMTEXT = 7, + CF_DIB = 8, + CF_PALETTE = 9, + CF_PENDATA = 10, + CF_RIFF = 11, + CF_WAVE = 12, + CF_UNICODETEXT = 13, + CF_ENHMETAFILE = 14, + CF_HDROP = 15, + CF_LOCALE = 16, + CF_DIBV5 = 17 + } + + [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] +#if PUBLIC_TYPES + public +#else + internal +#endif + struct MINMAXINFO { + internal POINT ptReserved; + internal POINT ptMaxSize; + internal POINT ptMaxPosition; + internal POINT ptMinTrackSize; + internal POINT ptMaxTrackSize; + } + + [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] +#if PUBLIC_TYPES + public +#else + internal +#endif + struct KeyFilterData { + internal bool Down; + internal int keycode; + internal int keysym; + internal Keys ModifierKeys; + internal String str; + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum ScrollBarCommands { + SB_LINEUP = 0, + SB_LINELEFT = 0, + SB_LINEDOWN = 1, + SB_LINERIGHT = 1, + SB_PAGEUP = 2, + SB_PAGELEFT = 2, + SB_PAGEDOWN = 3, + SB_PAGERIGHT = 3, + SB_THUMBPOSITION = 4, + SB_THUMBTRACK = 5, + SB_TOP = 6, + SB_LEFT = 6, + SB_BOTTOM = 7, + SB_RIGHT = 7, + SB_ENDSCROLL = 8 + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum ClipCombineMode { + RGN_AND = 1, + RGN_OR, + RGN_XOR, + RGN_DIFF, + RGN_COPY, + + RGN_MIN = RGN_AND, + RGN_MAX = RGN_COPY + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum SystemCommands { + SC_SIZE = 0xF000, + SC_MOVE = 0xF010, + SC_MINIMIZE = 0xF020, + SC_MAXIMIZE = 0xF030, + SC_NEXTWINDOW = 0xF040, + SC_PREVWINDOW = 0xF050, + SC_CLOSE = 0xF060, + SC_VSCROLL = 0xF070, + SC_HSCROLL = 0xF080, + SC_MOUSEMENU = 0xF090, + SC_KEYMENU = 0xF100, + SC_ARRANGE = 0xF110, + SC_RESTORE = 0xF120, + SC_TASKLIST = 0xF130, + SC_SCREENSAVE = 0xF140, + SC_HOTKEY = 0xF150, + SC_DEFAULT = 0xF160, + SC_MONITORPOWER = 0xF170, + SC_CONTEXTHELP = 0xF180 + } + +#if PUBLIC_TYPES + public +#else + internal +#endif + enum AlertType { + Default = 1, + Error = 2, + Question = 3, + Warning = 4, + Information = 5 + } +} + diff --git a/source/ShiftUI/Internal/XplatUIWin32.cs b/source/ShiftUI/Internal/XplatUIWin32.cs new file mode 100644 index 0000000..a741a46 --- /dev/null +++ b/source/ShiftUI/Internal/XplatUIWin32.cs @@ -0,0 +1,3751 @@ +// 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) 2004-2006 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// +// + +// NOT COMPLETE + +using System; +using System.Drawing; +using System.Drawing.Imaging; +using System.ComponentModel; +using System.Collections; +using System.Diagnostics; +using System.IO; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; + + +/// Win32 Version +namespace ShiftUI { + internal class XplatUIWin32 : XplatUIDriver { + #region Local Variables + private static XplatUIWin32 instance; + private static int ref_count; + private static IntPtr FosterParentLast; + + internal static MouseButtons mouse_state; + internal static Point mouse_position; + internal static bool grab_confined; + internal static IntPtr grab_hwnd; + internal static Rectangle grab_area; + internal static WndProc wnd_proc; + internal static IntPtr prev_mouse_hwnd; + internal static bool caret_visible; + + internal static bool themes_enabled; + private Hashtable timer_list; + private static Queue message_queue; + private static IntPtr clip_magic = new IntPtr(27051977); + private static int scroll_width; + private static int scroll_height; + private static Hashtable wm_nc_registered; + private static RECT clipped_cursor_rect; + private Hashtable registered_classes; + private Hwnd HwndCreating; // the Hwnd we are currently creating (see CreateWindow) + + #endregion // Local Variables + + #region Private Structs + [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] + private struct WNDCLASS { + internal int style; + internal WndProc lpfnWndProc; + internal int cbClsExtra; + internal int cbWndExtra; + internal IntPtr hInstance; + internal IntPtr hIcon; + internal IntPtr hCursor; + internal IntPtr hbrBackground; + [MarshalAs(UnmanagedType.LPWStr)] + internal string lpszMenuName; + [MarshalAs(UnmanagedType.LPWStr)] + internal string lpszClassName; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct RECT { + internal int left; + internal int top; + internal int right; + internal int bottom; + + public RECT (int left, int top, int right, int bottom) + { + this.left = left; + this.top = top; + this.right = right; + this.bottom = bottom; + } + + #region Instance Properties + public int Height { get { return bottom - top; } } + public int Width { get { return right - left; } } + public Size Size { get { return new Size (Width, Height); } } + public Point Location { get { return new Point (left, top); } } + #endregion + + #region Instance Methods + public Rectangle ToRectangle () + { + return Rectangle.FromLTRB (left, top, right, bottom); + } + + public static RECT FromRectangle (Rectangle rectangle) + { + return new RECT (rectangle.Left, rectangle.Top, rectangle.Right, rectangle.Bottom); + } + + public override int GetHashCode () + { + return left ^ ((top << 13) | (top >> 0x13)) + ^ ((Width << 0x1a) | (Width >> 6)) + ^ ((Height << 7) | (Height >> 0x19)); + } + + public override string ToString () + { + return String.Format("RECT left={0}, top={1}, right={2}, bottom={3}, width={4}, height={5}", left, top, right, bottom, right-left, bottom-top); + } + #endregion + + #region Operator overloads + public static implicit operator Rectangle (RECT rect) + { + return Rectangle.FromLTRB (rect.left, rect.top, rect.right, rect.bottom); + } + + public static implicit operator RECT (Rectangle rect) + { + return new RECT (rect.Left, rect.Top, rect.Right, rect.Bottom); + } + #endregion + } + + internal enum SPIAction { + SPI_GETACTIVEWINDOWTRACKING = 0x1000, + SPI_GETACTIVEWNDTRKTIMEOUT = 0x2002, + SPI_GETANIMATION = 0x0048, + SPI_GETCARETWIDTH = 0x2006, + SPI_GETCOMBOBOXANIMATION = 0x1004, + SPI_GETDRAGFULLWINDOWS = 0x0026, + SPI_GETDROPSHADOW = 0x1024, + SPI_GETFONTSMOOTHING = 0x004A, + SPI_GETFONTSMOOTHINGCONTRAST = 0x200C, + SPI_GETFONTSMOOTHINGTYPE = 0x200A, + SPI_GETGRADIENTCAPTIONS = 0x1008, + SPI_GETHOTTRACKING = 0x100E, + SPI_GETICONTITLEWRAP = 0x0019, + SPI_GETKEYBOARDSPEED = 0x000A, + SPI_GETKEYBOARDDELAY = 0x0016, + SPI_GETKEYBOARDCUES = 0x100A, + SPI_GETKEYBOARDPREF = 0x0044, + SPI_GETLISTBOXSMOOTHSCROLLING = 0x1006, + SPI_GETMENUANIMATION = 0x1002, + SPI_GETMENUDROPALIGNMENT = 0x001B, + SPI_GETMENUFADE = 0x1012, + SPI_GETMENUSHOWDELAY = 0x006A, + SPI_GETMOUSESPEED = 0x0070, + SPI_GETSELECTIONFADE = 0x1014, + SPI_GETSNAPTODEFBUTTON = 0x005F, + SPI_GETTOOLTIPANIMATION = 0x1016, + SPI_GETWORKAREA = 0x0030, + SPI_GETMOUSEHOVERWIDTH = 0x0062, + SPI_GETMOUSEHOVERHEIGHT = 0x0064, + SPI_GETMOUSEHOVERTIME = 0x0066, + SPI_GETUIEFFECTS = 0x103E, + SPI_GETWHEELSCROLLLINES = 0x0068 + } + + internal enum WindowPlacementFlags { + SW_HIDE = 0, + SW_SHOWNORMAL = 1, + SW_NORMAL = 1, + SW_SHOWMINIMIZED = 2, + SW_SHOWMAXIMIZED = 3, + SW_MAXIMIZE = 3, + SW_SHOWNOACTIVATE = 4, + SW_SHOW = 5, + SW_MINIMIZE = 6, + SW_SHOWMINNOACTIVE = 7, + SW_SHOWNA = 8, + SW_RESTORE = 9, + SW_SHOWDEFAULT = 10, + SW_FORCEMINIMIZE = 11, + SW_MAX = 11 + } + + [StructLayout(LayoutKind.Sequential)] + private struct WINDOWPLACEMENT { + internal uint length; + internal uint flags; + internal WindowPlacementFlags showCmd; + internal POINT ptMinPosition; + internal POINT ptMaxPosition; + internal RECT rcNormalPosition; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct NCCALCSIZE_PARAMS { + internal RECT rgrc1; + internal RECT rgrc2; + internal RECT rgrc3; + internal IntPtr lppos; + } + + [Flags] + private enum TMEFlags { + TME_HOVER = 0x00000001, + TME_LEAVE = 0x00000002, + TME_NONCLIENT = 0x00000010, + TME_QUERY = unchecked((int)0x40000000), + TME_CANCEL = unchecked((int)0x80000000) + } + + [StructLayout(LayoutKind.Sequential)] + private struct TRACKMOUSEEVENT { + internal int size; + internal TMEFlags dwFlags; + internal IntPtr hWnd; + internal int dwHoverTime; + } + + [StructLayout(LayoutKind.Sequential)] + private struct PAINTSTRUCT { + internal IntPtr hdc; + internal int fErase; + internal RECT rcPaint; + internal int fRestore; + internal int fIncUpdate; + internal int Reserved1; + internal int Reserved2; + internal int Reserved3; + internal int Reserved4; + internal int Reserved5; + internal int Reserved6; + internal int Reserved7; + internal int Reserved8; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct KEYBDINPUT { + internal short wVk; + internal short wScan; + internal Int32 dwFlags; + internal Int32 time; + internal UIntPtr dwExtraInfo; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct MOUSEINPUT { + internal Int32 dx; + internal Int32 dy; + internal Int32 mouseData; + internal Int32 dwFlags; + internal Int32 time; + internal UIntPtr dwExtraInfo; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct HARDWAREINPUT { + internal Int32 uMsg; + internal short wParamL; + internal short wParamH; + } + + [StructLayout (LayoutKind.Sequential)] + internal struct ICONINFO { + internal bool fIcon; + internal Int32 xHotspot; + internal Int32 yHotspot; + internal IntPtr hbmMask; + internal IntPtr hbmColor; + } + + [StructLayout(LayoutKind.Explicit)] + internal struct INPUT { + [FieldOffset(0)] + internal Int32 type; + + [FieldOffset(4)] + internal MOUSEINPUT mi; + + [FieldOffset(4)] + internal KEYBDINPUT ki; + + [FieldOffset(4)] + internal HARDWAREINPUT hi; + } + + [StructLayout (LayoutKind.Sequential)] + public struct ANIMATIONINFO { + internal uint cbSize; + internal int iMinAnimate; + } + + internal enum InputFlags { + KEYEVENTF_EXTENDEDKEY = 0x0001, + KEYEVENTF_KEYUP = 0x0002, + KEYEVENTF_SCANCODE = 0x0003, + KEYEVENTF_UNICODE = 0x0004, + } + + internal enum ClassStyle { + CS_VREDRAW = 0x00000001, + CS_HREDRAW = 0x00000002, + CS_KEYCVTWINDOW = 0x00000004, + CS_DBLCLKS = 0x00000008, + CS_OWNDC = 0x00000020, + CS_CLASSDC = 0x00000040, + CS_PARENTDC = 0x00000080, + CS_NOKEYCVT = 0x00000100, + CS_NOCLOSE = 0x00000200, + CS_SAVEBITS = 0x00000800, + CS_BYTEALIGNCLIENT = 0x00001000, + CS_BYTEALIGNWINDOW = 0x00002000, + CS_GLOBALCLASS = 0x00004000, + CS_IME = 0x00010000, + // Windows XP+ + CS_DROPSHADOW = 0x00020000 + } + + internal enum SetWindowPosZOrder { + HWND_TOP = 0, + HWND_BOTTOM = 1, + HWND_TOPMOST = -1, + HWND_NOTOPMOST = -2 + } + + [Flags] + internal enum SetWindowPosFlags { + SWP_ASYNCWINDOWPOS = 0x4000, + SWP_DEFERERASE = 0x2000, + SWP_DRAWFRAME = 0x0020, + SWP_FRAMECHANGED = 0x0020, + SWP_HIDEWINDOW = 0x0080, + SWP_NOACTIVATE = 0x0010, + SWP_NOCOPYBITS = 0x0100, + SWP_NOMOVE = 0x0002, + SWP_NOOWNERZORDER = 0x0200, + SWP_NOREDRAW = 0x0008, + SWP_NOREPOSITION = 0x0200, + SWP_NOENDSCHANGING = 0x0400, + SWP_NOSIZE = 0x0001, + SWP_NOZORDER = 0x0004, + SWP_SHOWWINDOW = 0x0040 + } + + internal enum GetSysColorIndex { + COLOR_SCROLLBAR = 0, + COLOR_BACKGROUND = 1, + COLOR_ACTIVECAPTION = 2, + COLOR_INACTIVECAPTION = 3, + COLOR_MENU = 4, + COLOR_WINDOW = 5, + COLOR_WINDOWFRAME = 6, + COLOR_MENUTEXT = 7, + COLOR_WINDOWTEXT = 8, + COLOR_CAPTIONTEXT = 9, + COLOR_ACTIVEBORDER = 10, + COLOR_INACTIVEBORDER = 11, + COLOR_APPWORKSPACE = 12, + COLOR_HIGHLIGHT = 13, + COLOR_HIGHLIGHTTEXT = 14, + COLOR_BTNFACE = 15, + COLOR_BTNSHADOW = 16, + COLOR_GRAYTEXT = 17, + COLOR_BTNTEXT = 18, + COLOR_INACTIVECAPTIONTEXT = 19, + COLOR_BTNHIGHLIGHT = 20, + COLOR_3DDKSHADOW = 21, + COLOR_3DLIGHT = 22, + COLOR_INFOTEXT = 23, + COLOR_INFOBK = 24, + + COLOR_HOTLIGHT = 26, + COLOR_GRADIENTACTIVECAPTION = 27, + COLOR_GRADIENTINACTIVECAPTION = 28, + COLOR_MENUHIGHLIGHT = 29, + COLOR_MENUBAR = 30, + + COLOR_DESKTOP = 1, + COLOR_3DFACE = 16, + COLOR_3DSHADOW = 16, + COLOR_3DHIGHLIGHT = 20, + COLOR_3DHILIGHT = 20, + COLOR_BTNHILIGHT = 20, + COLOR_MAXVALUE = 24,/* Maximum value */ + } + + private enum LoadCursorType { + First = 32512, + IDC_ARROW = 32512, + IDC_IBEAM = 32513, + IDC_WAIT = 32514, + IDC_CROSS = 32515, + IDC_UPARROW = 32516, + IDC_SIZE = 32640, + IDC_ICON = 32641, + IDC_SIZENWSE = 32642, + IDC_SIZENESW = 32643, + IDC_SIZEWE = 32644, + IDC_SIZENS = 32645, + IDC_SIZEALL = 32646, + IDC_NO = 32648, + IDC_HAND = 32649, + IDC_APPSTARTING = 32650, + IDC_HELP = 32651, + Last = 32651 + } + + private enum AncestorType { + GA_PARENT = 1, + GA_ROOT = 2, + GA_ROOTOWNER = 3 + } + + [Flags] + private enum WindowLong { + GWL_WNDPROC = -4, + GWL_HINSTANCE = -6, + GWL_HWNDPARENT = -8, + GWL_STYLE = -16, + GWL_EXSTYLE = -20, + GWL_USERDATA = -21, + GWL_ID = -12 + } + + [Flags] + private enum LogBrushStyle { + BS_SOLID = 0, + BS_NULL = 1, + BS_HATCHED = 2, + BS_PATTERN = 3, + BS_INDEXED = 4, + BS_DIBPATTERN = 5, + BS_DIBPATTERNPT = 6, + BS_PATTERN8X8 = 7, + BS_DIBPATTERN8X8 = 8, + BS_MONOPATTERN = 9 + } + + [Flags] + private enum LogBrushHatch { + HS_HORIZONTAL = 0, /* ----- */ + HS_VERTICAL = 1, /* ||||| */ + HS_FDIAGONAL = 2, /* \\\\\ */ + HS_BDIAGONAL = 3, /* ///// */ + HS_CROSS = 4, /* +++++ */ + HS_DIAGCROSS = 5, /* xxxxx */ + } + + internal struct COLORREF { + internal byte R; + internal byte G; + internal byte B; + internal byte A; + } + + [StructLayout(LayoutKind.Sequential)] + private struct LOGBRUSH { + internal LogBrushStyle lbStyle; + internal COLORREF lbColor; + internal LogBrushHatch lbHatch; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct TEXTMETRIC { + internal int tmHeight; + internal int tmAscent; + internal int tmDescent; + internal int tmInternalLeading; + internal int tmExternalLeading; + internal int tmAveCharWidth; + internal int tmMaxCharWidth; + internal int tmWeight; + internal int tmOverhang; + internal int tmDigitizedAspectX; + internal int tmDigitizedAspectY; + internal short tmFirstChar; + internal short tmLastChar; + internal short tmDefaultChar; + internal short tmBreakChar; + internal byte tmItalic; + internal byte tmUnderlined; + internal byte tmStruckOut; + internal byte tmPitchAndFamily; + internal byte tmCharSet; + } + + public enum TernaryRasterOperations : uint + { + SRCCOPY = 0x00CC0020, + SRCPAINT = 0x00EE0086, + SRCAND = 0x008800C6, + SRCINVERT = 0x00660046, + SRCERASE = 0x00440328, + NOTSRCCOPY = 0x00330008, + NOTSRCERASE = 0x001100A6, + MERGECOPY = 0x00C000CA, + MERGEPAINT = 0x00BB0226, + PATCOPY = 0x00F00021, + PATPAINT = 0x00FB0A09, + PATINVERT = 0x005A0049, + DSTINVERT = 0x00550009, + BLACKNESS = 0x00000042, + WHITENESS = 0x00FF0062 + } + + [Flags] + private enum ScrollWindowExFlags { + SW_NONE = 0x0000, + SW_SCROLLCHILDREN = 0x0001, + SW_INVALIDATE = 0x0002, + SW_ERASE = 0x0004, + SW_SMOOTHSCROLL = 0x0010 + } + + internal enum SystemMetrics { + SM_CXSCREEN = 0, + SM_CYSCREEN = 1, + SM_CXVSCROLL = 2, + SM_CYHSCROLL = 3, + SM_CYCAPTION = 4, + SM_CXBORDER = 5, + SM_CYBORDER = 6, + SM_CXDLGFRAME = 7, + SM_CYDLGFRAME = 8, + SM_CYVTHUMB = 9, + SM_CXHTHUMB = 10, + SM_CXICON = 11, + SM_CYICON = 12, + SM_CXCURSOR = 13, + SM_CYCURSOR = 14, + SM_CYMENU = 15, + SM_CXFULLSCREEN = 16, + SM_CYFULLSCREEN = 17, + SM_CYKANJIWINDOW = 18, + SM_MOUSEPRESENT = 19, + SM_CYVSCROLL = 20, + SM_CXHSCROLL = 21, + SM_DEBUG = 22, + SM_SWAPBUTTON = 23, + SM_RESERVED1 = 24, + SM_RESERVED2 = 25, + SM_RESERVED3 = 26, + SM_RESERVED4 = 27, + SM_CXMIN = 28, + SM_CYMIN = 29, + SM_CXSIZE = 30, + SM_CYSIZE = 31, + SM_CXFRAME = 32, + SM_CYFRAME = 33, + SM_CXMINTRACK = 34, + SM_CYMINTRACK = 35, + SM_CXDOUBLECLK = 36, + SM_CYDOUBLECLK = 37, + SM_CXICONSPACING = 38, + SM_CYICONSPACING = 39, + SM_MENUDROPALIGNMENT = 40, + SM_PENWINDOWS = 41, + SM_DBCSENABLED = 42, + SM_CMOUSEBUTTONS = 43, + SM_CXFIXEDFRAME = SM_CXDLGFRAME, + SM_CYFIXEDFRAME = SM_CYDLGFRAME, + SM_CXSIZEFRAME = SM_CXFRAME, + SM_CYSIZEFRAME = SM_CYFRAME, + SM_SECURE = 44, + SM_CXEDGE = 45, + SM_CYEDGE = 46, + SM_CXMINSPACING = 47, + SM_CYMINSPACING = 48, + SM_CXSMICON = 49, + SM_CYSMICON = 50, + SM_CYSMCAPTION = 51, + SM_CXSMSIZE = 52, + SM_CYSMSIZE = 53, + SM_CXMENUSIZE = 54, + SM_CYMENUSIZE = 55, + SM_ARRANGE = 56, + SM_CXMINIMIZED = 57, + SM_CYMINIMIZED = 58, + SM_CXMAXTRACK = 59, + SM_CYMAXTRACK = 60, + SM_CXMAXIMIZED = 61, + SM_CYMAXIMIZED = 62, + SM_NETWORK = 63, + SM_CLEANBOOT = 67, + SM_CXDRAG = 68, + SM_CYDRAG = 69, + SM_SHOWSOUNDS = 70, + SM_CXMENUCHECK = 71, + SM_CYMENUCHECK = 72, + SM_SLOWMACHINE = 73, + SM_MIDEASTENABLED = 74, + SM_MOUSEWHEELPRESENT = 75, + SM_XVIRTUALSCREEN = 76, + SM_YVIRTUALSCREEN = 77, + SM_CXVIRTUALSCREEN = 78, + SM_CYVIRTUALSCREEN = 79, + SM_CMONITORS = 80, + SM_SAMEDISPLAYFORMAT = 81, + SM_IMMENABLED = 82, + SM_CXFOCUSBORDER = 83, + SM_CYFOCUSBORDER = 84, + SM_TABLETPC = 86, + SM_MEDIACENTER = 87, + SM_CMETRICS = 88 + } + + // We'll only support _WIN32_IE < 0x0500 for now + internal enum NotifyIconMessage { + NIM_ADD = 0x00000000, + NIM_MODIFY = 0x00000001, + NIM_DELETE = 0x00000002, + } + + [Flags] + internal enum NotifyIconFlags { + NIF_MESSAGE = 0x00000001, + NIF_ICON = 0x00000002, + NIF_TIP = 0x00000004, + NIF_STATE = 0x00000008, + NIF_INFO = 0x00000010 + } + + [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] + internal struct NOTIFYICONDATA { + internal uint cbSize; + internal IntPtr hWnd; + internal uint uID; + internal NotifyIconFlags uFlags; + internal uint uCallbackMessage; + internal IntPtr hIcon; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst=128)] + internal string szTip; + internal int dwState; + internal int dwStateMask; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)] + internal string szInfo; + internal int uTimeoutOrVersion; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst=64)] + internal string szInfoTitle; + internal ToolTipIcon dwInfoFlags; + } + + [Flags] + internal enum DCExFlags { + DCX_WINDOW = 0x00000001, + DCX_CACHE = 0x00000002, + DCX_NORESETATTRS = 0x00000004, + DCX_CLIPCHILDREN = 0x00000008, + DCX_CLIPSIBLINGS = 0x00000010, + DCX_PARENTCLIP = 0x00000020, + DCX_EXCLUDERGN = 0x00000040, + DCX_INTERSECTRGN = 0x00000080, + DCX_EXCLUDEUPDATE = 0x00000100, + DCX_INTERSECTUPDATE = 0x00000200, + DCX_LOCKWINDOWUPDATE = 0x00000400, + DCX_USESTYLE = 0x00010000, + DCX_VALIDATE = 0x00200000 + } + + [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] + internal struct CLIENTCREATESTRUCT { + internal IntPtr hWindowMenu; + internal uint idFirstChild; + } + + private enum ClassLong : int { + GCL_MENUNAME = -8, + GCL_HBRBACKGROUND = -10, + GCL_HCURSOR = -12, + GCL_HICON = -14, + GCL_HMODULE = -16, + GCL_CBWNDEXTRA = -18, + GCL_CBCLSEXTRA = -20, + GCL_WNDPROC = -24, + GCL_STYLE = -26, + GCW_ATOM = -32, + GCL_HICONSM = -34 + } + + [Flags] + internal enum GAllocFlags : uint { + GMEM_FIXED = 0x0000, + GMEM_MOVEABLE = 0x0002, + GMEM_NOCOMPACT = 0x0010, + GMEM_NODISCARD = 0x0020, + GMEM_ZEROINIT = 0x0040, + GMEM_MODIFY = 0x0080, + GMEM_DISCARDABLE = 0x0100, + GMEM_NOT_BANKED = 0x1000, + GMEM_SHARE = 0x2000, + GMEM_DDESHARE = 0x2000, + GMEM_NOTIFY = 0x4000, + GMEM_LOWER = GMEM_NOT_BANKED, + GMEM_VALID_FLAGS = 0x7F72, + GMEM_INVALID_HANDLE = 0x8000, + GHND = (GMEM_MOVEABLE | GMEM_ZEROINIT), + GPTR = (GMEM_FIXED | GMEM_ZEROINIT) + } + + internal enum ROP2DrawMode : int { + R2_BLACK = 1, + R2_NOTMERGEPEN = 2, + R2_MASKNOTPEN = 3, + R2_NOTCOPYPEN = 4, + R2_MASKPENNOT = 5, + R2_NOT = 6, + R2_XORPEN = 7, + R2_NOTMASKPEN = 8, + R2_MASKPEN = 9, + R2_NOTXORPEN = 10, + R2_NOP = 11, + R2_MERGENOTPEN = 12, + R2_COPYPEN = 13, + R2_MERGEPENNOT = 14, + R2_MERGEPEN = 15, + R2_WHITE = 16, + R2_LAST = 16 + } + + internal enum PenStyle : int { + PS_SOLID = 0, + PS_DASH = 1, + PS_DOT = 2, + PS_DASHDOT = 3, + PS_DASHDOTDOT = 4, + PS_NULL = 5, + PS_INSIDEFRAME = 6, + PS_USERSTYLE = 7, + PS_ALTERNATE = 8 + } + + internal enum PatBltRop : int { + PATCOPY = 0xf00021, + PATINVERT = 0x5a0049, + DSTINVERT = 0x550009, + BLACKNESS = 0x000042, + WHITENESS = 0xff0062, + } + + internal enum StockObject : int { + WHITE_BRUSH = 0, + LTGRAY_BRUSH = 1, + GRAY_BRUSH = 2, + DKGRAY_BRUSH = 3, + BLACK_BRUSH = 4, + NULL_BRUSH = 5, + HOLLOW_BRUSH = NULL_BRUSH, + WHITE_PEN = 6, + BLACK_PEN = 7, + NULL_PEN = 8, + OEM_FIXED_FONT = 10, + ANSI_FIXED_FONT = 11, + ANSI_VAR_FONT = 12, + SYSTEM_FONT = 13, + DEVICE_DEFAULT_FONT = 14, + DEFAULT_PALETTE = 15, + SYSTEM_FIXED_FONT = 16 + } + + internal enum HatchStyle : int { + HS_HORIZONTAL = 0, + HS_VERTICAL = 1, + HS_FDIAGONAL = 2, + HS_BDIAGONAL = 3, + HS_CROSS = 4, + HS_DIAGCROSS = 5 + } + + [Flags] + internal enum SndFlags : int { + SND_SYNC = 0x0000, + SND_ASYNC = 0x0001, + SND_NODEFAULT = 0x0002, + SND_MEMORY = 0x0004, + SND_LOOP = 0x0008, + SND_NOSTOP = 0x0010, + SND_NOWAIT = 0x00002000, + SND_ALIAS = 0x00010000, + SND_ALIAS_ID = 0x00110000, + SND_FILENAME = 0x00020000, + SND_RESOURCE = 0x00040004, + SND_PURGE = 0x0040, + SND_APPLICATION = 0x0080, + } + + [Flags] + internal enum LayeredWindowAttributes : int { + LWA_COLORKEY = 0x1, + LWA_ALPHA = 0x2, + } + + public enum ACLineStatus : byte { + Offline = 0, + Online = 1, + Unknown = 255 + } + + public enum BatteryFlag : byte { + High = 1, + Low = 2, + Critical = 4, + Charging = 8, + NoSystemBattery = 128, + Unknown = 255 + } + + [StructLayout (LayoutKind.Sequential)] + public class SYSTEMPOWERSTATUS { + public ACLineStatus _ACLineStatus; + public BatteryFlag _BatteryFlag; + public Byte _BatteryLifePercent; + public Byte _Reserved1; + public Int32 _BatteryLifeTime; + public Int32 _BatteryFullLifeTime; + } + #endregion + + #region Constructor & Destructor + private XplatUIWin32() { + // Handle singleton stuff first + ref_count=0; + + mouse_state = MouseButtons.None; + mouse_position = Point.Empty; + + grab_confined = false; + grab_area = Rectangle.Empty; + + message_queue = new Queue(); + + themes_enabled = false; + + wnd_proc = new WndProc(InternalWndProc); + + FosterParentLast = IntPtr.Zero; + + scroll_height = Win32GetSystemMetrics(SystemMetrics.SM_CYHSCROLL); + scroll_width = Win32GetSystemMetrics(SystemMetrics.SM_CXVSCROLL); + + timer_list = new Hashtable (); + registered_classes = new Hashtable (); + } + #endregion // Constructor & Destructor + + #region Private Support Methods + + private IntPtr GetFosterParent() + { + if (!IsWindow(FosterParentLast)) + { + FosterParentLast=Win32CreateWindow(WindowExStyles.WS_EX_TOOLWINDOW, "static", "Foster Parent Window", WindowStyles.WS_OVERLAPPEDWINDOW, 0, 0, 0, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); + + if (FosterParentLast==IntPtr.Zero) { + Win32MessageBox(IntPtr.Zero, "Could not create foster window, win32 error " + Win32GetLastError().ToString(), "Oops", 0); + } + } + return FosterParentLast; + } + + private string RegisterWindowClass (int classStyle) + { + string class_name; + + lock (registered_classes) { + class_name = (string)registered_classes[classStyle]; + + if (class_name != null) + return class_name; + + class_name = string.Format ("ShiftUI.Form.Thread={0}.GUID={1}", System.Threading.Thread.GetDomainID ().ToString (), Guid.NewGuid().ToString()); + + WNDCLASS wndClass; + + wndClass.style = classStyle; + wndClass.lpfnWndProc = wnd_proc; + wndClass.cbClsExtra = 0; + wndClass.cbWndExtra = 0; + wndClass.hbrBackground = (IntPtr)(GetSysColorIndex.COLOR_WINDOW + 1); + wndClass.hCursor = Win32LoadCursor (IntPtr.Zero, LoadCursorType.IDC_ARROW); + wndClass.hIcon = IntPtr.Zero; + wndClass.hInstance = IntPtr.Zero; + wndClass.lpszClassName = class_name; + wndClass.lpszMenuName = ""; + + bool result = Win32RegisterClass (ref wndClass); + + if (result == false) + Win32MessageBox (IntPtr.Zero, "Could not register the window class, win32 error " + Win32GetLastError ().ToString (), "Oops", 0); + + registered_classes[classStyle] = class_name; + } + + return class_name; + } + + private static bool RetrieveMessage(ref MSG msg) { + MSG message; + + if (message_queue.Count == 0) { + return false; + } + + message = (MSG)message_queue.Dequeue(); + msg = message; + + return true; + } + + private static bool StoreMessage(ref MSG msg) { + MSG message = new MSG(); + + message = msg; + message_queue.Enqueue(message); + + return true; + } + + internal static String AnsiToString(IntPtr ansi_data) { + return (string)Marshal.PtrToStringAnsi(ansi_data); + } + + internal static String UnicodeToString(IntPtr unicode_data) { + return (string)Marshal.PtrToStringUni(unicode_data); + } + + internal static Image DIBtoImage(IntPtr dib_data) { + BITMAPINFOHEADER bmi; + int ncolors; + int imagesize; + //int palettesize; + Bitmap bmp; + BitmapData bits; + ColorPalette pal; + int[] palette; + byte[] imagebits; + int bytesPerLine; + + bmi = (BITMAPINFOHEADER)Marshal.PtrToStructure(dib_data, typeof(BITMAPINFOHEADER)); + + ncolors = (int)bmi.biClrUsed; + if (ncolors == 0) { + if (bmi.biBitCount < 24) { + ncolors = (int)(1 << bmi.biBitCount); + } + } + //palettesize = ncolors * 4; + + imagesize = (int)bmi.biSizeImage; + if (imagesize == 0) { + imagesize = (int)(((((bmi.biWidth * bmi.biBitCount) + 31) & ~31) >> 3) * bmi.biHeight); + } + + switch(bmi.biBitCount) { + case 1: { // Monochrome + bmp = new Bitmap(bmi.biWidth, bmi.biHeight, PixelFormat.Format1bppIndexed); + palette = new int[2]; + break; + } + + case 4: { // 4bpp + bmp = new Bitmap(bmi.biWidth, bmi.biHeight, PixelFormat.Format4bppIndexed); + palette = new int[16]; + break; + } + + case 8: { // 8bpp + bmp = new Bitmap(bmi.biWidth, bmi.biHeight, PixelFormat.Format8bppIndexed); + palette = new int[256]; + break; + } + + case 24: + case 32: { // 32bpp + bmp = new Bitmap(bmi.biWidth, bmi.biHeight, PixelFormat.Format32bppArgb); + palette = new int[0]; + break; + } + + default: { + throw new Exception("Unexpected number of bits:" + bmi.biBitCount.ToString()); + } + } + + if (bmi.biBitCount < 24) { + pal = bmp.Palette; // Managed palette + Marshal.Copy((IntPtr)((int)dib_data + Marshal.SizeOf(typeof(BITMAPINFOHEADER))), palette, 0, palette.Length); + + for (int i = 0; i < ncolors; i++) { + pal.Entries[i] = Color.FromArgb(palette[i] | unchecked((int)0xff000000)); + } + bmp.Palette = pal; + } + + bytesPerLine = (int)((((bmi.biWidth * bmi.biBitCount) + 31) & ~31) >> 3); + bits = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.WriteOnly, bmp.PixelFormat); + + imagebits = new byte[bytesPerLine]; + + for (int y = 0; y < bmi.biHeight; y++) { + // Copy from source to managed + Marshal.Copy((IntPtr)((int)dib_data + Marshal.SizeOf(typeof(BITMAPINFOHEADER)) + palette.Length * 4 + bytesPerLine * y), imagebits, 0, bytesPerLine); + + // Copy from managed to dest + Marshal.Copy(imagebits, 0, (IntPtr)((int)bits.Scan0 + bits.Stride * (bmi.biHeight - 1 - y)), imagebits.Length); + } + + bmp.UnlockBits(bits); + + return bmp; + } + + internal static byte[] ImageToDIB(Image image) { + MemoryStream ms; + byte[] buffer; + byte[] retbuf; + + ms = new MemoryStream(); + image.Save(ms, ImageFormat.Bmp); + buffer = ms.GetBuffer(); + + // Filter out the file header + retbuf = new byte[buffer.Length]; + Array.Copy(buffer, 14, retbuf, 0, buffer.Length - 14); + return retbuf; + } + + internal static IntPtr DupGlobalMem(IntPtr mem) { + IntPtr dup; + IntPtr dup_ptr; + IntPtr mem_ptr; + uint len; + + len = Win32GlobalSize(mem); + mem_ptr = Win32GlobalLock(mem); + + dup = Win32GlobalAlloc(GAllocFlags.GMEM_MOVEABLE, (int)len); + dup_ptr = Win32GlobalLock(dup); + + Win32CopyMemory(dup_ptr, mem_ptr, (int)len); + + Win32GlobalUnlock(mem); + Win32GlobalUnlock(dup); + + return dup; + } + + private int GetSystemParametersInfoInt (SPIAction spi) + { + int value = 0; + + Win32SystemParametersInfo (spi, 0, ref value, 0); + + return value; + } + + private bool GetSystemParametersInfoBool (SPIAction spi) + { + bool value = false; + + Win32SystemParametersInfo (spi, 0, ref value, 0); + + return value; + } + #endregion // Private Support Methods + + #region Static Properties + internal override int ActiveWindowTrackingDelay { + get { return GetSystemParametersInfoInt (SPIAction.SPI_GETACTIVEWNDTRKTIMEOUT); } + } + + internal override int CaretWidth { + get { + // Supported on 2k, XP, 2k3 + + if (Environment.OSVersion.Version.Major < 5) + throw new NotSupportedException (); + + return GetSystemParametersInfoInt (SPIAction.SPI_GETCARETWIDTH); + } + } + + internal override int FontSmoothingContrast { + get { + // Supported on XP, 2k3 + + if (Environment.OSVersion.Version.Major < 5 || (Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor == 0)) + throw new NotSupportedException (); + + return GetSystemParametersInfoInt (SPIAction.SPI_GETFONTSMOOTHINGCONTRAST); + } + } + + internal override int FontSmoothingType { + get { + // Supported on XP, 2k3 + + if (Environment.OSVersion.Version.Major < 5 || (Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor == 0)) + throw new NotSupportedException (); + + return GetSystemParametersInfoInt (SPIAction.SPI_GETFONTSMOOTHINGTYPE); + } + } + + internal override int HorizontalResizeBorderThickness { + get { return Win32GetSystemMetrics (SystemMetrics.SM_CXSIZEFRAME); } + } + + internal override bool IsActiveWindowTrackingEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETACTIVEWINDOWTRACKING); } + } + + internal override bool IsComboBoxAnimationEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETCOMBOBOXANIMATION); } + } + + internal override bool IsDropShadowEnabled { + get { + // Supported on XP, 2k3 + + if (Environment.OSVersion.Version.Major < 5 || (Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor == 0)) + throw new NotSupportedException (); + + return GetSystemParametersInfoBool (SPIAction.SPI_GETDROPSHADOW); + } + } + + internal override bool IsFontSmoothingEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETFONTSMOOTHING); } + } + + internal override bool IsHotTrackingEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETHOTTRACKING); } + } + + internal override bool IsIconTitleWrappingEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETICONTITLEWRAP); } + } + + internal override bool IsKeyboardPreferred { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETKEYBOARDPREF); } + } + + internal override bool IsListBoxSmoothScrollingEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETLISTBOXSMOOTHSCROLLING); } + } + + internal override bool IsMenuAnimationEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETMENUANIMATION); } + } + + internal override bool IsMenuFadeEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETMENUFADE); } + } + + internal override bool IsMinimizeRestoreAnimationEnabled { + get { + ANIMATIONINFO ai = new ANIMATIONINFO (); + ai.cbSize = (uint)Marshal.SizeOf (ai); + + Win32SystemParametersInfo (SPIAction.SPI_GETANIMATION, 0, ref ai, 0); + return ai.iMinAnimate == 0 ? false : true; + } + } + + internal override bool IsSelectionFadeEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETSELECTIONFADE); } + } + + internal override bool IsSnapToDefaultEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETSNAPTODEFBUTTON); } + } + + internal override bool IsTitleBarGradientEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETGRADIENTCAPTIONS); } + } + + internal override bool IsToolTipAnimationEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETTOOLTIPANIMATION); } + } + + internal override Size MenuBarButtonSize { + get { + return new Size (Win32GetSystemMetrics (SystemMetrics.SM_CXMENUSIZE), + Win32GetSystemMetrics (SystemMetrics.SM_CYMENUSIZE)); + } + } + + public override Size MenuButtonSize { + get { + return new Size ( + Win32GetSystemMetrics (SystemMetrics.SM_CXMENUSIZE), + Win32GetSystemMetrics (SystemMetrics.SM_CYMENUSIZE)); + } + } + + internal override int MenuShowDelay { + get { return GetSystemParametersInfoInt (SPIAction.SPI_GETMENUSHOWDELAY); } + } + + internal override int MouseSpeed { + get { return GetSystemParametersInfoInt (SPIAction.SPI_GETMOUSESPEED); } + } + + internal override LeftRightAlignment PopupMenuAlignment { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETMENUDROPALIGNMENT) == true ? LeftRightAlignment.Left : LeftRightAlignment.Right; } + } + + internal override PowerStatus PowerStatus { + get { + SYSTEMPOWERSTATUS p = new SYSTEMPOWERSTATUS (); + + Win32GetSystemPowerStatus (p); + + PowerStatus ps = new PowerStatus ((BatteryChargeStatus)p._BatteryFlag, p._BatteryFullLifeTime, (float)p._BatteryLifePercent / 255f, p._BatteryLifeTime, (PowerLineStatus)p._ACLineStatus); + + return ps; + } + } + + internal override int SizingBorderWidth { + get { return Win32GetSystemMetrics (SystemMetrics.SM_CXSIZEFRAME); } + } + + internal override Size SmallCaptionButtonSize { + get { + return new Size (Win32GetSystemMetrics (SystemMetrics.SM_CXSMSIZE), + Win32GetSystemMetrics (SystemMetrics.SM_CYSMSIZE)); + } + } + + internal override bool UIEffectsEnabled { + get { return GetSystemParametersInfoBool (SPIAction.SPI_GETUIEFFECTS); } + } + + internal override int VerticalResizeBorderThickness { + get { return Win32GetSystemMetrics (SystemMetrics.SM_CYSIZEFRAME); } + } + + internal override void RaiseIdle (EventArgs e) + { + if (Idle != null) + Idle (this, e); + } + + internal override Keys ModifierKeys { + get { + short state; + Keys key_state; + + key_state = Keys.None; + + state = Win32GetKeyState(VirtualKeys.VK_SHIFT); + if ((state & 0x8000) != 0) { + key_state |= Keys.Shift; + } + state = Win32GetKeyState(VirtualKeys.VK_CONTROL); + if ((state & 0x8000) != 0) { + key_state |= Keys.Widget; + } + + state = Win32GetKeyState(VirtualKeys.VK_MENU); + if ((state & 0x8000) != 0) { + key_state |= Keys.Alt; + } + + return key_state; + } + } + + internal override MouseButtons MouseButtons { + get { + return mouse_state; + } + } + + internal override Point MousePosition { + get { + return mouse_position; + } + } + + internal override Size MouseHoverSize { + get { + int width = 4; + int height = 4; + + Win32SystemParametersInfo(SPIAction.SPI_GETMOUSEHOVERWIDTH, 0, ref width, 0); + Win32SystemParametersInfo(SPIAction.SPI_GETMOUSEHOVERWIDTH, 0, ref height, 0); + return new Size(width, height); + } + } + + internal override int MouseHoverTime { + get { + int time = 500; + + Win32SystemParametersInfo(SPIAction.SPI_GETMOUSEHOVERTIME, 0, ref time, 0); + return time; + } + } + + internal override int MouseWheelScrollDelta { + get { + int delta = 120; + Win32SystemParametersInfo(SPIAction.SPI_GETWHEELSCROLLLINES, 0, ref delta, 0); + return delta; + } + } + + internal override int HorizontalScrollBarHeight { + get { + return scroll_height; + } + } + + internal override bool UserClipWontExposeParent { + get { + return false; + } + } + + + internal override int VerticalScrollBarWidth { + get { + return scroll_width; + } + } + + internal override int MenuHeight { + get { + return Win32GetSystemMetrics(SystemMetrics.SM_CYMENU); + } + } + + internal override Size Border3DSize { + get { + return new Size (Win32GetSystemMetrics (SystemMetrics.SM_CXEDGE), + Win32GetSystemMetrics (SystemMetrics.SM_CYEDGE)); + } + } + + internal override Size BorderSize { + get { + return new Size (Win32GetSystemMetrics (SystemMetrics.SM_CXBORDER), + Win32GetSystemMetrics (SystemMetrics.SM_CYBORDER)); + } + } + + internal override bool DropTarget { + get { + return false; + } + + set { + if (value) { + //throw new NotImplementedException("Need to figure out D'n'D for Win32"); + } + } + } + + internal override Size CaptionButtonSize { + get { + return new Size (Win32GetSystemMetrics (SystemMetrics.SM_CXSIZE), + Win32GetSystemMetrics (SystemMetrics.SM_CYSIZE)); + } + } + + internal override int CaptionHeight { + get { + return Win32GetSystemMetrics(SystemMetrics.SM_CYCAPTION); + } + } + + internal override Size CursorSize { + get { + return new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR), Win32GetSystemMetrics(SystemMetrics.SM_CYCURSOR)); + } + } + + internal override bool DragFullWindows { + get { + int full = 0; + Win32SystemParametersInfo (SPIAction.SPI_GETDRAGFULLWINDOWS, 0, ref full, 0); + return (full != 0); + } + } + + internal override Size DragSize { + get { + return new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXDRAG), Win32GetSystemMetrics(SystemMetrics.SM_CYDRAG)); + } + } + + internal override Size DoubleClickSize { + get { + return new Size (Win32GetSystemMetrics (SystemMetrics.SM_CXDOUBLECLK), + Win32GetSystemMetrics (SystemMetrics.SM_CYDOUBLECLK)); + } + } + + internal override int DoubleClickTime { + get { + return Win32GetDoubleClickTime (); + } + } + + internal override Size FixedFrameBorderSize { + get { + return new Size (Win32GetSystemMetrics (SystemMetrics.SM_CXFIXEDFRAME), + Win32GetSystemMetrics (SystemMetrics.SM_CYFIXEDFRAME)); + } + } + + internal override Size FrameBorderSize { + get { + return new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXFRAME), Win32GetSystemMetrics(SystemMetrics.SM_CYFRAME)); + } + } + + internal override Size IconSize { + get { + return new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXICON), Win32GetSystemMetrics(SystemMetrics.SM_CYICON)); + } + } + + internal override Size MaxWindowTrackSize { + get { + return new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXMAXTRACK), Win32GetSystemMetrics(SystemMetrics.SM_CYMAXTRACK)); + } + } + + internal override bool MenuAccessKeysUnderlined { + get { + int underlined = 0; + Win32SystemParametersInfo (SPIAction.SPI_GETKEYBOARDCUES, 0, ref underlined, 0); + return (underlined != 0); + } + } + + internal override Size MinimizedWindowSize { + get { + return new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXMINIMIZED), Win32GetSystemMetrics(SystemMetrics.SM_CYMINIMIZED)); + } + } + + internal override Size MinimizedWindowSpacingSize { + get { + return new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXMINSPACING), Win32GetSystemMetrics(SystemMetrics.SM_CYMINSPACING)); + } + } + + internal override Size MinimumWindowSize { + get { + return new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXMIN), Win32GetSystemMetrics(SystemMetrics.SM_CYMIN)); + } + } + + internal override Size MinWindowTrackSize { + get { + return new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXMINTRACK), Win32GetSystemMetrics(SystemMetrics.SM_CYMINTRACK)); + } + } + + internal override Size SmallIconSize { + get { + return new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXSMICON), Win32GetSystemMetrics(SystemMetrics.SM_CYSMICON)); + } + } + + internal override int MouseButtonCount { + get { + return Win32GetSystemMetrics(SystemMetrics.SM_CMOUSEBUTTONS); + } + } + + internal override bool MouseButtonsSwapped { + get { + return Win32GetSystemMetrics(SystemMetrics.SM_SWAPBUTTON) != 0; + } + } + + internal override bool MouseWheelPresent { + get { + return Win32GetSystemMetrics(SystemMetrics.SM_MOUSEWHEELPRESENT) != 0; + } + } + + internal override Rectangle VirtualScreen { + get { + return new Rectangle( Win32GetSystemMetrics(SystemMetrics.SM_XVIRTUALSCREEN), Win32GetSystemMetrics(SystemMetrics.SM_YVIRTUALSCREEN), + Win32GetSystemMetrics(SystemMetrics.SM_CXVIRTUALSCREEN), Win32GetSystemMetrics(SystemMetrics.SM_CYVIRTUALSCREEN)); + } + } + + internal override Rectangle WorkingArea { + get { + RECT rect; + + rect = new RECT(); + Win32SystemParametersInfo(SPIAction.SPI_GETWORKAREA, 0, ref rect, 0); + return new Rectangle(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top); + //return new Rectangle(0, 0, Win32GetSystemMetrics(SystemMetrics.SM.SM_CXSCREEN), Win32GetSystemMetrics(SystemMetrics.SM_CYSCREEN)); + } + } + + [MonoTODO] + internal override Screen[] AllScreens { + get { + // To support multiples, we need to use GetMonitorInfo API on Win32 + return null; + } + } + + internal override bool ThemesEnabled { + get { + return XplatUIWin32.themes_enabled; + } + } + + internal override bool RequiresPositiveClientAreaSize { + get { + return false; + } + } + + public override int ToolWindowCaptionHeight { + get { + return Win32GetSystemMetrics (SystemMetrics.SM_CYSMCAPTION); + } + } + + public override Size ToolWindowCaptionButtonSize { + get { + return new Size ( + Win32GetSystemMetrics (SystemMetrics.SM_CXSMSIZE), + Win32GetSystemMetrics (SystemMetrics.SM_CYSMSIZE)); + } + } + #endregion // Static Properties + + #region Singleton Specific Code + public static XplatUIWin32 GetInstance() { + if (instance==null) { + instance=new XplatUIWin32(); + } + ref_count++; + return instance; + } + + public int Reference { + get { + return ref_count; + } + } + #endregion + + #region Public Static Methods + internal override IntPtr InitializeDriver() { + return IntPtr.Zero; + } + + internal override void ShutdownDriver(IntPtr token) { + Console.WriteLine("XplatUIWin32 ShutdownDriver called"); + } + + + internal void Version() { + Console.WriteLine("Xplat version $revision: $"); + } + + string GetSoundAlias (AlertType alert) + { + switch (alert) { + case AlertType.Error: + return "SystemHand"; + case AlertType.Question: + return "SystemQuestion"; + case AlertType.Warning: + return "SystemExclamation"; + case AlertType.Information: + return "SystemAsterisk"; + default: + return "SystemDefault"; + } + } + + internal override void AudibleAlert(AlertType alert) { + Win32PlaySound(GetSoundAlias (alert), IntPtr.Zero, SndFlags.SND_ALIAS_ID | SndFlags.SND_ASYNC | SndFlags.SND_NOSTOP | SndFlags.SND_NOWAIT); + } + + internal override void BeginMoveResize (IntPtr handle) { + } + + internal override void GetDisplaySize(out Size size) { + RECT rect; + + Win32GetWindowRect(Win32GetDesktopWindow(), out rect); + + size = new Size(rect.right - rect.left, rect.bottom - rect.top); + } + + internal override void EnableThemes() { + themes_enabled=true; + } + + internal override IntPtr CreateWindow(CreateParams cp) { + IntPtr WindowHandle; + IntPtr ParentHandle; + Hwnd hwnd; + + hwnd = new Hwnd(); + + ParentHandle=cp.Parent; + + if ((ParentHandle==IntPtr.Zero) && (cp.Style & (int)(WindowStyles.WS_CHILD))!=0) { + // We need to use our foster parent window until this poor child gets it's parent assigned + ParentHandle = GetFosterParent(); + } + + if ( ((cp.Style & (int)(WindowStyles.WS_CHILD | WindowStyles.WS_POPUP))==0) && ((cp.ExStyle & (int)WindowExStyles.WS_EX_APPWINDOW) == 0)) { + // If we want to be hidden from the taskbar we need to be 'owned' by + // something not on the taskbar. FosterParent is just that + ParentHandle = GetFosterParent(); + } + + Point location; + if (cp.HasWindowManager) { + location = Hwnd.GetNextStackedFormLocation (cp, Hwnd.ObjectFromHandle (cp.Parent)); + } else { + location = new Point (cp.X, cp.Y); + } + + string class_name = RegisterWindowClass (cp.ClassStyle); + HwndCreating = hwnd; + + // We cannot actually send the WS_EX_MDICHILD flag to Windows because we + // are faking MDI, not uses Windows' version. + if ((cp.WindowExStyle & WindowExStyles.WS_EX_MDICHILD) == WindowExStyles.WS_EX_MDICHILD) + cp.WindowExStyle ^= WindowExStyles.WS_EX_MDICHILD; + + WindowHandle = Win32CreateWindow (cp.WindowExStyle, class_name, cp.Caption, cp.WindowStyle, location.X, location.Y, cp.Width, cp.Height, ParentHandle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); + + HwndCreating = null; + + if (WindowHandle==IntPtr.Zero) { + int error = Marshal.GetLastWin32Error (); + + Win32MessageBox(IntPtr.Zero, "Error : " + error.ToString(), "Failed to create window, class '"+cp.ClassName+"'", 0); + } + + hwnd.ClientWindow = WindowHandle; + hwnd.Mapped = true; + Win32SetWindowLong(WindowHandle, WindowLong.GWL_USERDATA, (uint)ThemeEngine.Current.DefaultControlBackColor.ToArgb()); + + return WindowHandle; + } + + internal override IntPtr CreateWindow(IntPtr Parent, int X, int Y, int Width, int Height) { + CreateParams create_params = new CreateParams(); + + create_params.Caption = ""; + create_params.X = X; + create_params.Y = Y; + create_params.Width = Width; + create_params.Height = Height; + + create_params.ClassName=XplatUI.GetDefaultClassName (GetType ()); + create_params.ClassStyle = 0; + create_params.ExStyle=0; + create_params.Parent=IntPtr.Zero; + create_params.Param=0; + + return CreateWindow(create_params); + } + + internal override void DestroyWindow(IntPtr handle) { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + Win32DestroyWindow(handle); + hwnd.Dispose(); + return; + } + + internal override void SetWindowMinMax(IntPtr handle, Rectangle maximized, Size min, Size max) { + // We do nothing, Form has to handle WM_GETMINMAXINFO + } + + + internal override FormWindowState GetWindowState(IntPtr handle) { + uint style; + + style = Win32GetWindowLong(handle, WindowLong.GWL_STYLE); + if ((style & (uint)WindowStyles.WS_MAXIMIZE) != 0) { + return FormWindowState.Maximized; + } else if ((style & (uint)WindowStyles.WS_MINIMIZE) != 0) { + return FormWindowState.Minimized; + } + return FormWindowState.Normal; + } + + internal override void SetWindowState(IntPtr hwnd, FormWindowState state) { + switch(state) { + case FormWindowState.Normal: { + Win32ShowWindow(hwnd, WindowPlacementFlags.SW_RESTORE); + return; + } + + case FormWindowState.Minimized: { + Win32ShowWindow(hwnd, WindowPlacementFlags.SW_MINIMIZE); + return; + } + + case FormWindowState.Maximized: { + Win32ShowWindow(hwnd, WindowPlacementFlags.SW_MAXIMIZE); + return; + } + } + } + + internal override void SetWindowStyle(IntPtr handle, CreateParams cp) { + + Win32SetWindowLong(handle, WindowLong.GWL_STYLE, (uint)cp.Style); + Win32SetWindowLong(handle, WindowLong.GWL_EXSTYLE, (uint)cp.ExStyle); + + // From MSDN: + // Certain window data is cached, so changes you make using SetWindowLong + // will not take effect until you call the SetWindowPos function. Specifically, + // if you change any of the frame styles, you must call SetWindowPos with + // the SWP_FRAMECHANGED flag for the cache to be updated properly. + if (cp.control is Form) + XplatUI.RequestNCRecalc (handle); + } + + internal override double GetWindowTransparency(IntPtr handle) + { + LayeredWindowAttributes lwa; + COLORREF clrRef; + byte alpha; + + if (0 == Win32GetLayeredWindowAttributes (handle, out clrRef, out alpha, out lwa)) + return 1.0; + + return ((double)alpha) / 255.0; + } + + internal override void SetWindowTransparency(IntPtr handle, double transparency, Color key) { + LayeredWindowAttributes lwa = LayeredWindowAttributes.LWA_ALPHA; + byte opacity = (byte)(transparency*255); + COLORREF clrRef = new COLORREF(); + if (key != Color.Empty) { + clrRef.R = key.R; + clrRef.G = key.G; + clrRef.B = key.B; + lwa = (LayeredWindowAttributes)( (int)lwa | (int)LayeredWindowAttributes.LWA_COLORKEY ); + } + RECT rc; + rc.right = 1000; + rc.bottom = 1000; + Win32SetLayeredWindowAttributes(handle, clrRef, opacity, lwa); + } + + TransparencySupport support; + bool queried_transparency_support; + internal override TransparencySupport SupportsTransparency() { + if (queried_transparency_support) + return support; + + bool flag; + support = TransparencySupport.None; + + flag = true; + try { + Win32SetLayeredWindowAttributes (IntPtr.Zero, new COLORREF (), 255, LayeredWindowAttributes.LWA_ALPHA); + } + catch (EntryPointNotFoundException) { flag = false; } + catch { /* swallow everything else */ } + + if (flag) support |= TransparencySupport.Set; + + flag = true; + try { + LayeredWindowAttributes lwa; + COLORREF clrRef; + byte alpha; + + Win32GetLayeredWindowAttributes (IntPtr.Zero, out clrRef, out alpha, out lwa); + } + catch (EntryPointNotFoundException) { flag = false; } + catch { /* swallow everything else */ } + + if (flag) support |= TransparencySupport.Get; + + queried_transparency_support = true; + return support; + } + + internal override void UpdateWindow(IntPtr handle) { + Win32UpdateWindow(handle); + } + + internal override PaintEventArgs PaintEventStart(ref Message msg, IntPtr handle, bool client) { + IntPtr hdc; + PAINTSTRUCT ps; + PaintEventArgs paint_event; + RECT rect; + Rectangle clip_rect; + Hwnd hwnd; + + clip_rect = new Rectangle(); + rect = new RECT(); + ps = new PAINTSTRUCT(); + + hwnd = Hwnd.ObjectFromHandle(msg.HWnd); + + if (client) { + if (Win32GetUpdateRect(msg.HWnd, ref rect, false)) { + if (handle != msg.HWnd) { + // We need to validate the window where the paint message + // was generated, otherwise we'll never stop getting paint + // messages. + Win32GetClientRect (msg.HWnd, out rect); + Win32ValidateRect (msg.HWnd, ref rect); + hdc = Win32GetDC (handle); + } else { + hdc = Win32BeginPaint (handle, ref ps); + rect = ps.rcPaint; + } + } else { + hdc = Win32GetDC(handle); + } + clip_rect = rect.ToRectangle (); + } else { + hdc = Win32GetWindowDC (handle); + + // HACK this in for now + Win32GetWindowRect (handle, out rect); + clip_rect = new Rectangle (0, 0, rect.Width, rect.Height); + } + + // If we called BeginPaint, store the PAINTSTRUCT, + // otherwise store hdc, so that PaintEventEnd can know + // whether to call EndPaint or ReleaseDC. + if (ps.hdc != IntPtr.Zero) { + hwnd.drawing_stack.Push (ps); + } else { + hwnd.drawing_stack.Push (hdc); + } + + Graphics dc = Graphics.FromHdc(hdc); + hwnd.drawing_stack.Push (dc); + + paint_event = new PaintEventArgs(dc, clip_rect); + + return paint_event; + } + + internal override void PaintEventEnd(ref Message m, IntPtr handle, bool client) { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(m.HWnd); + + Graphics dc = (Graphics)hwnd.drawing_stack.Pop(); + dc.Dispose (); + + object o = hwnd.drawing_stack.Pop(); + if (o is IntPtr) { + IntPtr hdc = (IntPtr) o; + Win32ReleaseDC (handle, hdc); + } else if (o is PAINTSTRUCT) { + PAINTSTRUCT ps = (PAINTSTRUCT) o; + Win32EndPaint (handle, ref ps); + } + } + + + internal override void SetWindowPos(IntPtr handle, int x, int y, int width, int height) { + Win32MoveWindow(handle, x, y, width, height, true); + return; + } + + internal override void GetWindowPos(IntPtr handle, bool is_toplevel, out int x, out int y, out int width, out int height, out int client_width, out int client_height) { + IntPtr parent; + RECT rect; + POINT pt; + + Win32GetWindowRect(handle, out rect); + width = rect.right - rect.left; + height = rect.bottom - rect.top; + + pt.x=rect.left; + pt.y=rect.top; + + parent = Win32GetAncestor (handle, AncestorType.GA_PARENT); + if (parent != IntPtr.Zero && parent != Win32GetDesktopWindow ()) + Win32ScreenToClient(parent, ref pt); + + x = pt.x; + y = pt.y; + + Win32GetClientRect(handle, out rect); + client_width = rect.right - rect.left; + client_height = rect.bottom - rect.top; + return; + } + + internal override void Activate(IntPtr handle) { + Win32SetActiveWindow(handle); + // delayed timer enabled + lock (timer_list) { + foreach (Timer t in timer_list.Values) { + if (t.Enabled && t.window == IntPtr.Zero) { + t.window = handle; + int id = t.GetHashCode (); + Win32SetTimer(handle, id, (uint)t.Interval, IntPtr.Zero); + } + } + } + } + + internal override void Invalidate(IntPtr handle, Rectangle rc, bool clear) { + RECT rect; + + rect.left=rc.Left; + rect.top=rc.Top; + rect.right=rc.Right; + rect.bottom=rc.Bottom; + Win32InvalidateRect(handle, ref rect, clear); + } + + + internal override void InvalidateNC (IntPtr handle) + { + // found this gem at + // http://www.dotnet247.com/247reference/msgs/58/292037.aspx + Win32SetWindowPos(handle, IntPtr.Zero, + 0, 0, 0, 0, + SetWindowPosFlags.SWP_NOMOVE | + SetWindowPosFlags.SWP_NOSIZE | + SetWindowPosFlags.SWP_NOZORDER | + SetWindowPosFlags.SWP_NOACTIVATE | + SetWindowPosFlags.SWP_DRAWFRAME); + } + + private IntPtr InternalWndProc (IntPtr hWnd, Msg msg, IntPtr wParam, IntPtr lParam) + { + if (HwndCreating != null && HwndCreating.ClientWindow == IntPtr.Zero) + HwndCreating.ClientWindow = hWnd; + return NativeWindow.WndProc (hWnd, msg, wParam, lParam); + } + + internal override IntPtr DefWndProc(ref Message msg) { + msg.Result=Win32DefWindowProc(msg.HWnd, (Msg)msg.Msg, msg.WParam, msg.LParam); + return msg.Result; + } + + internal override void HandleException(Exception e) { + StackTrace st = new StackTrace(e); + Win32MessageBox(IntPtr.Zero, e.Message+st.ToString(), "Exception", 0); + Console.WriteLine("{0}{1}", e.Message, st.ToString()); + } + + internal override void DoEvents() { + MSG msg = new MSG(); + + while (GetMessage(ref msg, IntPtr.Zero, 0, 0, false)) { + Message m = Message.Create (msg.hwnd, (int)msg.message, msg.wParam, msg.lParam); + + if (Application.FilterMessage (ref m)) + continue; + + XplatUI.TranslateMessage(ref msg); + XplatUI.DispatchMessage(ref msg); + } + } + + internal override bool PeekMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags) { + return Win32PeekMessage(ref msg, hWnd, wFilterMin, wFilterMax, flags); + } + + internal override void PostQuitMessage(int exitCode) { + Win32PostQuitMessage(exitCode); + } + + internal override void RequestAdditionalWM_NCMessages(IntPtr hwnd, bool hover, bool leave) + { + if (wm_nc_registered == null) + wm_nc_registered = new Hashtable (); + + TMEFlags flags = TMEFlags.TME_NONCLIENT; + if (hover) + flags |= TMEFlags.TME_HOVER; + if (leave) + flags |= TMEFlags.TME_LEAVE; + + if (flags == TMEFlags.TME_NONCLIENT) { + if (wm_nc_registered.Contains (hwnd)) { + wm_nc_registered.Remove (hwnd); + } + } else { + if (!wm_nc_registered.Contains (hwnd)) { + wm_nc_registered.Add (hwnd, flags); + } else { + wm_nc_registered [hwnd] = flags; + } + } + } + + internal override void RequestNCRecalc(IntPtr handle) { + Win32SetWindowPos(handle, IntPtr.Zero, 0, 0, 0, 0, SetWindowPosFlags.SWP_FRAMECHANGED | SetWindowPosFlags.SWP_NOOWNERZORDER | SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE); + } + + internal override void ResetMouseHover(IntPtr handle) { + TRACKMOUSEEVENT tme; + + tme = new TRACKMOUSEEVENT(); + tme.size = Marshal.SizeOf(tme); + tme.hWnd = handle; + tme.dwFlags = TMEFlags.TME_LEAVE | TMEFlags.TME_HOVER; + Win32TrackMouseEvent(ref tme); + } + + + internal override bool GetMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax) { + return GetMessage(ref msg, hWnd, wFilterMin, wFilterMax, true); + } + + private bool GetMessage(ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, bool blocking) { + bool result; + + msg.refobject = 0; + if (RetrieveMessage(ref msg)) { + return true; + } + + if (blocking) { + result = Win32GetMessage(ref msg, hWnd, wFilterMin, wFilterMax); + } else { + result = Win32PeekMessage(ref msg, hWnd, wFilterMin, wFilterMax, (uint)PeekMessageFlags.PM_REMOVE); + if (!result) { + return false; + } + } + + // We need to fake WM_MOUSE_ENTER + switch (msg.message) { + case Msg.WM_LBUTTONDOWN: { + mouse_state |= MouseButtons.Left; + break; + } + + case Msg.WM_MBUTTONDOWN: { + mouse_state |= MouseButtons.Middle; + break; + } + + case Msg.WM_RBUTTONDOWN: { + mouse_state |= MouseButtons.Right; + break; + } + + case Msg.WM_LBUTTONUP: { + mouse_state &= ~MouseButtons.Left; + break; + } + + case Msg.WM_MBUTTONUP: { + mouse_state &= ~MouseButtons.Middle; + break; + } + + case Msg.WM_RBUTTONUP: { + mouse_state &= ~MouseButtons.Right; + break; + } + + case Msg.WM_ASYNC_MESSAGE: { + XplatUIDriverSupport.ExecuteClientMessage((GCHandle)msg.lParam); + break; + } + + case Msg.WM_MOUSEMOVE: { + if (msg.hwnd != prev_mouse_hwnd) { + TRACKMOUSEEVENT tme; + + mouse_state = Widget.FromParamToMouseButtons ((int)msg.lParam.ToInt32()); + + // The current message will be sent out next time around + StoreMessage(ref msg); + + // This is the message we want to send at this point + msg.message = Msg.WM_MOUSE_ENTER; + + prev_mouse_hwnd = msg.hwnd; + + tme = new TRACKMOUSEEVENT(); + tme.size = Marshal.SizeOf(tme); + tme.hWnd = msg.hwnd; + tme.dwFlags = TMEFlags.TME_LEAVE | TMEFlags.TME_HOVER; + Win32TrackMouseEvent(ref tme); + return result; + } + break; + } + + case Msg.WM_NCMOUSEMOVE: { + if (wm_nc_registered == null || !wm_nc_registered.Contains (msg.hwnd)) + break; + + mouse_state = Widget.FromParamToMouseButtons ((int)msg.lParam.ToInt32 ()); + + TRACKMOUSEEVENT tme; + + tme = new TRACKMOUSEEVENT (); + tme.size = Marshal.SizeOf(tme); + tme.hWnd = msg.hwnd; + tme.dwFlags = (TMEFlags)wm_nc_registered[msg.hwnd]; + Win32TrackMouseEvent (ref tme); + return result; + } + + case Msg.WM_DROPFILES: { + return Win32DnD.HandleWMDropFiles(ref msg); + } + + case Msg.WM_MOUSELEAVE: { + prev_mouse_hwnd = IntPtr.Zero; + break; + } + + case Msg.WM_TIMER: { + Timer timer=(Timer)timer_list[(int)msg.wParam]; + + if (timer != null) { + timer.FireTick(); + } + break; + } + } + + return result; + } + + internal override bool TranslateMessage(ref MSG msg) { + return Win32TranslateMessage(ref msg); + } + + internal override IntPtr DispatchMessage(ref MSG msg) { + return Win32DispatchMessage(ref msg); + } + + internal override bool SetZOrder(IntPtr hWnd, IntPtr AfterhWnd, bool Top, bool Bottom) { + if (Top) { + Win32SetWindowPos(hWnd, SetWindowPosZOrder.HWND_TOP, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE); + return true; + } else if (!Bottom) { + Win32SetWindowPos(hWnd, AfterhWnd, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE); + } else { + Win32SetWindowPos(hWnd, (IntPtr)SetWindowPosZOrder.HWND_BOTTOM, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE); + return true; + } + return false; + } + + internal override bool SetTopmost(IntPtr hWnd, bool Enabled) { + if (Enabled) { + Win32SetWindowPos(hWnd, SetWindowPosZOrder.HWND_TOPMOST, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOACTIVATE); + return true; + } else { + Win32SetWindowPos(hWnd, SetWindowPosZOrder.HWND_NOTOPMOST, 0, 0, 0, 0, SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOACTIVATE); + return true; + } + } + + internal override bool SetOwner(IntPtr hWnd, IntPtr hWndOwner) { + Win32SetWindowLong(hWnd, WindowLong.GWL_HWNDPARENT, (uint) hWndOwner); + return true; + } + + internal override bool Text(IntPtr handle, string text) { + Win32SetWindowText(handle, text); + return true; + } + + internal override bool GetText(IntPtr handle, out string text) { + StringBuilder sb; + + sb = new StringBuilder(256); + Win32GetWindowText(handle, sb, sb.Capacity); + text = sb.ToString(); + return true; + } + + internal override bool SetVisible (IntPtr handle, bool visible, bool activate) + { + if (visible) { + Widget c = Widget.FromHandle (handle); + if (c is Form) { + Form f; + + f = (Form)Widget.FromHandle (handle); + WindowPlacementFlags flags = WindowPlacementFlags.SW_SHOWNORMAL; + switch (f.WindowState) { + case FormWindowState.Normal: flags = WindowPlacementFlags.SW_SHOWNORMAL; break; + case FormWindowState.Minimized: flags = WindowPlacementFlags.SW_MINIMIZE; break; + case FormWindowState.Maximized: flags = WindowPlacementFlags.SW_MAXIMIZE; break; + } + + if (!f.ActivateOnShow) + flags = WindowPlacementFlags.SW_SHOWNOACTIVATE; + + Win32ShowWindow (handle, flags); + } + else { + if (c.ActivateOnShow) + Win32ShowWindow (handle, WindowPlacementFlags.SW_SHOWNORMAL); + else + Win32ShowWindow (handle, WindowPlacementFlags.SW_SHOWNOACTIVATE); + } + } + else { + Win32ShowWindow (handle, WindowPlacementFlags.SW_HIDE); + } + return true; + } + + internal override bool IsEnabled(IntPtr handle) { + return IsWindowEnabled (handle); + } + + internal override bool IsKeyLocked (VirtualKeys key) + { + return (Win32GetKeyState (key) & 1) == 1; + } + + internal override bool IsVisible(IntPtr handle) { + return IsWindowVisible (handle); + } + + internal override IntPtr SetParent(IntPtr handle, IntPtr parent) { + Widget c = Widget.FromHandle (handle); + if (parent == IntPtr.Zero) { + if (!(c is Form)) { + Win32ShowWindow(handle, WindowPlacementFlags.SW_HIDE); + } + } else { + if (!(c is Form)) { + SetVisible (handle, c.is_visible, true); + } + } + // The Win32SetParent is lame, it can very well move the window + // ref: http://groups.google.com/group/microsoft.public.vb.winapi/browse_thread/thread/1b82ccc54231ecee/afa82835bfc0422a%23afa82835bfc0422a + // Here we save the position before changing the parent, and if it has changed afterwards restore it. + // Another possibility would be to intercept WM_WINDOWPOSCHANGING and restore the coords there, but this would require plumbing in weird places + // (either inside Widget or add handling to InternalWndProc) + // We also need to remove WS_CHILD if making the window parent-less, and add it if we're parenting it. + RECT rect, rect2; + IntPtr result; + WindowStyles style, new_style; + + Win32GetWindowRect (handle, out rect); + style = (WindowStyles) Win32GetWindowLong (handle, WindowLong.GWL_STYLE); + + if (parent == IntPtr.Zero) { + new_style = style & ~WindowStyles.WS_CHILD; + result = Win32SetParent (handle, GetFosterParent()); + } else { + new_style = style | WindowStyles.WS_CHILD; + result = Win32SetParent (handle, parent); + } + if (style != new_style && c is Form) { + Win32SetWindowLong (handle, WindowLong.GWL_STYLE, (uint) new_style); + } + Win32GetWindowRect (handle, out rect2); + if (rect.top != rect2.top && rect.left != rect2.left && c is Form) { + Win32SetWindowPos (handle, IntPtr.Zero, rect.top, rect.left, rect.Width, rect.Height, SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOREDRAW | SetWindowPosFlags.SWP_NOOWNERZORDER | SetWindowPosFlags.SWP_NOENDSCHANGING | SetWindowPosFlags.SWP_NOACTIVATE); + } + return result; + } + + // If we ever start using this, we should probably replace FosterParent with IntPtr.Zero + internal override IntPtr GetParent(IntPtr handle) { + return Win32GetParent(handle); + } + + // This is a nop on win32 and x11 + internal override IntPtr GetPreviousWindow(IntPtr handle) { + return handle; + } + + internal override void GrabWindow(IntPtr hWnd, IntPtr ConfineToHwnd) { + grab_hwnd = hWnd; + Win32SetCapture(hWnd); + + if (ConfineToHwnd != IntPtr.Zero) { + RECT window_rect; + Win32GetWindowRect (ConfineToHwnd, out window_rect); + Win32GetClipCursor (out clipped_cursor_rect); + Win32ClipCursor (ref window_rect); + } + } + + internal override void GrabInfo(out IntPtr hWnd, out bool GrabConfined, out Rectangle GrabArea) { + hWnd = grab_hwnd; + GrabConfined = grab_confined; + GrabArea = grab_area; + } + + internal override void UngrabWindow(IntPtr hWnd) { + if (!(clipped_cursor_rect.top == 0 && clipped_cursor_rect.bottom == 0 && clipped_cursor_rect.left == 0 && clipped_cursor_rect.right == 0)) { + Win32ClipCursor (ref clipped_cursor_rect); + clipped_cursor_rect = new RECT (); + } + + Win32ReleaseCapture(); + grab_hwnd = IntPtr.Zero; + } + + internal override bool CalculateWindowRect(ref Rectangle ClientRect, CreateParams cp, Menu menu, out Rectangle WindowRect) { + RECT rect; + + rect.left=ClientRect.Left; + rect.top=ClientRect.Top; + rect.right=ClientRect.Right; + rect.bottom=ClientRect.Bottom; + + if (!Win32AdjustWindowRectEx(ref rect, cp.Style, menu != null, cp.ExStyle)) { + WindowRect = new Rectangle(ClientRect.Left, ClientRect.Top, ClientRect.Width, ClientRect.Height); + return false; + } + + WindowRect = new Rectangle(rect.left, rect.top, rect.right-rect.left, rect.bottom-rect.top); + return true; + } + + internal override void SetCursor(IntPtr window, IntPtr cursor) { + Win32SetCursor(cursor); + return; + } + + internal override void ShowCursor(bool show) { + Win32ShowCursor(show); + } + + internal override void OverrideCursor(IntPtr cursor) { + Win32SetCursor(cursor); + } + + internal override IntPtr DefineCursor(Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot) { + IntPtr cursor; + Bitmap cursor_bitmap; + Bitmap cursor_mask; + Byte[] cursor_bits; + Byte[] mask_bits; + Color pixel; + int width; + int height; + + // Win32 only allows creation cursors of a certain size + if ((bitmap.Width != Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR)) || (bitmap.Width != Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR))) { + cursor_bitmap = new Bitmap(bitmap, new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR), Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR))); + cursor_mask = new Bitmap(mask, new Size(Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR), Win32GetSystemMetrics(SystemMetrics.SM_CXCURSOR))); + } else { + cursor_bitmap = bitmap; + cursor_mask = mask; + } + + width = cursor_bitmap.Width; + height = cursor_bitmap.Height; + + cursor_bits = new Byte[(width / 8) * height]; + mask_bits = new Byte[(width / 8) * height]; + + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + pixel = cursor_bitmap.GetPixel(x, y); + + if (pixel == cursor_pixel) { + cursor_bits[y * width / 8 + x / 8] |= (byte)(0x80 >> (x % 8)); + } + + pixel = cursor_mask.GetPixel(x, y); + + if (pixel == mask_pixel) { + mask_bits[y * width / 8 + x / 8] |= (byte)(0x80 >> (x % 8)); + } + } + } + + cursor = Win32CreateCursor(IntPtr.Zero, xHotSpot, yHotSpot, width, height, mask_bits, cursor_bits); + + return cursor; + } + + internal override Bitmap DefineStdCursorBitmap (StdCursor id) + { + // We load the cursor, create a bitmap, draw the cursor onto the bitmap and return the bitmap. + IntPtr cursor = DefineStdCursor (id); + // Windows only have one possible cursor size! + int width = Win32GetSystemMetrics (SystemMetrics.SM_CXCURSOR); + int height = Win32GetSystemMetrics (SystemMetrics.SM_CYCURSOR); + Bitmap bmp = new Bitmap (width, height); + Graphics gc = Graphics.FromImage (bmp); + IntPtr hdc = gc.GetHdc (); + Win32DrawIcon (hdc, 0, 0, cursor); + gc.ReleaseHdc (hdc); + gc.Dispose (); + return bmp; + } + + [MonoTODO("Define the missing cursors")] + internal override IntPtr DefineStdCursor(StdCursor id) { + switch(id) { + case StdCursor.AppStarting: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_APPSTARTING); + case StdCursor.Arrow: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); + case StdCursor.Cross: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_CROSS); + case StdCursor.Default: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); + case StdCursor.Hand: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_HAND); + case StdCursor.Help: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_HELP); + case StdCursor.HSplit: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.IBeam: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_IBEAM); + case StdCursor.No: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_NO); + case StdCursor.NoMove2D: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.NoMoveHoriz: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.NoMoveVert: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanEast: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanNE: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanNorth: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanNW: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanSE: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanSouth: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanSW: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.PanWest: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.SizeAll: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZEALL); + case StdCursor.SizeNESW: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZENESW); + case StdCursor.SizeNS: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZENS); + case StdCursor.SizeNWSE: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZENWSE); + case StdCursor.SizeWE: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_SIZEWE); + case StdCursor.UpArrow: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_UPARROW); + case StdCursor.VSplit: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_ARROW); // FIXME + case StdCursor.WaitCursor: return Win32LoadCursor(IntPtr.Zero, LoadCursorType.IDC_WAIT); + } + throw new NotImplementedException (); + } + + internal override void DestroyCursor(IntPtr cursor) { + if ((cursor.ToInt32() < (int)LoadCursorType.First) || (cursor.ToInt32() > (int)LoadCursorType.Last)) { + Win32DestroyCursor(cursor); + } + } + + [MonoTODO] + internal override void GetCursorInfo(IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y) { + ICONINFO ii = new ICONINFO (); + + if (!Win32GetIconInfo (cursor, out ii)) + throw new Win32Exception (); + + width = 20; + height = 20; + hotspot_x = ii.xHotspot; + hotspot_y = ii.yHotspot; + } + + internal override void SetCursorPos(IntPtr handle, int x, int y) { + Win32SetCursorPos(x, y); + } + + internal override Region GetClipRegion(IntPtr hwnd) { + Region region; + + region = new Region(); + + Win32GetWindowRgn(hwnd, region.GetHrgn(Graphics.FromHwnd(hwnd))); + + return region; + } + + internal override void SetClipRegion(IntPtr hwnd, Region region) { + if (region == null) + Win32SetWindowRgn (hwnd, IntPtr.Zero, true); + else + Win32SetWindowRgn(hwnd, region.GetHrgn(Graphics.FromHwnd(hwnd)), true); + } + + internal override void EnableWindow(IntPtr handle, bool Enable) { + Win32EnableWindow(handle, Enable); + } + + internal override void EndLoop(System.Threading.Thread thread) { + // Nothing to do + } + + internal override object StartLoop(System.Threading.Thread thread) { + return null; + } + + internal override void SetModal(IntPtr handle, bool Modal) { + // we do nothing on Win32 + } + + internal override void GetCursorPos(IntPtr handle, out int x, out int y) { + POINT pt; + + Win32GetCursorPos(out pt); + + if (handle!=IntPtr.Zero) { + Win32ScreenToClient(handle, ref pt); + } + + x=pt.x; + y=pt.y; + } + + internal override void ScreenToClient(IntPtr handle, ref int x, ref int y) + { + POINT pnt = new POINT(); + + pnt.x = x; + pnt.y = y; + Win32ScreenToClient (handle, ref pnt); + + x = pnt.x; + y = pnt.y; + } + + internal override void ClientToScreen(IntPtr handle, ref int x, ref int y) { + POINT pnt = new POINT(); + + pnt.x = x; + pnt.y = y; + + Win32ClientToScreen(handle, ref pnt); + + x = pnt.x; + y = pnt.y; + } + + internal override void ScreenToMenu(IntPtr handle, ref int x, ref int y) { + RECT rect; + + Win32GetWindowRect(handle, out rect); + x -= rect.left + SystemInformation.FrameBorderSize.Width; + y -= rect.top + SystemInformation.FrameBorderSize.Height; + + WindowStyles style = (WindowStyles) Win32GetWindowLong (handle, WindowLong.GWL_STYLE); + if (CreateParams.IsSet (style, WindowStyles.WS_CAPTION)) { + y -= ThemeEngine.Current.CaptionHeight; + } + } + + internal override void MenuToScreen(IntPtr handle, ref int x, ref int y) { + RECT rect; + + Win32GetWindowRect(handle, out rect); + x += rect.left + SystemInformation.FrameBorderSize.Width; + y += rect.top + SystemInformation.FrameBorderSize.Height + ThemeEngine.Current.CaptionHeight; + return; + } + + internal override void SendAsyncMethod (AsyncMethodData method) + { + Win32PostMessage(GetFosterParent(), Msg.WM_ASYNC_MESSAGE, IntPtr.Zero, (IntPtr)GCHandle.Alloc (method)); + } + + internal override void SetTimer (Timer timer) + { + IntPtr FosterParent=GetFosterParent(); + int index; + + index = timer.GetHashCode(); + + lock (timer_list) { + timer_list[index]=timer; + } + + if (Win32SetTimer(FosterParent, index, (uint)timer.Interval, IntPtr.Zero) != IntPtr.Zero) + timer.window = FosterParent; + else + timer.window = IntPtr.Zero; + } + + internal override void KillTimer (Timer timer) + { + int index; + + index = timer.GetHashCode(); + + Win32KillTimer(timer.window, index); + + lock (timer_list) { + timer_list.Remove(index); + } + } + + internal override void CreateCaret(IntPtr hwnd, int width, int height) { + Win32CreateCaret(hwnd, IntPtr.Zero, width, height); + caret_visible = false; + } + + internal override void DestroyCaret(IntPtr hwnd) { + Win32DestroyCaret(); + } + + internal override void SetCaretPos(IntPtr hwnd, int x, int y) { + Win32SetCaretPos(x, y); + } + + internal override void CaretVisible(IntPtr hwnd, bool visible) { + if (visible) { + if (!caret_visible) { + Win32ShowCaret(hwnd); + caret_visible = true; + } + } else { + if (caret_visible) { + Win32HideCaret(hwnd); + caret_visible = false; + } + } + } + + internal override IntPtr GetFocus() { + return Win32GetFocus(); + } + + internal override void SetFocus(IntPtr hwnd) { + Win32SetFocus(hwnd); + } + + internal override IntPtr GetActive() { + return Win32GetActiveWindow(); + } + + internal override bool GetFontMetrics(Graphics g, Font font, out int ascent, out int descent) { + IntPtr dc; + IntPtr prevobj; + TEXTMETRIC tm; + + tm = new TEXTMETRIC(); + + dc = Win32GetDC (IntPtr.Zero); + prevobj = Win32SelectObject (dc, font.ToHfont ()); + + if (Win32GetTextMetrics (dc, ref tm) == false) { + prevobj = Win32SelectObject (dc, prevobj); + Win32DeleteObject (prevobj); + Win32ReleaseDC (IntPtr.Zero, dc); + ascent = 0; + descent = 0; + return false; + } + prevobj = Win32SelectObject (dc, prevobj); + Win32DeleteObject (prevobj); + Win32ReleaseDC (IntPtr.Zero, dc); + + ascent = tm.tmAscent; + descent = tm.tmDescent; + + return true; + } + + internal override void ScrollWindow(IntPtr hwnd, Rectangle rectangle, int XAmount, int YAmount, bool with_children) { + RECT rect; + + rect = new RECT(); + rect.left = rectangle.X; + rect.top = rectangle.Y; + rect.right = rectangle.Right; + rect.bottom = rectangle.Bottom; + + Win32ScrollWindowEx(hwnd, XAmount, YAmount, IntPtr.Zero, ref rect, IntPtr.Zero, IntPtr.Zero, ScrollWindowExFlags.SW_INVALIDATE | ScrollWindowExFlags.SW_ERASE | (with_children ? ScrollWindowExFlags.SW_SCROLLCHILDREN : ScrollWindowExFlags.SW_NONE)); + Win32UpdateWindow(hwnd); + } + + internal override void ScrollWindow(IntPtr hwnd, int XAmount, int YAmount, bool with_children) { + Win32ScrollWindowEx(hwnd, XAmount, YAmount, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, ScrollWindowExFlags.SW_INVALIDATE | ScrollWindowExFlags.SW_ERASE | (with_children ? ScrollWindowExFlags.SW_SCROLLCHILDREN : ScrollWindowExFlags.SW_NONE)); + } + + internal override bool SystrayAdd(IntPtr hwnd, string tip, Icon icon, out ToolTip tt) { + NOTIFYICONDATA nid; + + nid = new NOTIFYICONDATA(); + + nid.cbSize = (uint)Marshal.SizeOf(nid); + nid.hWnd = hwnd; + nid.uID = 1; + nid.uCallbackMessage = (uint)Msg.WM_USER; + nid.uFlags = NotifyIconFlags.NIF_MESSAGE; + + if (tip != null) { + nid.szTip = tip; + nid.uFlags |= NotifyIconFlags.NIF_TIP; + } + + if (icon != null) { + nid.hIcon = icon.Handle; + nid.uFlags |= NotifyIconFlags.NIF_ICON; + } + + tt = null; + + return Win32Shell_NotifyIcon(NotifyIconMessage.NIM_ADD, ref nid); + } + + internal override bool SystrayChange(IntPtr hwnd, string tip, Icon icon, ref ToolTip tt) { + NOTIFYICONDATA nid; + + nid = new NOTIFYICONDATA(); + + nid.cbSize = (uint)Marshal.SizeOf(nid); + nid.hIcon = icon.Handle; + nid.hWnd = hwnd; + nid.uID = 1; + nid.uCallbackMessage = (uint)Msg.WM_USER; + nid.uFlags = NotifyIconFlags.NIF_MESSAGE; + + if (tip != null) { + nid.szTip = tip; + nid.uFlags |= NotifyIconFlags.NIF_TIP; + } + + if (icon != null) { + nid.hIcon = icon.Handle; + nid.uFlags |= NotifyIconFlags.NIF_ICON; + } + + return Win32Shell_NotifyIcon(NotifyIconMessage.NIM_MODIFY, ref nid); + } + + internal override void SystrayRemove(IntPtr hwnd, ref ToolTip tt) { + NOTIFYICONDATA nid; + + nid = new NOTIFYICONDATA(); + + nid.cbSize = (uint)Marshal.SizeOf(nid); + nid.hWnd = hwnd; + nid.uID = 1; + nid.uFlags = 0; + + Win32Shell_NotifyIcon(NotifyIconMessage.NIM_DELETE, ref nid); + } + + internal override void SystrayBalloon(IntPtr hwnd, int timeout, string title, string text, ToolTipIcon icon) + { + NOTIFYICONDATA nid; + + nid = new NOTIFYICONDATA(); + + nid.cbSize = (uint)Marshal.SizeOf(nid); + nid.hWnd = hwnd; + nid.uID = 1; + nid.uFlags = NotifyIconFlags.NIF_INFO; + nid.uTimeoutOrVersion = timeout; + nid.szInfoTitle = title; + nid.szInfo = text; + nid.dwInfoFlags = icon; + + Win32Shell_NotifyIcon(NotifyIconMessage.NIM_MODIFY, ref nid); + } + + internal override void SetBorderStyle(IntPtr handle, FormBorderStyle border_style) { + // Nothing to do on Win32 + } + + internal override void SetMenu(IntPtr handle, Menu menu) { + // Trigger WM_NCCALC + Win32SetWindowPos(handle, IntPtr.Zero, 0, 0, 0, 0, SetWindowPosFlags.SWP_FRAMECHANGED | SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE); + } + + internal override Point GetMenuOrigin(IntPtr handle) { + Form form = Widget.FromHandle (handle) as Form; + + if (form != null) { + if (form.FormBorderStyle == FormBorderStyle.None) + return Point.Empty; + + int bordersize = (form.Width - form.ClientSize.Width) / 2; + + if (form.FormBorderStyle == FormBorderStyle.FixedToolWindow || form.FormBorderStyle == FormBorderStyle.SizableToolWindow) + return new Point (bordersize, bordersize + SystemInformation.ToolWindowCaptionHeight); + else + return new Point (bordersize, bordersize + SystemInformation.CaptionHeight); + } + + return new Point(SystemInformation.FrameBorderSize.Width, SystemInformation.FrameBorderSize.Height + ThemeEngine.Current.CaptionHeight); + } + + internal override void SetIcon(IntPtr hwnd, Icon icon) { + Win32SendMessage(hwnd, Msg.WM_SETICON, (IntPtr)1, icon == null ? IntPtr.Zero : icon.Handle); // 1 = large icon (0 would be small) + } + + internal override void ClipboardClose(IntPtr handle) { + if (handle != clip_magic) { + throw new ArgumentException("handle is not a valid clipboard handle"); + } + Win32CloseClipboard(); + } + + internal override int ClipboardGetID(IntPtr handle, string format) { + if (handle != clip_magic) { + throw new ArgumentException("handle is not a valid clipboard handle"); + } + if (format == "Text" ) return 1; + else if (format == "Bitmap" ) return 2; + else if (format == "MetaFilePict" ) return 3; + else if (format == "SymbolicLink" ) return 4; + else if (format == "DataInterchangeFormat" ) return 5; + else if (format == "Tiff" ) return 6; + else if (format == "OEMText" ) return 7; + else if (format == "DeviceIndependentBitmap" ) return 8; + else if (format == "Palette" ) return 9; + else if (format == "PenData" ) return 10; + else if (format == "RiffAudio" ) return 11; + else if (format == "WaveAudio" ) return 12; + else if (format == "UnicodeText" ) return 13; + else if (format == "EnhancedMetafile" ) return 14; + else if (format == "FileDrop" ) return 15; + else if (format == "Locale" ) return 16; + + return (int)Win32RegisterClipboardFormat(format); + } + + internal override IntPtr ClipboardOpen(bool primary_selection) { + // Win32 does not have primary selection + Win32OpenClipboard(GetFosterParent()); + return clip_magic; + } + + internal override int[] ClipboardAvailableFormats(IntPtr handle) { + uint format; + int[] result; + int count; + + if (handle != clip_magic) { + return null; + } + + // Count first + count = 0; + format = 0; + do { + format = Win32EnumClipboardFormats(format); + if (format != 0) { + count++; + } + } while (format != 0); + + // Now assign + result = new int[count]; + count = 0; + format = 0; + do { + format = Win32EnumClipboardFormats(format); + if (format != 0) { + result[count++] = (int)format; + } + } while (format != 0); + + return result; + } + + + internal override object ClipboardRetrieve(IntPtr handle, int type, XplatUI.ClipboardToObject converter) { + IntPtr hmem; + IntPtr data; + object obj; + + if (handle != clip_magic) { + throw new ArgumentException("handle is not a valid clipboard handle"); + } + + hmem = Win32GetClipboardData((uint)type); + if (hmem == IntPtr.Zero) { + return null; + } + + data = Win32GlobalLock(hmem); + if (data == IntPtr.Zero) { + uint error = Win32GetLastError(); + Console.WriteLine("Error: {0}", error); + return null; + } + + obj = null; + + if (type == DataFormats.GetFormat(DataFormats.Rtf).Id) { + obj = AnsiToString(data); + } else switch ((ClipboardFormats)type) { + case ClipboardFormats.CF_TEXT: { + obj = AnsiToString(data); + break; + } + + case ClipboardFormats.CF_DIB: { + obj = DIBtoImage(data); + break; + } + + case ClipboardFormats.CF_UNICODETEXT: { + obj = UnicodeToString(data); + break; + } + + default: { + if (converter != null && !converter(type, data, out obj)) { + obj = null; + } + break; + } + } + Win32GlobalUnlock(hmem); + + return obj; + + } + + internal override void ClipboardStore(IntPtr handle, object obj, int type, XplatUI.ObjectToClipboard converter, bool copy) + { + byte[] data = null; + + if (handle != clip_magic) { + throw new ArgumentException("handle is not a valid clipboard handle"); + } + + if (obj == null) { + // Just clear it + if (!Win32EmptyClipboard()) + throw new ExternalException("Win32EmptyClipboard"); + return; + } + + if (type == -1) { + if (obj is string) { + type = (int)ClipboardFormats.CF_UNICODETEXT; + } else if (obj is Image) { + type = (int)ClipboardFormats.CF_DIB; + } + } + + if (type == DataFormats.GetFormat(DataFormats.Rtf).Id) { + data = StringToAnsi ((string)obj); + } else switch((ClipboardFormats)type) { + case ClipboardFormats.CF_UNICODETEXT: { + data = StringToUnicode ((string)obj); + break; + } + + case ClipboardFormats.CF_TEXT: { + data = StringToAnsi ((string)obj); + break; + } + + case ClipboardFormats.CF_BITMAP: + case ClipboardFormats.CF_DIB: { + data = ImageToDIB ((Image)obj); + type = (int)ClipboardFormats.CF_DIB; + break; + } + + default: { + if (converter != null && !converter(ref type, obj, out data)) { + data = null; // ensure that a failed conversion leaves null. + } + break; + } + } + if (data != null) { + SetClipboardData ((uint)type, data); + } + } + + internal static byte[] StringToUnicode (string text) + { + return Encoding.Unicode.GetBytes (text + "\0"); + } + + internal static byte[] StringToAnsi (string text) + { + // FIXME, follow the behaviour of the previous code using UTF-8, + // but this should be 'ANSI' on Windows, i.e. the current code page. + // Does Encoding.Default work on Windows? + return Encoding.UTF8.GetBytes (text + "\0"); + } + + private void SetClipboardData (uint type, byte[] data) + { + if (data.Length == 0) + // Shouldn't call Win32SetClipboard with NULL, as, from MSDN: + // "This parameter can be NULL, indicating that the window provides data + // in the specified clipboard format (renders the format) upon request." + // and I don't think we support that... + // Note this is unrelated to the fact that passing a null obj to + // ClipboardStore is actually a request to empty the clipboard! + return; + IntPtr hmem = CopyToMoveableMemory (data); + if (hmem == IntPtr.Zero) + // As above, should not call with null. + // (Not that CopyToMoveableMemory should ever return null!) + throw new ExternalException ("CopyToMoveableMemory failed."); + if (Win32SetClipboardData (type, hmem) == IntPtr.Zero) + throw new ExternalException ("Win32SetClipboardData"); + } + + /// <summary> + /// Creates a memory block with GlobalAlloc(GMEM_MOVEABLE), copies the data + /// into it, and returns the handle to the memory. + /// </summary> + /// - + /// <param name="data">The data. Must not be null or zero-length — + /// see the exception notes.</param> + /// - + /// <returns>The *handle* to the allocated GMEM_MOVEABLE block.</returns> + /// - + /// <exception cref="T:System.ArgumentException">The data was null or zero + /// length. This is disallowed since a zero length allocation can't be made + /// </exception> + /// <exception cref="T:System.ComponentModel.Win32Exception">The allocation, + /// or locking (handle->pointer) failed. + /// Either out of memory or the handle table is full (256 max currently). + /// Note Win32Exception is a subclass of ExternalException so this is OK in + /// the documented Clipboard interface. + /// </exception> + internal static IntPtr CopyToMoveableMemory (byte[] data) + { + if (data == null || data.Length == 0) + // detect this before GlobalAlloc does. + throw new ArgumentException ("Can't create a zero length memory block."); + + IntPtr hmem = Win32GlobalAlloc (GAllocFlags.GMEM_MOVEABLE | GAllocFlags.GMEM_DDESHARE, data.Length); + if (hmem == IntPtr.Zero) + throw new Win32Exception (); + IntPtr hmem_ptr = Win32GlobalLock (hmem); + if (hmem_ptr == IntPtr.Zero) // If the allocation was valid this shouldn't occur. + throw new Win32Exception (); + Marshal.Copy (data, 0, hmem_ptr, data.Length); + Win32GlobalUnlock (hmem); + return hmem; + } + + + internal override void SetAllowDrop(IntPtr hwnd, bool allowed) { + if (allowed) { + Win32DnD.RegisterDropTarget(hwnd); + } else { + Win32DnD.UnregisterDropTarget(hwnd); + } + } + + internal override DragDropEffects StartDrag(IntPtr hwnd, object data, DragDropEffects allowedEffects) { + return Win32DnD.StartDrag(hwnd, data, allowedEffects); + } + + // XXX this doesn't work at all for FrameStyle.Dashed - it draws like Thick, and in the Thick case + // the corners are drawn incorrectly. + internal override void DrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style) { + IntPtr hdc; + IntPtr pen; + IntPtr oldpen; + COLORREF clrRef = new COLORREF(); + + // If we want the standard hatch pattern we would + // need to create a brush + + clrRef.R = backColor.R; + clrRef.G = backColor.G; + clrRef.B = backColor.B; + + // Grab a pen + pen = Win32CreatePen (style == FrameStyle.Thick ? PenStyle.PS_SOLID : PenStyle.PS_DASH, + style == FrameStyle.Thick ? 4 : 2, ref clrRef); + + hdc = Win32GetDC(IntPtr.Zero); + Win32SetROP2(hdc, ROP2DrawMode.R2_NOT); + oldpen = Win32SelectObject(hdc, pen); + + Win32MoveToEx(hdc, rectangle.Left, rectangle.Top, IntPtr.Zero); + if ((rectangle.Width > 0) && (rectangle.Height > 0)) { + Win32LineTo(hdc, rectangle.Right, rectangle.Top); + Win32LineTo(hdc, rectangle.Right, rectangle.Bottom); + Win32LineTo(hdc, rectangle.Left, rectangle.Bottom); + Win32LineTo(hdc, rectangle.Left, rectangle.Top); + } else { + if (rectangle.Width > 0) { + Win32LineTo(hdc, rectangle.Right, rectangle.Top); + } else { + Win32LineTo(hdc, rectangle.Left, rectangle.Bottom); + } + } + + Win32SelectObject(hdc, oldpen); + Win32DeleteObject(pen); + + Win32ReleaseDC(IntPtr.Zero, hdc); + } + + internal override void DrawReversibleLine(Point start, Point end, Color backColor) { + IntPtr hdc; + IntPtr pen; + IntPtr oldpen; + POINT pt; + COLORREF clrRef = new COLORREF(); + + pt = new POINT(); + pt.x = 0; + pt.y = 0; + Win32ClientToScreen(IntPtr.Zero, ref pt); + + // If we want the standard hatch pattern we would + // need to create a brush + + clrRef.R = backColor.R; + clrRef.G = backColor.G; + clrRef.B = backColor.B; + + // Grab a pen + pen = Win32CreatePen(PenStyle.PS_SOLID, 1, ref clrRef); + + hdc = Win32GetDC(IntPtr.Zero); + Win32SetROP2(hdc, ROP2DrawMode.R2_NOT); + oldpen = Win32SelectObject(hdc, pen); + + Win32MoveToEx(hdc, pt.x + start.X, pt.y + start.Y, IntPtr.Zero); + Win32LineTo(hdc, pt.x + end.X, pt.y + end.Y); + + Win32SelectObject(hdc, oldpen); + Win32DeleteObject(pen); + + Win32ReleaseDC(IntPtr.Zero, hdc); + } + + internal override void FillReversibleRectangle (Rectangle rectangle, Color backColor) + { + RECT rect; + + rect = new RECT(); + rect.left = rectangle.Left; + rect.top = rectangle.Top; + rect.right = rectangle.Right; + rect.bottom = rectangle.Bottom; + + IntPtr hdc; + IntPtr brush; + IntPtr oldbrush; + COLORREF clrRef = new COLORREF(); + + clrRef.R = backColor.R; + clrRef.G = backColor.G; + clrRef.B = backColor.B; + + // Grab a brush + brush = Win32CreateSolidBrush (clrRef); + + hdc = Win32GetDC(IntPtr.Zero); + oldbrush = Win32SelectObject(hdc, brush); + + Win32PatBlt (hdc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height, PatBltRop.DSTINVERT); + + Win32SelectObject(hdc, oldbrush); + Win32DeleteObject(brush); + + Win32ReleaseDC(IntPtr.Zero, hdc); + } + + internal override void DrawReversibleRectangle(IntPtr handle, Rectangle rect, int line_width) { + IntPtr hdc; + IntPtr pen; + IntPtr oldpen; + POINT pt; + + pt = new POINT(); + pt.x = 0; + pt.y = 0; + Win32ClientToScreen(handle, ref pt); + + // If we want the standard hatch pattern we would + // need to create a brush + + // Grab a pen + pen = Win32CreatePen(PenStyle.PS_SOLID, line_width, IntPtr.Zero); + + hdc = Win32GetDC(IntPtr.Zero); + Win32SetROP2(hdc, ROP2DrawMode.R2_NOT); + oldpen = Win32SelectObject(hdc, pen); + + Widget c = Widget.FromHandle (handle); + if (c != null) { + RECT window_rect; + Win32GetWindowRect (c.Handle, out window_rect); + Region r = new Region (new Rectangle(window_rect.left, window_rect.top, window_rect.right - window_rect.left, window_rect.bottom - window_rect.top)); + Win32ExtSelectClipRgn(hdc, r.GetHrgn (Graphics.FromHdc (hdc)), (int) ClipCombineMode.RGN_AND); + } + + Win32MoveToEx(hdc, pt.x + rect.Left, pt.y + rect.Top, IntPtr.Zero); + if ((rect.Width > 0) && (rect.Height > 0)) { + Win32LineTo(hdc, pt.x + rect.Right, pt.y + rect.Top); + Win32LineTo(hdc, pt.x + rect.Right, pt.y + rect.Bottom); + Win32LineTo(hdc, pt.x + rect.Left, pt.y + rect.Bottom); + Win32LineTo(hdc, pt.x + rect.Left, pt.y + rect.Top); + } else { + if (rect.Width > 0) { + Win32LineTo(hdc, pt.x + rect.Right, pt.y + rect.Top); + } else { + Win32LineTo(hdc, pt.x + rect.Left, pt.y + rect.Bottom); + } + } + + Win32SelectObject(hdc, oldpen); + Win32DeleteObject(pen); + if (c != null) + Win32ExtSelectClipRgn(hdc, IntPtr.Zero, (int) ClipCombineMode.RGN_COPY); + + Win32ReleaseDC(IntPtr.Zero, hdc); + } + + internal override SizeF GetAutoScaleSize(Font font) { + Graphics g; + float width; + string magic_string = "The quick brown fox jumped over the lazy dog."; + double magic_number = 44.549996948242189; + + g = Graphics.FromHwnd(GetFosterParent()); + + width = (float) (g.MeasureString (magic_string, font).Width / magic_number); + return new SizeF(width, font.Height); + } + + internal override IntPtr SendMessage (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam) { + return Win32SendMessage(hwnd, message, wParam, lParam); + } + + internal override bool PostMessage (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam) { + return Win32PostMessage(hwnd, message, wParam, lParam); + } + + internal override int SendInput (IntPtr hwnd, Queue keys) { + INPUT[] inputs = new INPUT[keys.Count]; + const Int32 INPUT_KEYBOARD = 1; + uint returns = 0; + int i = 0; + while (keys.Count > 0) { + MSG msg = (MSG)keys.Dequeue(); + + + inputs[i].ki.wScan = 0; + inputs[i].ki.time = 0; + inputs[i].ki.dwFlags = (Int32)(msg.message == Msg.WM_KEYUP ? InputFlags.KEYEVENTF_KEYUP : 0); + inputs[i].ki.wVk = (short)msg.wParam.ToInt32(); + inputs[i].type = INPUT_KEYBOARD; + i++; + } + returns = Win32SendInput((UInt32)inputs.Length, inputs, Marshal.SizeOf(typeof(INPUT))); + + return (int) returns; + } + + internal override int KeyboardSpeed { + get { + int speed = 0; + Win32SystemParametersInfo(SPIAction.SPI_GETKEYBOARDSPEED, 0, ref speed, 0); + // + // Return values range from 0 to 31 which map to 2.5 to 30 repetitions per second. + // + return speed; + } + } + + internal override int KeyboardDelay { + get { + int delay = 1; + Win32SystemParametersInfo(SPIAction.SPI_GETKEYBOARDDELAY, 0, ref delay, 0); + // + // Return values must range from 0 to 4, 0 meaning 250ms, + // and 4 meaning 1000 ms. + // + return delay; + } + } + + private class WinBuffer + { + public IntPtr hdc; + public IntPtr bitmap; + + public WinBuffer (IntPtr hdc, IntPtr bitmap) + { + this.hdc = hdc; + this.bitmap = bitmap; + } + } + + internal override void CreateOffscreenDrawable (IntPtr handle, int width, int height, out object offscreen_drawable) + { + Graphics destG = Graphics.FromHwnd (handle); + IntPtr destHdc = destG.GetHdc (); + + IntPtr srcHdc = Win32CreateCompatibleDC (destHdc); + IntPtr srcBmp = Win32CreateCompatibleBitmap (destHdc, width, height); + Win32SelectObject (srcHdc, srcBmp); + + offscreen_drawable = new WinBuffer (srcHdc, srcBmp); + + destG.ReleaseHdc (destHdc); + } + + internal override Graphics GetOffscreenGraphics (object offscreen_drawable) + { + return Graphics.FromHdc (((WinBuffer)offscreen_drawable).hdc); + } + + internal override void BlitFromOffscreen (IntPtr dest_handle, Graphics dest_dc, object offscreen_drawable, Graphics offscreen_dc, Rectangle r) + { + WinBuffer wb = (WinBuffer)offscreen_drawable; + + IntPtr destHdc = dest_dc.GetHdc (); + Win32BitBlt (destHdc, r.Left, r.Top, r.Width, r.Height, wb.hdc, r.Left, r.Top, TernaryRasterOperations.SRCCOPY); + dest_dc.ReleaseHdc (destHdc); + } + + internal override void DestroyOffscreenDrawable (object offscreen_drawable) + { + WinBuffer wb = (WinBuffer)offscreen_drawable; + + Win32DeleteObject (wb.bitmap); + Win32DeleteDC (wb.hdc); + } + + internal override void SetForegroundWindow (IntPtr handle) + { + Win32SetForegroundWindow(handle); + } + + internal override event EventHandler Idle; + #endregion // Public Static Methods + + #region Win32 Imports + [DllImport ("kernel32.dll", EntryPoint="GetLastError", CallingConvention=CallingConvention.StdCall)] + private extern static uint Win32GetLastError(); + + [DllImport ("user32.dll", EntryPoint="CreateWindowExW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32CreateWindow(WindowExStyles dwExStyle, string lpClassName, string lpWindowName, WindowStyles dwStyle, int x, int y, int nWidth, int nHeight, IntPtr hWndParent, IntPtr hMenu, IntPtr hInstance, IntPtr lParam); + + [DllImport ("user32.dll", EntryPoint="DestroyWindow", CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32DestroyWindow(IntPtr hWnd); + + [DllImport ("user32.dll", EntryPoint="PeekMessageW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32PeekMessage(ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags); + + [DllImport ("user32.dll", EntryPoint="GetMessageW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32GetMessage(ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax); + + [DllImport ("user32.dll", EntryPoint="TranslateMessage", CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32TranslateMessage(ref MSG msg); + + [DllImport ("user32.dll", EntryPoint="DispatchMessageW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32DispatchMessage(ref MSG msg); + + [DllImport ("user32.dll", EntryPoint="MoveWindow", CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32MoveWindow(IntPtr hWnd, int x, int y, int width, int height, bool repaint); + + [DllImport ("user32.dll", EntryPoint="SetWindowPos", CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int cx, int cy, SetWindowPosFlags Flags); + + [DllImport ("user32.dll", EntryPoint="SetWindowPos", CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32SetWindowPos(IntPtr hWnd, SetWindowPosZOrder pos, int x, int y, int cx, int cy, SetWindowPosFlags Flags); + + [DllImport ("user32.dll", EntryPoint="SetWindowTextW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32SetWindowText(IntPtr hWnd, string lpString); + + [DllImport ("user32.dll", EntryPoint="GetWindowTextW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount); + + [DllImport ("user32.dll", EntryPoint="SetParent", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32SetParent(IntPtr hWnd, IntPtr hParent); + + [DllImport ("user32.dll", EntryPoint="RegisterClassW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32RegisterClass(ref WNDCLASS wndClass); + + [DllImport ("user32.dll", EntryPoint="LoadCursorW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32LoadCursor(IntPtr hInstance, LoadCursorType type); + + [DllImport ("user32.dll", EntryPoint="ShowCursor", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32ShowCursor(bool bShow); + + [DllImport ("user32.dll", EntryPoint="SetCursor", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32SetCursor(IntPtr hCursor); + + [DllImport ("user32.dll", EntryPoint="CreateCursor", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32CreateCursor(IntPtr hInstance, int xHotSpot, int yHotSpot, int nWidth, int nHeight, Byte[] pvANDPlane, Byte[] pvORPlane); + + [DllImport ("user32.dll", EntryPoint="DestroyCursor", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32DestroyCursor(IntPtr hCursor); + + [DllImport ("user32.dll", EntryPoint = "DrawIcon", CallingConvention = CallingConvention.StdCall)] + private extern static bool Win32DrawIcon (IntPtr hDC, int X, int Y, IntPtr hIcon); + + [DllImport ("user32.dll", EntryPoint="DefWindowProcW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32DefWindowProc(IntPtr hWnd, Msg Msg, IntPtr wParam, IntPtr lParam); + + //[DllImport ("user32.dll", EntryPoint="DefDlgProcW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + //private extern static IntPtr Win32DefDlgProc(IntPtr hWnd, Msg Msg, IntPtr wParam, IntPtr lParam); + + [DllImport ("user32.dll", EntryPoint="PostQuitMessage", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32PostQuitMessage(int nExitCode); + + [DllImport ("user32.dll", EntryPoint="UpdateWindow", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32UpdateWindow(IntPtr hWnd); + + [DllImport ("user32.dll", EntryPoint="GetUpdateRect", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32GetUpdateRect(IntPtr hWnd, ref RECT rect, bool erase); + + [DllImport ("user32.dll", EntryPoint="BeginPaint", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32BeginPaint(IntPtr hWnd, ref PAINTSTRUCT ps); + + [DllImport ("user32.dll", EntryPoint = "ValidateRect", CallingConvention = CallingConvention.StdCall)] + private extern static IntPtr Win32ValidateRect (IntPtr hWnd, ref RECT rect); + + [DllImport ("user32.dll", EntryPoint="EndPaint", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32EndPaint(IntPtr hWnd, ref PAINTSTRUCT ps); + + [DllImport ("user32.dll", EntryPoint="GetDC", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32GetDC(IntPtr hWnd); + + [DllImport ("user32.dll", EntryPoint="GetWindowDC", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32GetWindowDC(IntPtr hWnd); + + //[DllImport ("user32.dll", EntryPoint="GetDCEx", CallingConvention=CallingConvention.StdCall)] + //private extern static IntPtr Win32GetDCEx(IntPtr hWnd, IntPtr hRgn, DCExFlags flags); + + [DllImport ("user32.dll", EntryPoint="ReleaseDC", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32ReleaseDC(IntPtr hWnd, IntPtr hDC); + + [DllImport ("user32.dll", EntryPoint="MessageBoxW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32MessageBox(IntPtr hParent, string pText, string pCaption, uint uType); + + [DllImport ("user32.dll", EntryPoint="InvalidateRect", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32InvalidateRect(IntPtr hWnd, ref RECT lpRect, bool bErase); + + //[DllImport ("user32.dll", EntryPoint="InvalidateRect", CallingConvention=CallingConvention.StdCall)] + //private extern static IntPtr Win32InvalidateRect(IntPtr hWnd, IntPtr lpRect, bool bErase); + + [DllImport ("user32.dll", EntryPoint="SetCapture", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32SetCapture(IntPtr hWnd); + + [DllImport ("user32.dll", EntryPoint="ReleaseCapture", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32ReleaseCapture(); + + [DllImport ("user32.dll", EntryPoint="GetWindowRect", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32GetWindowRect(IntPtr hWnd, out RECT rect); + + [DllImport ("user32.dll", EntryPoint="GetClientRect", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32GetClientRect(IntPtr hWnd, out RECT rect); + + [DllImport ("user32.dll", EntryPoint="ScreenToClient", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32ScreenToClient(IntPtr hWnd, ref POINT pt); + + [DllImport ("user32.dll", EntryPoint="ClientToScreen", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32ClientToScreen(IntPtr hWnd, ref POINT pt); + + // This function returns the parent OR THE OWNER! + // Use GetAncestor to only get the parent. + [DllImport ("user32.dll", EntryPoint="GetParent", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32GetParent(IntPtr hWnd); + + [DllImport ("user32.dll", EntryPoint = "GetAncestor", CallingConvention = CallingConvention.StdCall)] + private extern static IntPtr Win32GetAncestor (IntPtr hWnd, AncestorType flags); + + [DllImport ("user32.dll", EntryPoint="SetActiveWindow", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32SetActiveWindow(IntPtr hWnd); + + [DllImport ("user32.dll", EntryPoint="AdjustWindowRectEx", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32AdjustWindowRectEx(ref RECT lpRect, int dwStyle, bool bMenu, int dwExStyle); + + [DllImport ("user32.dll", EntryPoint="GetCursorPos", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32GetCursorPos(out POINT lpPoint); + + [DllImport ("user32.dll", EntryPoint="SetCursorPos", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32SetCursorPos(int x, int y); + + //[DllImport ("user32.dll", EntryPoint="GetWindowPlacement", CallingConvention=CallingConvention.StdCall)] + //private extern static bool Win32GetWindowPlacement(IntPtr hWnd, ref WINDOWPLACEMENT lpwndpl); + + [DllImport ("user32.dll", EntryPoint="TrackMouseEvent", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32TrackMouseEvent(ref TRACKMOUSEEVENT tme); + + //[DllImport ("gdi32.dll", EntryPoint="CreateBrushIndirect", CallingConvention=CallingConvention.StdCall)] + //private extern static IntPtr Win32CreateBrushIndirect(ref LOGBRUSH lb); + + [DllImport ("gdi32.dll", EntryPoint="CreateSolidBrush", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32CreateSolidBrush(COLORREF clrRef); + + [DllImport ("gdi32.dll", EntryPoint="PatBlt", CallingConvention=CallingConvention.StdCall)] + private extern static int Win32PatBlt(IntPtr hdc, int nXLeft, int nYLeft, int nWidth, int nHeight, PatBltRop dwRop); + + [DllImport ("user32.dll", EntryPoint="SetWindowLong", CallingConvention=CallingConvention.StdCall)] + private extern static uint Win32SetWindowLong(IntPtr hwnd, WindowLong index, uint value); + + [DllImport ("user32.dll", EntryPoint="GetWindowLong", CallingConvention=CallingConvention.StdCall)] + private extern static uint Win32GetWindowLong(IntPtr hwnd, WindowLong index); + + [DllImport ("user32.dll", EntryPoint="SetLayeredWindowAttributes", CallingConvention=CallingConvention.StdCall)] + private extern static uint Win32SetLayeredWindowAttributes (IntPtr hwnd, COLORREF crKey, byte bAlpha, LayeredWindowAttributes dwFlags); + + [DllImport ("user32.dll", EntryPoint="GetLayeredWindowAttributes", CallingConvention=CallingConvention.StdCall)] + private extern static uint Win32GetLayeredWindowAttributes (IntPtr hwnd, out COLORREF pcrKey, out byte pbAlpha, out LayeredWindowAttributes pwdFlags); + + [DllImport ("gdi32.dll", EntryPoint="DeleteObject", CallingConvention=CallingConvention.StdCall)] + public extern static bool Win32DeleteObject(IntPtr o); + + [DllImport ("user32.dll", EntryPoint="GetKeyState", CallingConvention=CallingConvention.StdCall)] + private extern static short Win32GetKeyState(VirtualKeys nVirtKey); + + [DllImport ("user32.dll", EntryPoint="GetDesktopWindow", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32GetDesktopWindow(); + + [DllImport ("user32.dll", EntryPoint="SetTimer", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32SetTimer(IntPtr hwnd, int nIDEvent, uint uElapse, IntPtr timerProc); + + [DllImport ("user32.dll", EntryPoint="KillTimer", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32KillTimer(IntPtr hwnd, int nIDEvent); + + [DllImport ("user32.dll", EntryPoint="ShowWindow", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32ShowWindow(IntPtr hwnd, WindowPlacementFlags nCmdShow); + + [DllImport ("user32.dll", EntryPoint="EnableWindow", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32EnableWindow(IntPtr hwnd, bool Enabled); + + [DllImport ("user32.dll", EntryPoint="SetFocus", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32SetFocus(IntPtr hwnd); + + [DllImport ("user32.dll", EntryPoint="GetFocus", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32GetFocus(); + + [DllImport ("user32.dll", EntryPoint="CreateCaret", CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32CreateCaret(IntPtr hwnd, IntPtr hBitmap, int nWidth, int nHeight); + + [DllImport ("user32.dll", EntryPoint="DestroyCaret", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32DestroyCaret(); + + [DllImport ("user32.dll", EntryPoint="ShowCaret", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32ShowCaret(IntPtr hwnd); + + [DllImport ("user32.dll", EntryPoint="HideCaret", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32HideCaret(IntPtr hwnd); + + [DllImport ("user32.dll", EntryPoint="SetCaretPos", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32SetCaretPos(int X, int Y); + + //[DllImport ("user32.dll", EntryPoint="GetCaretBlinkTime", CallingConvention=CallingConvention.StdCall)] + //private extern static uint Win32GetCaretBlinkTime(); + + [DllImport ("gdi32.dll", EntryPoint="GetTextMetricsW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32GetTextMetrics(IntPtr hdc, ref TEXTMETRIC tm); + + [DllImport ("gdi32.dll", EntryPoint="SelectObject", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32SelectObject(IntPtr hdc, IntPtr hgdiobject); + + //[DllImport ("user32.dll", EntryPoint="ScrollWindowEx", CallingConvention=CallingConvention.StdCall)] + //private extern static bool Win32ScrollWindowEx(IntPtr hwnd, int dx, int dy, ref RECT prcScroll, ref RECT prcClip, IntPtr hrgnUpdate, out RECT prcUpdate, ScrollWindowExFlags flags); + + //[DllImport ("user32.dll", EntryPoint="ScrollWindowEx", CallingConvention=CallingConvention.StdCall)] + //private extern static bool Win32ScrollWindowEx(IntPtr hwnd, int dx, int dy, IntPtr prcScroll, ref RECT prcClip, IntPtr hrgnUpdate, out RECT prcUpdate, ScrollWindowExFlags flags); + + //[DllImport ("user32.dll", EntryPoint="ScrollWindowEx", CallingConvention=CallingConvention.StdCall)] + //private extern static bool Win32ScrollWindowEx(IntPtr hwnd, int dx, int dy, ref RECT prcScroll, IntPtr prcClip, IntPtr hrgnUpdate, out RECT prcUpdate, ScrollWindowExFlags flags); + + [DllImport ("user32.dll", EntryPoint="ScrollWindowEx", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32ScrollWindowEx(IntPtr hwnd, int dx, int dy, IntPtr prcScroll, ref RECT prcClip, IntPtr hrgnUpdate, IntPtr prcUpdate, ScrollWindowExFlags flags); + + //[DllImport ("user32.dll", EntryPoint="ScrollWindowEx", CallingConvention=CallingConvention.StdCall)] + //private extern static bool Win32ScrollWindowEx(IntPtr hwnd, int dx, int dy, ref RECT prcScroll, IntPtr prcClip, IntPtr hrgnUpdate, IntPtr prcUpdate, ScrollWindowExFlags flags); + + //[DllImport ("user32.dll", EntryPoint="ScrollWindowEx", CallingConvention=CallingConvention.StdCall)] + //private extern static bool Win32ScrollWindowEx(IntPtr hwnd, int dx, int dy, ref RECT prcScroll, ref RECT prcClip, IntPtr hrgnUpdate, IntPtr prcUpdate, ScrollWindowExFlags flags); + + [DllImport ("user32.dll", EntryPoint="ScrollWindowEx", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32ScrollWindowEx(IntPtr hwnd, int dx, int dy, IntPtr prcScroll, IntPtr prcClip, IntPtr hrgnUpdate, IntPtr prcUpdate, ScrollWindowExFlags flags); + + [DllImport ("user32.dll", EntryPoint="GetActiveWindow", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32GetActiveWindow(); + + [DllImport ("user32.dll", EntryPoint="GetSystemMetrics", CallingConvention=CallingConvention.StdCall)] + private extern static int Win32GetSystemMetrics(SystemMetrics nIndex); + + [DllImport ("shell32.dll", EntryPoint="Shell_NotifyIconW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32Shell_NotifyIcon(NotifyIconMessage dwMessage, ref NOTIFYICONDATA lpData); + + [DllImport ("gdi32.dll", EntryPoint="CreateRectRgn", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32CreateRectRgn(int nLeftRect, int nTopRect, int nRightRect, int nBottomRect); + + [DllImport ("user32.dll", EntryPoint="IsWindowEnabled", CallingConvention=CallingConvention.StdCall)] + private extern static bool IsWindowEnabled(IntPtr hwnd); + + [DllImport ("user32.dll", EntryPoint="IsWindowVisible", CallingConvention=CallingConvention.StdCall)] + private extern static bool IsWindowVisible(IntPtr hwnd); + + [DllImport ("user32.dll", EntryPoint="IsWindow", CallingConvention=CallingConvention.StdCall)] + private extern static bool IsWindow(IntPtr hwnd); + + //[DllImport ("user32.dll", EntryPoint="SetClassLong", CallingConvention=CallingConvention.StdCall)] + //private extern static bool Win32SetClassLong(IntPtr hwnd, ClassLong nIndex, IntPtr dwNewLong); + + [DllImport ("user32.dll", EntryPoint="SendMessageW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32SendMessage(IntPtr hwnd, Msg msg, IntPtr wParam, IntPtr lParam); + + [DllImport ("user32.dll", EntryPoint="PostMessageW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32PostMessage(IntPtr hwnd, Msg msg, IntPtr wParam, IntPtr lParam); + + [DllImport ("user32.dll", EntryPoint="SendInput", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + private extern static UInt32 Win32SendInput(UInt32 nInputs, [MarshalAs(UnmanagedType.LPArray)] INPUT[] inputs, Int32 cbSize); + + [DllImport ("user32.dll", EntryPoint="SystemParametersInfoW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32SystemParametersInfo(SPIAction uiAction, uint uiParam, ref RECT rect, uint fWinIni); + + //[DllImport ("user32.dll", EntryPoint="SystemParametersInfoW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + //private extern static bool Win32SystemParametersInfo(SPIAction uiAction, uint uiParam, ref uint value, uint fWinIni); + + [DllImport ("user32.dll", EntryPoint = "SystemParametersInfoW", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)] + private extern static bool Win32SystemParametersInfo (SPIAction uiAction, uint uiParam, ref int value, uint fWinIni); + + [DllImport ("user32.dll", EntryPoint = "SystemParametersInfoW", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)] + private extern static bool Win32SystemParametersInfo (SPIAction uiAction, uint uiParam, ref bool value, uint fWinIni); + + [DllImport ("user32.dll", EntryPoint = "SystemParametersInfoW", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.StdCall)] + private extern static bool Win32SystemParametersInfo (SPIAction uiAction, uint uiParam, ref ANIMATIONINFO value, uint fWinIni); + + [DllImport ("user32.dll", EntryPoint="OpenClipboard", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32OpenClipboard(IntPtr hwnd); + + [DllImport ("user32.dll", EntryPoint="EmptyClipboard", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32EmptyClipboard(); + + [DllImport ("user32.dll", EntryPoint="RegisterClipboardFormatW", CharSet=CharSet.Unicode, CallingConvention=CallingConvention.StdCall)] + private extern static uint Win32RegisterClipboardFormat(string format); + + [DllImport ("user32.dll", EntryPoint="CloseClipboard", CallingConvention=CallingConvention.StdCall)] + private extern static bool Win32CloseClipboard(); + + [DllImport ("user32.dll", EntryPoint="EnumClipboardFormats", CallingConvention=CallingConvention.StdCall)] + private extern static uint Win32EnumClipboardFormats(uint format); + + [DllImport ("user32.dll", EntryPoint="GetClipboardData", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32GetClipboardData(uint format); + + [DllImport ("user32.dll", EntryPoint="SetClipboardData", CallingConvention=CallingConvention.StdCall)] + private extern static IntPtr Win32SetClipboardData(uint format, IntPtr handle); + + [DllImport ("kernel32.dll", EntryPoint="GlobalAlloc", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32GlobalAlloc(GAllocFlags Flags, int dwBytes); + + [DllImport ("kernel32.dll", EntryPoint="CopyMemory", CallingConvention=CallingConvention.StdCall)] + internal extern static void Win32CopyMemory(IntPtr Destination, IntPtr Source, int length); + + [DllImport ("kernel32.dll", EntryPoint="GlobalFree", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32GlobalFree(IntPtr hMem); + + [DllImport ("kernel32.dll", EntryPoint="GlobalSize", CallingConvention=CallingConvention.StdCall)] + internal extern static uint Win32GlobalSize(IntPtr hMem); + + [DllImport ("kernel32.dll", EntryPoint="GlobalLock", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32GlobalLock(IntPtr hMem); + + [DllImport ("kernel32.dll", EntryPoint="GlobalUnlock", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32GlobalUnlock(IntPtr hMem); + + [DllImport ("gdi32.dll", EntryPoint="SetROP2", CallingConvention=CallingConvention.StdCall)] + internal extern static int Win32SetROP2(IntPtr hdc, ROP2DrawMode fnDrawMode); + + [DllImport ("gdi32.dll", EntryPoint="MoveToEx", CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32MoveToEx(IntPtr hdc, int x, int y, ref POINT lpPoint); + + [DllImport ("gdi32.dll", EntryPoint="MoveToEx", CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32MoveToEx(IntPtr hdc, int x, int y, IntPtr lpPoint); + + [DllImport ("gdi32.dll", EntryPoint="LineTo", CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32LineTo(IntPtr hdc, int x, int y); + + [DllImport ("gdi32.dll", EntryPoint="CreatePen", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32CreatePen(PenStyle fnPenStyle, int nWidth, ref COLORREF color); + + [DllImport ("gdi32.dll", EntryPoint="CreatePen", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32CreatePen(PenStyle fnPenStyle, int nWidth, IntPtr color); + + [DllImport ("gdi32.dll", EntryPoint="GetStockObject", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32GetStockObject(StockObject fnObject); + + [DllImport ("gdi32.dll", EntryPoint="CreateHatchBrush", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32CreateHatchBrush(HatchStyle fnStyle, IntPtr color); + + [DllImport ("gdi32.dll", EntryPoint="CreateHatchBrush", CallingConvention=CallingConvention.StdCall)] + internal extern static IntPtr Win32CreateHatchBrush(HatchStyle fnStyle, ref COLORREF color); + + [DllImport("gdi32.dll", EntryPoint = "ExcludeClipRect", CallingConvention = CallingConvention.StdCall)] + internal extern static int Win32ExcludeClipRect (IntPtr hdc, int left, int top, int right, int bottom); + + [DllImport ("gdi32.dll", EntryPoint="ExtSelectClipRgn", CallingConvention=CallingConvention.StdCall)] + internal extern static int Win32ExtSelectClipRgn(IntPtr hdc, IntPtr hrgn, int mode); + + [DllImport ("winmm.dll", EntryPoint="PlaySoundW", CallingConvention=CallingConvention.StdCall, CharSet=CharSet.Unicode)] + internal extern static IntPtr Win32PlaySound(string pszSound, IntPtr hmod, SndFlags fdwSound); + + [DllImport ("user32.dll", EntryPoint="GetDoubleClickTime", CallingConvention=CallingConvention.StdCall, CharSet=CharSet.Unicode)] + private extern static int Win32GetDoubleClickTime (); + + [DllImport ("user32.dll", EntryPoint="SetWindowRgn", CallingConvention=CallingConvention.StdCall, CharSet=CharSet.Unicode)] + internal extern static int Win32SetWindowRgn(IntPtr hWnd, IntPtr hRgn, bool redraw); + + [DllImport ("user32.dll", EntryPoint="GetWindowRgn", CallingConvention=CallingConvention.StdCall, CharSet=CharSet.Unicode)] + internal extern static IntPtr Win32GetWindowRgn(IntPtr hWnd, IntPtr hRgn); + + [DllImport ("user32.dll", EntryPoint="ClipCursor", CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32ClipCursor (ref RECT lpRect); + + [DllImport ("user32.dll", EntryPoint="GetClipCursor", CallingConvention=CallingConvention.StdCall)] + internal extern static bool Win32GetClipCursor (out RECT lpRect); + + [DllImport ("gdi32.dll", EntryPoint="BitBlt", CallingConvention=CallingConvention.StdCall)] + internal static extern bool Win32BitBlt (IntPtr hObject, int nXDest, int nYDest, int nWidth, + int nHeight, IntPtr hObjSource, int nXSrc, int nYSrc, TernaryRasterOperations dwRop); + + [DllImport ("gdi32.dll", EntryPoint="CreateCompatibleDC", CallingConvention=CallingConvention.StdCall, ExactSpelling = true, SetLastError = true)] + internal static extern IntPtr Win32CreateCompatibleDC (IntPtr hdc); + + [DllImport ("gdi32.dll", EntryPoint="DeleteDC", CallingConvention=CallingConvention.StdCall, ExactSpelling = true, SetLastError = true)] + internal static extern bool Win32DeleteDC (IntPtr hdc); + + [DllImport ("gdi32.dll", EntryPoint="CreateCompatibleBitmap", CallingConvention=CallingConvention.StdCall)] + internal static extern IntPtr Win32CreateCompatibleBitmap (IntPtr hdc, int nWidth, int nHeight); + + [DllImport ("kernel32.dll", EntryPoint = "GetSystemPowerStatus", CallingConvention = CallingConvention.StdCall)] + internal static extern Boolean Win32GetSystemPowerStatus (SYSTEMPOWERSTATUS sps); + + [DllImport ("user32.dll", EntryPoint = "GetIconInfo", CallingConvention = CallingConvention.StdCall)] + internal static extern bool Win32GetIconInfo (IntPtr hIcon, out ICONINFO piconinfo); + + [DllImport ("user32.dll", EntryPoint="SetForegroundWindow", CallingConvention=CallingConvention.StdCall)] + extern static bool Win32SetForegroundWindow(IntPtr hWnd); + #endregion + } +} diff --git a/source/ShiftUI/Internal/XplatUIX11-new.cs b/source/ShiftUI/Internal/XplatUIX11-new.cs new file mode 100644 index 0000000..3795406 --- /dev/null +++ b/source/ShiftUI/Internal/XplatUIX11-new.cs @@ -0,0 +1,1079 @@ +// 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) 2004-2006 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// Chris Toshok [email protected] +// +// + +// NOTE: +// This driver understands the following environment variables: (Set the var to enable feature) +// +// MONO_XEXCEPTIONS = throw an exception when a X11 error is encountered; +// by default a message is displayed but execution continues +// +// MONO_XSYNC = perform all X11 commands synchronous; this is slower but +// helps in debugging errors +// + +// NOT COMPLETE + +// define to log Window handles and relationships to stdout +#undef DriverDebug + +// Extra detailed debug +#undef DriverDebugExtra +#undef DriverDebugParent +#undef DriverDebugCreate +#undef DriverDebugDestroy +#undef DriverDebugThreads +#undef DriverDebugXEmbed + +using System; +using System.ComponentModel; +using System.Collections; +using System.Diagnostics; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Drawing.Imaging; +using System.IO; +using System.Net; +using System.Net.Sockets; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; +using ShiftUI; + +/// X11 Version +namespace ShiftUI.X11Internal { + internal class XplatUIX11_new : XplatUIX11 { + + + #region Local Variables + // General + static volatile XplatUIX11_new Instance; + static readonly object lockobj = new object (); + static int RefCount; + static bool themes_enabled; + + static Hashtable MessageQueues; // Holds our thread-specific X11ThreadQueues + + X11Display display; + + #endregion // Local Variables + #region Constructors + private XplatUIX11_new() { + // Handle singleton stuff first + RefCount = 0; + + // Now regular initialization + MessageQueues = Hashtable.Synchronized (new Hashtable(7)); + if (Xlib.XInitThreads() == 0) { + Console.WriteLine ("Failed XInitThreads. The X11 event loop will not function properly"); + } + } + + private void InitializeDisplay () + { + display = new X11Display (Xlib.XOpenDisplay(IntPtr.Zero)); + + Graphics.FromHdcInternal (display.Handle); + } + + ~XplatUIX11_new() { + // Remove our display handle from S.D + Graphics.FromHdcInternal (IntPtr.Zero); + } + + #endregion // Constructors + + #region Singleton Specific Code + public static XplatUIX11_new GetInstance() { + lock (lockobj) { + if (Instance == null) { + Instance = new XplatUIX11_new (); + + Instance.InitializeDisplay (); + } + RefCount++; + } + return Instance; + } + + public int Reference { + get { + return RefCount; + } + } + #endregion + + #region Internal Methods + internal static void Where() { + Console.WriteLine("Here: {0}\n", GetInstance().display.WhereString()); + } + + #endregion // Internal Methods + + #region Private Methods + + internal X11ThreadQueue ThreadQueue (Thread thread) + { + X11ThreadQueue queue; + + queue = (X11ThreadQueue)MessageQueues[thread]; + if (queue == null) { + queue = new X11ThreadQueue(thread); + MessageQueues[thread] = queue; + } + + return queue; + } + #endregion // Private Methods + + + #region Public Properties + internal override int CaptionHeight { + get { return 19; } + } + + internal override Size CursorSize { + get { return display.CursorSize; } + } + + internal override bool DragFullWindows { + get { return true; } + } + + internal override Size DragSize { + get { return new Size(4, 4); } + } + + internal override Size FrameBorderSize { + get { return new Size (4, 4); } + } + + internal override Size IconSize { + get { return display.IconSize; } + } + + internal override int KeyboardSpeed { + get { return display.KeyboardSpeed; } + } + + internal override int KeyboardDelay { + get { return display.KeyboardSpeed; } + } + + internal override Size MaxWindowTrackSize { + get { return new Size (WorkingArea.Width, WorkingArea.Height); } + } + + internal override bool MenuAccessKeysUnderlined { + get { + return false; + } + } + + internal override Size MinimizedWindowSpacingSize { + get { return new Size(1, 1); } + } + + internal override Size MinimumWindowSize { + get { return new Size(1, 1); } + } + + internal override Keys ModifierKeys { + get { return display.ModifierKeys; } + } + + internal override Size SmallIconSize { + get { return display.SmallIconSize; } + } + + internal override int MouseButtonCount { + get { return 3; /* FIXME - should detect this somehow.. */} + } + + internal override bool MouseButtonsSwapped { + get { return false; /*FIXME - how to detect? */} + } + + internal override Size MouseHoverSize { + get { return new Size (1, 1); } + } + + internal override int MouseHoverTime { + get { return display.MouseHoverTime; } + } + + internal override bool MouseWheelPresent { + get { return true; /* FIXME - how to detect? */ } + } + + internal override Rectangle VirtualScreen { + get { return display.VirtualScreen; } + } + + internal override Rectangle WorkingArea { + get { return display.WorkingArea; } + } + + internal override bool ThemesEnabled { + get { return XplatUIX11_new.themes_enabled; } + } + + + #endregion // Public properties + + #region Public Static Methods + internal override void RaiseIdle (EventArgs e) + { + X11ThreadQueue queue = ThreadQueue (Thread.CurrentThread); + queue.OnIdle (e); + } + + internal override IntPtr InitializeDriver () + { + lock (this) { + if (display == null) + display = new X11Display (Xlib.XOpenDisplay(IntPtr.Zero)); + } + return IntPtr.Zero; + } + + internal override void ShutdownDriver(IntPtr token) + { + lock (this) { + if (display != null) { + display.Close (); + display = null; + } + } + } + + internal override void EnableThemes() + { + themes_enabled = true; + } + + internal override void Activate (IntPtr handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.Activate (); + } + + internal override void AudibleAlert(AlertType atype) + { + display.AudibleAlert (); + } + + + internal override void CaretVisible (IntPtr handle, bool visible) + { + display.CaretVisible (handle, visible); + } + + // XXX this implementation should probably be shared between all non-win32 backends + internal override bool CalculateWindowRect (ref Rectangle ClientRect, CreateParams cp, Menu menu, out Rectangle WindowRect) + { + WindowRect = Hwnd.GetWindowRectangle (cp, menu, ClientRect); + return true; + } + + internal override void ClientToScreen (IntPtr handle, ref int x, ref int y) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.ClientToScreen (ref x, ref y); + } + + internal override void CreateCaret (IntPtr handle, int width, int height) + { + display.CreateCaret (handle, width, height); + } + + internal override IntPtr CreateWindow (CreateParams cp) + { + X11Hwnd hwnd = new X11Hwnd (display); + + hwnd.CreateWindow (cp); + + return hwnd.Handle; + } + + internal override IntPtr CreateWindow (IntPtr Parent, int X, int Y, int Width, int Height) + { + CreateParams create_params = new CreateParams(); + + create_params.Caption = ""; + create_params.X = X; + create_params.Y = Y; + create_params.Width = Width; + create_params.Height = Height; + + create_params.ClassName = XplatUI.DefaultClassName; + create_params.ClassStyle = 0; + create_params.ExStyle = 0; + create_params.Parent = IntPtr.Zero; + create_params.Param = 0; + + return CreateWindow (create_params); + } + + internal override IntPtr DefineCursor (Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot) + { + return display.DefineCursor (bitmap, mask, cursor_pixel, mask_pixel, xHotSpot, yHotSpot); + } + internal override Bitmap DefineStdCursorBitmap (StdCursor id) + { + return display.DefineStdCursorBitmap (id); + } + internal override IntPtr DefineStdCursor (StdCursor id) + { + return display.DefineStdCursor (id); + } + + internal override IntPtr DefWndProc(ref Message msg) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.GetObjectFromWindow(msg.HWnd); + + if (hwnd == null) + return IntPtr.Zero; + + return hwnd.DefWndProc (ref msg); + } + + internal override void DestroyCaret (IntPtr handle) + { + display.DestroyCaret (handle); + } + + internal override void DestroyCursor(IntPtr cursor) + { + display.DestroyCursor (cursor); + } + + internal override void DestroyWindow (IntPtr handle) { + X11Hwnd hwnd; + + hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd == null) { +#if DriverDebug || DriverDebugDestroy + Console.WriteLine("window {0:X} already destroyed", handle.ToInt32()); +#endif + return; + } + +#if DriverDebug || DriverDebugDestroy + Console.WriteLine("Destroying window {0}", XplatUI.Window(hwnd.ClientWindow)); +#endif + + display.DestroyWindow (hwnd); + } + + internal override IntPtr DispatchMessage(ref MSG msg) + { + return display.DispatchMessage (ref msg); + } + + internal override void DrawReversibleLine (Point start, Point end, Color backColor) + { + display.DrawReversibleLine (start, end, backColor); + } + + internal override void FillReversibleRectangle (Rectangle rectangle, Color backColor) + { + display.FillReversibleRectangle (rectangle, backColor); + } + + internal override void DrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style) + { + display.DrawReversibleFrame (rectangle, backColor, style); + } + + internal override void DrawReversibleRectangle (IntPtr handle, Rectangle rect, int line_width) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.DrawReversibleRectangle (rect, line_width); + } + + internal override void DoEvents () + { + X11ThreadQueue queue = ThreadQueue (Thread.CurrentThread); + display.DoEvents (queue); + } + + internal override void EnableWindow (IntPtr handle, bool Enable) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + if (hwnd != null) + hwnd.Enabled = Enable; + } + + internal override void EndLoop (Thread thread) + { + // This is where we one day will shut down the loop for the thread + } + + + internal override IntPtr GetActive() + { + X11Hwnd hwnd = display.GetActiveWindow (); + + return (hwnd == null) ? IntPtr.Zero : hwnd.Handle; + } + + internal override Region GetClipRegion (IntPtr handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + return (hwnd == null) ? null : hwnd.GetClipRegion (); + } + + internal override void GetCursorInfo(IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y) + { + width = 20; + height = 20; + hotspot_x = 0; + hotspot_y = 0; + } + + internal override void GetDisplaySize(out Size size) + { + display.GetDisplaySize (out size); + } + + internal override SizeF GetAutoScaleSize (Font font) + { + return display.GetAutoScaleSize (font); + } + + // XXX this should be someplace shareable by all non-win32 backends.. like in Hwnd itself. + // maybe a Hwnd.ParentHandle property + internal override IntPtr GetParent (IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + if (hwnd != null && hwnd.parent != null) { + return hwnd.parent.Handle; + } + return IntPtr.Zero; + } + + // This is a nop on win32 and x11 + internal override IntPtr GetPreviousWindow(IntPtr handle) { + return handle; + } + + internal override void GetCursorPos (IntPtr handle, out int x, out int y) + { + display.GetCursorPos ((X11Hwnd)Hwnd.ObjectFromHandle(handle), + out x, out y); + } + + internal override IntPtr GetFocus() + { + return display.GetFocus (); + } + + // XXX this should be shared amongst non-win32 backends + internal override bool GetFontMetrics (Graphics g, Font font, out int ascent, out int descent) + { + FontFamily ff = font.FontFamily; + ascent = ff.GetCellAscent (font.Style); + descent = ff.GetCellDescent (font.Style); + return true; + } + + + // XXX this should be shared amongst non-win32 backends + internal override Point GetMenuOrigin (IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + return hwnd.MenuOrigin; + + return Point.Empty; + } + + internal override bool GetMessage (object queue_id, ref MSG msg, IntPtr handle, int wFilterMin, int wFilterMax) + { + return display.GetMessage (queue_id, ref msg, handle, wFilterMin, wFilterMax); + } + + internal override bool GetText (IntPtr handle, out string text) + { + X11Hwnd hwnd = (X11Hwnd) Hwnd.ObjectFromHandle(handle); + + text = ""; + return hwnd != null && hwnd.GetText (out text); + } + + internal override void GetWindowPos (IntPtr handle, bool is_toplevel, + out int x, out int y, + out int width, out int height, + out int client_width, out int client_height) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) { + hwnd.GetPosition (is_toplevel, out x, out y, out width, out height, out client_width, out client_height); + } + else { + // Should we throw an exception or fail silently? + // throw new ArgumentException("Called with an invalid window handle", "handle"); + + x = 0; + y = 0; + width = 0; + height = 0; + client_width = 0; + client_height = 0; + } + } + + internal override FormWindowState GetWindowState (IntPtr handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd == null) + return FormWindowState.Normal; // XXX should we throw an exception here? probably + + return hwnd.GetWindowState (); + } + + internal override void GrabInfo (out IntPtr handle, out bool GrabConfined, out Rectangle GrabArea) + { + display.GrabInfo (out handle, out GrabConfined, out GrabArea); + } + + internal override void GrabWindow (IntPtr handle, IntPtr confine_to_handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + X11Hwnd confine_to_hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(confine_to_handle); + + display.GrabWindow (hwnd, confine_to_hwnd); + } + + internal override void UngrabWindow (IntPtr handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + display.UngrabWindow (hwnd); + } + + internal override void HandleException(Exception e) { + StackTrace st = new StackTrace(e, true); + Console.WriteLine("Exception '{0}'", e.Message+st.ToString()); + Console.WriteLine("{0}{1}", e.Message, st.ToString()); + } + + internal override void Invalidate (IntPtr handle, Rectangle rc, bool clear) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + hwnd.Invalidate (rc, clear); + } + + internal override void InvalidateNC (IntPtr handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + hwnd.InvalidateNC (); + } + + internal override bool IsEnabled(IntPtr handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle (handle); + + return hwnd != null && hwnd.Enabled; + } + + internal override bool IsVisible(IntPtr handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle (handle); + + return hwnd != null && hwnd.Visible; + } + + internal override void KillTimer (Timer timer) + { + X11ThreadQueue queue = (X11ThreadQueue) MessageQueues [timer.thread]; + + if (queue == null) { + // This isn't really an error, MS doesn't start the timer if + // it has no assosciated queue + return; + } + queue.KillTimer (timer); + } + + internal override void MenuToScreen (IntPtr handle, ref int x, ref int y) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.MenuToScreen (ref x, ref y); + } + + internal override void OverrideCursor (IntPtr cursor) + { + display.OverrideCursor = cursor; + } + + internal override PaintEventArgs PaintEventStart (ref Message m, IntPtr handle, bool client) + { + return display.PaintEventStart (ref m, handle, client); + } + + internal override void PaintEventEnd (ref Message m, IntPtr handle, bool client) + { + display.PaintEventEnd (ref m, handle, client); + } + + + internal override bool PeekMessage (object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags) + { + return display.PeekMessage (queue_id, ref msg, hWnd, wFilterMin, wFilterMax, flags); + } + + internal override bool PostMessage (IntPtr handle, Msg message, IntPtr wparam, IntPtr lparam) + { + return display.PostMessage (handle, message, wparam, lparam); + } + + internal override void PostQuitMessage(int exitCode) + { + display.PostMessage (display.FosterParent.Handle, Msg.WM_QUIT, IntPtr.Zero, IntPtr.Zero); + display.Flush (); + } + + [MonoTODO] + internal override void RequestAdditionalWM_NCMessages (IntPtr handle, bool hover, bool leave) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.RequestAdditionalWM_NCMessages (hover, leave); + } + + internal override void RequestNCRecalc (IntPtr handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.RequestNCRecalc (); + } + + internal override void ResetMouseHover (IntPtr handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + display.ResetMouseHover (hwnd); + } + + internal override void ScreenToClient(IntPtr handle, ref int x, ref int y) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.ScreenToClient (ref x, ref y); + } + + internal override void ScreenToMenu (IntPtr handle, ref int x, ref int y) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.ScreenToMenu (ref x, ref y); + } + + internal override void ScrollWindow (IntPtr handle, Rectangle area, int XAmount, int YAmount, bool with_children) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.ScrollWindow (area, XAmount, YAmount, with_children); + } + + internal override void ScrollWindow(IntPtr handle, int XAmount, int YAmount, bool with_children) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.GetObjectFromWindow(handle); + + if (hwnd != null) { + Rectangle rect; + + rect = hwnd.ClientRect; + rect.X = 0; + rect.Y = 0; + hwnd.ScrollWindow (rect, XAmount, YAmount, with_children); + } + } + + internal override void SendAsyncMethod (AsyncMethodData method) + { + display.SendAsyncMethod (method); + } + + // XXX this is likely shareable amongst other backends + internal override IntPtr SendMessage (IntPtr handle, Msg message, IntPtr wParam, IntPtr lParam) + { + return display.SendMessage (handle, message, wParam, lParam); + } + + internal override int SendInput(IntPtr handle, Queue keys) { + return display.SendInput(handle, keys); + } + + + internal override void SetAllowDrop (IntPtr handle, bool value) + { + // We allow drop on all windows + } + + internal override DragDropEffects StartDrag (IntPtr handle, object data, + DragDropEffects allowed_effects) + { + return display.StartDrag (handle, data, allowed_effects); + } + + internal override void SetBorderStyle (IntPtr handle, FormBorderStyle border_style) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.SetBorderStyle (border_style); + } + + internal override void SetCaretPos (IntPtr handle, int x, int y) + { + display.SetCaretPos (handle, x, y); + } + + internal override void SetClipRegion (IntPtr handle, Region region) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.SetClipRegion (region); + } + + internal override void SetCursor (IntPtr handle, IntPtr cursor) + { + display.SetCursor (handle, cursor); + } + + internal override void SetCursorPos (IntPtr handle, int x, int y) + { + if (handle == IntPtr.Zero) { + display.SetCursorPos (x, y); + } + else { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + hwnd.SetCursorPos (x, y); + } + } + + internal override void SetFocus (IntPtr handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + display.SetFocus (hwnd); + } + + internal override void SetIcon(IntPtr handle, Icon icon) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle);; + + if (hwnd != null) + hwnd.SetIcon (icon); + } + + internal override void SetMenu(IntPtr handle, Menu menu) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + hwnd.SetMenu (menu); + } + + internal override void SetModal(IntPtr handle, bool Modal) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + display.SetModal (hwnd, Modal); + } + + internal override IntPtr SetParent(IntPtr handle, IntPtr parent) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + X11Hwnd parent_hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(parent); + + if (hwnd != null) + hwnd.SetParent (parent_hwnd); + + return IntPtr.Zero; + } + + internal override void SetTimer (Timer timer) + { + X11ThreadQueue queue = (X11ThreadQueue) MessageQueues [timer.thread]; + + if (queue == null) { + // This isn't really an error, MS doesn't start the timer if + // it has no assosciated queue + return; + } + queue.SetTimer (timer); + } + + internal override bool SetTopmost(IntPtr handle, bool enabled) + { + X11Hwnd hwnd = (X11Hwnd) Hwnd.ObjectFromHandle (handle); + + if (hwnd == null) + return false; + + return hwnd.SetTopmost (enabled); + } + + internal override bool SetOwner(IntPtr handle, IntPtr handle_owner) + { + X11Hwnd hwnd; + + hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd == null) + return false; + + X11Hwnd hwnd_owner = (X11Hwnd)Hwnd.ObjectFromHandle(handle_owner); + + return hwnd.SetOwner (hwnd_owner); + } + + internal override bool SetVisible (IntPtr handle, bool visible, bool activate) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + return hwnd != null && hwnd.SetVisible (visible, activate); + } + + internal override void SetWindowMinMax (IntPtr handle, Rectangle maximized, Size min, Size max) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd == null) + return; + + hwnd.SetMinMax (maximized, min, max); + } + + internal override void SetWindowPos (IntPtr handle, int x, int y, int width, int height) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.SetPosition (x, y, width, height); + } + + internal override void SetWindowState (IntPtr handle, FormWindowState state) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.SetWindowState (state); + } + + internal override void SetWindowStyle (IntPtr handle, CreateParams cp) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) { + hwnd.SetHwndStyles (cp); + hwnd.SetWMStyles (cp); + } + } + + internal override double GetWindowTransparency (IntPtr handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + return hwnd.GetWindowTransparency (); + else + return 0.0; + } + + internal override void SetWindowTransparency (IntPtr handle, double transparency, Color key) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.SetWindowTransparency (transparency, key); + } + + internal override bool SetZOrder (IntPtr handle, IntPtr after_handle, bool top, bool bottom) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd == null || !hwnd.mapped) + return false; + + X11Hwnd after_hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(after_handle); + + return hwnd.SetZOrder (after_hwnd, top, bottom); + } + + internal override void ShowCursor (bool show) + { + display.ShowCursor (show); + } + + internal override object StartLoop(Thread thread) + { + return (object) ThreadQueue(thread); + } + + internal override TransparencySupport SupportsTransparency() + { + return display.SupportsTransparency (); + } + + internal override bool SystrayAdd (IntPtr handle, string tip, Icon icon, out ToolTip tt) + { + return display.SystrayAdd (handle, tip, icon, out tt); + } + + internal override bool SystrayChange (IntPtr handle, string tip, Icon icon, ref ToolTip tt) + { + return display.SystrayChange (handle, tip, icon, ref tt); + } + + internal override void SystrayRemove (IntPtr handle, ref ToolTip tt) + { + display.SystrayRemove (handle, ref tt); + } + + NotifyIcon.BalloonWindow balloon_window; + + internal override void SystrayBalloon(IntPtr handle, int timeout, string title, string text, ToolTipIcon icon) + { + Widget control = Widget.FromHandle(handle); + + if (control == null) + return; + + if (balloon_window != null) { + balloon_window.Close (); + balloon_window.Dispose (); + } + + balloon_window = new NotifyIcon.BalloonWindow (handle); + balloon_window.Title = title; + balloon_window.Text = text; + balloon_window.Timeout = timeout; + balloon_window.Show (); + + SendMessage(handle, Msg.WM_USER, IntPtr.Zero, (IntPtr) Msg.NIN_BALLOONSHOW); + } + + internal override bool Text (IntPtr handle, string text) + { + X11Hwnd hwnd = (X11Hwnd) Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.Text = text; + + return true; + } + + internal override bool TranslateMessage (ref MSG msg) + { + return display.TranslateMessage (ref msg); + } + + internal override void UpdateWindow (IntPtr handle) + { + X11Hwnd hwnd = (X11Hwnd)Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) + hwnd.Update (); + } + + internal override void CreateOffscreenDrawable (IntPtr handle, + int width, int height, + out object offscreen_drawable) + { + display.CreateOffscreenDrawable (handle, width, height, + out offscreen_drawable); + } + + internal override void DestroyOffscreenDrawable (object offscreen_drawable) + { + display.DestroyOffscreenDrawable (offscreen_drawable); + } + + internal override Graphics GetOffscreenGraphics (object offscreen_drawable) + { + return display.GetOffscreenGraphics (offscreen_drawable); + } + + internal override void BlitFromOffscreen (IntPtr dest_handle, + Graphics dest_dc, + object offscreen_drawable, + Graphics offscreen_dc, + Rectangle r) + { + display.BlitFromOffscreen (dest_handle, dest_dc, offscreen_drawable, offscreen_dc, r); + } + + #endregion // Public Static Methods + + #region Events + internal override event EventHandler Idle { + add { + Console.WriteLine ("adding idle handler for thread {0}", Thread.CurrentThread.GetHashCode()); + X11ThreadQueue queue = ThreadQueue(Thread.CurrentThread); + queue.Idle += value; + } + remove { + X11ThreadQueue queue = ThreadQueue(Thread.CurrentThread); + queue.Idle += value; + } + } + #endregion // Events + } +} diff --git a/source/ShiftUI/Internal/XplatUIX11.cs b/source/ShiftUI/Internal/XplatUIX11.cs new file mode 100644 index 0000000..fd68bab --- /dev/null +++ b/source/ShiftUI/Internal/XplatUIX11.cs @@ -0,0 +1,7687 @@ +// 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) 2004-2006 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// +// + +// NOTE: +// This driver understands the following environment variables: (Set the var to enable feature) +// +// MONO_XEXCEPTIONS = throw an exception when a X11 error is encountered; +// by default a message is displayed but execution continues +// +// MONO_XSYNC = perform all X11 commands synchronous; this is slower but +// helps in debugging errors +// + +// NOT COMPLETE + +// define to log Window handles and relationships to stdout +#undef DriverDebug + +// Extra detailed debug +#undef DriverDebugExtra +#undef DriverDebugParent +#undef DriverDebugCreate +#undef DriverDebugDestroy +#undef DriverDebugThreads +#undef DriverDebugXEmbed + +//#define TRACE +//#define DEBUG + +using System; +using System.ComponentModel; +using System.Collections; +using System.Diagnostics; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Drawing.Imaging; +using System.IO; +using System.Net; +using System.Net.Sockets; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Runtime.Serialization; +using System.Runtime.Serialization.Formatters.Binary; +using System.Text; +using System.Threading; + +// Only do the poll when building with mono for now +#if __MonoCS__ +using Mono.Unix.Native; +#endif + +/// X11 Version +namespace ShiftUI { + internal class XplatUIX11 : XplatUIDriver { + #region Local Variables + // General + static volatile XplatUIX11 Instance; + static int RefCount; + static object XlibLock; // Our locking object + static bool themes_enabled; + + // General X11 + static IntPtr DisplayHandle; // X11 handle to display + static int ScreenNo; // Screen number used + static IntPtr DefaultColormap; // Colormap for screen + static IntPtr CustomVisual; // Visual for window creation + static IntPtr CustomColormap; // Colormap for window creation + static IntPtr RootWindow; // Handle of the root window for the screen/display + static IntPtr FosterParent; // Container to hold child windows until their parent exists + static XErrorHandler ErrorHandler; // Error handler delegate + static bool ErrorExceptions; // Throw exceptions on X errors + int render_major_opcode; + int render_first_event; + int render_first_error; + + // Clipboard + static IntPtr ClipMagic; + static ClipboardData Clipboard; // Our clipboard + + // Communication + static IntPtr PostAtom; // PostMessage atom + static IntPtr AsyncAtom; // Support for async messages + + // Message Loop + static Hashtable MessageQueues; // Holds our thread-specific XEventQueues + static ArrayList unattached_timer_list; // holds timers that are enabled but not attached to a window. + #if __MonoCS__ // + static Pollfd[] pollfds; // For watching the X11 socket + static bool wake_waiting; + static object wake_waiting_lock = new object (); + #endif // + static X11Keyboard Keyboard; // + static X11Dnd Dnd; + static Socket listen; // + static Socket wake; // + static Socket wake_receive; // + static byte[] network_buffer; // + static bool detectable_key_auto_repeat; + + // Focus tracking + static IntPtr ActiveWindow; // Handle of the active window + static IntPtr FocusWindow; // Handle of the window with keyboard focus (if any) + + // Modality support + static Stack ModalWindows; // Stack of our modal windows + + // Systray + static IntPtr SystrayMgrWindow; // Handle of the Systray Manager window + + // Cursors + static IntPtr LastCursorWindow; // The last window we set the cursor on + static IntPtr LastCursorHandle; // The handle that was last set on LastCursorWindow + static IntPtr OverrideCursorHandle; // The cursor that is set to override any other cursors + + // Caret + static CaretStruct Caret; // + + // Last window containing the pointer + static IntPtr LastPointerWindow; // The last window containing the pointer + + // Our atoms + static IntPtr WM_PROTOCOLS; + static IntPtr WM_DELETE_WINDOW; + static IntPtr WM_TAKE_FOCUS; + //static IntPtr _NET_SUPPORTED; + //static IntPtr _NET_CLIENT_LIST; + //static IntPtr _NET_NUMBER_OF_DESKTOPS; + static IntPtr _NET_DESKTOP_GEOMETRY; + //static IntPtr _NET_DESKTOP_VIEWPORT; + static IntPtr _NET_CURRENT_DESKTOP; + //static IntPtr _NET_DESKTOP_NAMES; + static IntPtr _NET_ACTIVE_WINDOW; + static IntPtr _NET_WORKAREA; + //static IntPtr _NET_SUPPORTING_WM_CHECK; + //static IntPtr _NET_VIRTUAL_ROOTS; + //static IntPtr _NET_DESKTOP_LAYOUT; + //static IntPtr _NET_SHOWING_DESKTOP; + //static IntPtr _NET_CLOSE_WINDOW; + //static IntPtr _NET_MOVERESIZE_WINDOW; + static IntPtr _NET_WM_MOVERESIZE; + //static IntPtr _NET_RESTACK_WINDOW; + //static IntPtr _NET_REQUEST_FRAME_EXTENTS; + static IntPtr _NET_WM_NAME; + //static IntPtr _NET_WM_VISIBLE_NAME; + //static IntPtr _NET_WM_ICON_NAME; + //static IntPtr _NET_WM_VISIBLE_ICON_NAME; + //static IntPtr _NET_WM_DESKTOP; + static IntPtr _NET_WM_WINDOW_TYPE; + static IntPtr _NET_WM_STATE; + //static IntPtr _NET_WM_ALLOWED_ACTIONS; + //static IntPtr _NET_WM_STRUT; + //static IntPtr _NET_WM_STRUT_PARTIAL; + //static IntPtr _NET_WM_ICON_GEOMETRY; + static IntPtr _NET_WM_ICON; + //static IntPtr _NET_WM_PID; + //static IntPtr _NET_WM_HANDLED_ICONS; + static IntPtr _NET_WM_USER_TIME; + static IntPtr _NET_FRAME_EXTENTS; + //static IntPtr _NET_WM_PING; + //static IntPtr _NET_WM_SYNC_REQUEST; + static IntPtr _NET_SYSTEM_TRAY_S; + //static IntPtr _NET_SYSTEM_TRAY_ORIENTATION; + static IntPtr _NET_SYSTEM_TRAY_OPCODE; + static IntPtr _NET_WM_STATE_MAXIMIZED_HORZ; + static IntPtr _NET_WM_STATE_MAXIMIZED_VERT; + static IntPtr _XEMBED; + static IntPtr _XEMBED_INFO; + static IntPtr _MOTIF_WM_HINTS; + static IntPtr _NET_WM_STATE_SKIP_TASKBAR; + static IntPtr _NET_WM_STATE_ABOVE; + static IntPtr _NET_WM_STATE_MODAL; + static IntPtr _NET_WM_STATE_HIDDEN; + static IntPtr _NET_WM_CONTEXT_HELP; + static IntPtr _NET_WM_WINDOW_OPACITY; + //static IntPtr _NET_WM_WINDOW_TYPE_DESKTOP; + //static IntPtr _NET_WM_WINDOW_TYPE_DOCK; + //static IntPtr _NET_WM_WINDOW_TYPE_TOOLBAR; + //static IntPtr _NET_WM_WINDOW_TYPE_MENU; + static IntPtr _NET_WM_WINDOW_TYPE_UTILITY; + //static IntPtr _NET_WM_WINDOW_TYPE_SPLASH; + // static IntPtr _NET_WM_WINDOW_TYPE_DIALOG; + static IntPtr _NET_WM_WINDOW_TYPE_NORMAL; + static IntPtr CLIPBOARD; + static IntPtr PRIMARY; + //static IntPtr DIB; + static IntPtr OEMTEXT; + static IntPtr UTF8_STRING; + static IntPtr UTF16_STRING; + static IntPtr RICHTEXTFORMAT; + static IntPtr TARGETS; + + // mouse hover message generation + static HoverStruct HoverState; // + + // double click message generation + static ClickStruct ClickPending; // + + // Support for mouse grab + static GrabStruct Grab; // + + // State + Point mouse_position; // Last position of mouse, in screen coords + internal static MouseButtons MouseState; // Last state of mouse buttons + internal static bool in_doevents; + // 'Constants' + static int DoubleClickInterval; // msec; max interval between clicks to count as double click + + const EventMask SelectInputMask = (EventMask.ButtonPressMask | + EventMask.ButtonReleaseMask | + EventMask.KeyPressMask | + EventMask.KeyReleaseMask | + EventMask.EnterWindowMask | + EventMask.LeaveWindowMask | + EventMask.ExposureMask | + EventMask.FocusChangeMask | + EventMask.PointerMotionMask | + EventMask.PointerMotionHintMask | + EventMask.SubstructureNotifyMask); + + static readonly object lockobj = new object (); + + // messages WaitForHwndMwssage is waiting on + static Hashtable messageHold; + + #endregion // Local Variables + #region Constructors + public XplatUIX11() + { + // Handle singleton stuff first + RefCount = 0; + in_doevents = false; + + // Now regular initialization + XlibLock = new object (); + X11Keyboard.XlibLock = XlibLock; + MessageQueues = Hashtable.Synchronized (new Hashtable(7)); + unattached_timer_list = ArrayList.Synchronized (new ArrayList (3)); + messageHold = Hashtable.Synchronized (new Hashtable(3)); + Clipboard = new ClipboardData (); + XInitThreads(); + + ErrorExceptions = false; + + // X11 Initialization + SetDisplay(XOpenDisplay(IntPtr.Zero)); + X11DesktopColors.Initialize(); + + + // Disable keyboard autorepeat + try { + XkbSetDetectableAutoRepeat (DisplayHandle, true, IntPtr.Zero); + detectable_key_auto_repeat = true; + } catch { + Console.Error.WriteLine ("Could not disable keyboard auto repeat, will attempt to disable manually."); + detectable_key_auto_repeat = false; + } + + // Handle any upcoming errors; we re-set it here, X11DesktopColor stuff might have stolen it (gtk does) + ErrorHandler = new XErrorHandler(HandleError); + XSetErrorHandler(ErrorHandler); + } + + ~XplatUIX11() { + // Remove our display handle from S.D + Graphics.FromHdcInternal (IntPtr.Zero); + } + + #endregion // Constructors + + #region Singleton Specific Code + public static XplatUIX11 GetInstance() { + lock (lockobj) { + if (Instance == null) { + Instance=new XplatUIX11(); + } + RefCount++; + } + return Instance; + } + + public int Reference { + get { + return RefCount; + } + } + #endregion + + #region Internal Properties + internal static IntPtr Display { + get { + return DisplayHandle; + } + + set { + XplatUIX11.GetInstance().SetDisplay(value); + } + } + + internal static int Screen { + get { + return ScreenNo; + } + + set { + ScreenNo = value; + } + } + + internal static IntPtr RootWindowHandle { + get { + return RootWindow; + } + + set { + RootWindow = value; + } + } + + internal static IntPtr Visual { + get { + return CustomVisual; + } + + set { + CustomVisual = value; + } + } + + internal static IntPtr ColorMap { + get { + return CustomColormap; + } + + set { + CustomColormap = value; + } + } + +#if DEBUG_shana + internal static IntPtr DefaultColorMap { + get { + return DefaultColormap; + } + } +#endif + #endregion + + #region XExceptionClass + internal class XException : ApplicationException { + IntPtr Display; + IntPtr ResourceID; + IntPtr Serial; + XRequest RequestCode; + byte ErrorCode; + byte MinorCode; + + public XException(IntPtr Display, IntPtr ResourceID, IntPtr Serial, byte ErrorCode, XRequest RequestCode, byte MinorCode) { + this.Display = Display; + this.ResourceID = ResourceID; + this.Serial = Serial; + this.RequestCode = RequestCode; + this.ErrorCode = ErrorCode; + this.MinorCode = MinorCode; + } + + public override string Message { + get { + return GetMessage(Display, ResourceID, Serial, ErrorCode, RequestCode, MinorCode); + } + } + + public static string GetMessage(IntPtr Display, IntPtr ResourceID, IntPtr Serial, byte ErrorCode, XRequest RequestCode, byte MinorCode) { + StringBuilder sb; + string x_error_text; + string error; + string hwnd_text; + string Widget_text; + Hwnd hwnd; + Widget c; + + sb = new StringBuilder(160); + XGetErrorText(Display, ErrorCode, sb, sb.Capacity); + x_error_text = sb.ToString(); + hwnd = Hwnd.ObjectFromHandle(ResourceID); + if (hwnd != null) { + hwnd_text = hwnd.ToString(); + c = Widget.FromHandle(hwnd.Handle); + if (c != null) { + Widget_text = c.ToString(); + } else { + Widget_text = String.Format("<handle {0:X} non-existant>", hwnd.Handle.ToInt32()); + } + } else { + hwnd_text = "<null>"; + Widget_text = "<null>"; + } + + + error = String.Format("\n Error: {0}\n Request: {1:D} ({2})\n Resource ID: 0x{3:X}\n Serial: {4}\n Hwnd: {5}\n Widget: {6}", x_error_text, RequestCode, MinorCode, ResourceID.ToInt32(), Serial, hwnd_text, Widget_text); + return error; + } + } + #endregion // XExceptionClass + + #region Internal Methods + internal void SetDisplay(IntPtr display_handle) + { + if (display_handle != IntPtr.Zero) { + Hwnd hwnd; + + if ((DisplayHandle != IntPtr.Zero) && (FosterParent != IntPtr.Zero)) { + hwnd = Hwnd.ObjectFromHandle(FosterParent); + XDestroyWindow(DisplayHandle, FosterParent); + hwnd.Dispose(); + } + + if (DisplayHandle != IntPtr.Zero) { + XCloseDisplay(DisplayHandle); + } + + DisplayHandle=display_handle; + + // We need to tell System.Drawing our DisplayHandle. FromHdcInternal has + // been hacked to do this for us. + Graphics.FromHdcInternal (DisplayHandle); + + // query for the render extension so + // we can ignore the spurious + // BadPicture errors that are + // generated by cairo/render. + XQueryExtension (DisplayHandle, "RENDER", + ref render_major_opcode, ref render_first_event, ref render_first_error); + + // Debugging support + if (Environment.GetEnvironmentVariable ("MONO_XSYNC") != null) { + XSynchronize(DisplayHandle, true); + } + + if (Environment.GetEnvironmentVariable ("MONO_XEXCEPTIONS") != null) { + ErrorExceptions = true; + } + + // Generic X11 setup + ScreenNo = XDefaultScreen(DisplayHandle); + RootWindow = XRootWindow(DisplayHandle, ScreenNo); + DefaultColormap = XDefaultColormap(DisplayHandle, ScreenNo); + + // Create the foster parent + // it is important that border_width is kept in synch with the other XCreateWindow calls + FosterParent=XCreateSimpleWindow(DisplayHandle, RootWindow, 0, 0, 1, 1, 0, UIntPtr.Zero, UIntPtr.Zero); + if (FosterParent==IntPtr.Zero) { + Console.WriteLine("XplatUIX11 Constructor failed to create FosterParent"); + } + + DebugHelper.WriteLine ("FosterParent created 0x{0:x}", FosterParent.ToInt32()); + + hwnd = new Hwnd(); + hwnd.Queue = ThreadQueue(Thread.CurrentThread); + hwnd.WholeWindow = FosterParent; + hwnd.ClientWindow = FosterParent; + + // Create a HWND for RootWIndow as well, so our queue doesn't eat the events + hwnd = new Hwnd(); + hwnd.Queue = ThreadQueue(Thread.CurrentThread); + hwnd.whole_window = RootWindow; + hwnd.ClientWindow = RootWindow; + + // For sleeping on the X11 socket + listen = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); + IPEndPoint ep = new IPEndPoint(IPAddress.Loopback, 0); + listen.Bind(ep); + listen.Listen(1); + + // To wake up when a timer is ready + network_buffer = new byte[10]; + + wake = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); + wake.Connect(listen.LocalEndPoint); + + // Make this non-blocking, so it doesn't + // deadlock if too many wakes are sent + // before the wake_receive end is polled + wake.Blocking = false; + + wake_receive = listen.Accept(); + + #if __MonoCS__ + pollfds = new Pollfd [2]; + pollfds [0] = new Pollfd (); + pollfds [0].fd = XConnectionNumber (DisplayHandle); + pollfds [0].events = PollEvents.POLLIN; + + pollfds [1] = new Pollfd (); + pollfds [1].fd = wake_receive.Handle.ToInt32 (); + pollfds [1].events = PollEvents.POLLIN; + #endif + + Keyboard = new X11Keyboard(DisplayHandle, FosterParent); + Dnd = new X11Dnd (DisplayHandle, Keyboard); + + DoubleClickInterval = 500; + + HoverState.Interval = 500; + HoverState.Timer = new Timer(); + HoverState.Timer.Enabled = false; + HoverState.Timer.Interval = HoverState.Interval; + HoverState.Timer.Tick += new EventHandler(MouseHover); + HoverState.Size = new Size(4, 4); + HoverState.X = -1; + HoverState.Y = -1; + + ActiveWindow = IntPtr.Zero; + FocusWindow = IntPtr.Zero; + ModalWindows = new Stack(3); + + MouseState = MouseButtons.None; + mouse_position = new Point(0, 0); + + Caret.Timer = new Timer(); + Caret.Timer.Interval = 500; // FIXME - where should this number come from? + Caret.Timer.Tick += new EventHandler(CaretCallback); + + SetupAtoms(); + + // Grab atom changes off the root window to catch certain WM events + XSelectInput(DisplayHandle, RootWindow, new IntPtr ((int) (EventMask.PropertyChangeMask | Keyboard.KeyEventMask))); + + // Handle any upcoming errors + ErrorHandler = new XErrorHandler(HandleError); + XSetErrorHandler(ErrorHandler); + } else { + throw new ArgumentNullException("Display", "Could not open display (X-Server required. Check your DISPLAY environment variable)"); + } + } + #endregion // Internal Methods + + #region Methods + [Conditional ("DriverDebug")] + static void DriverDebug (string format, params object [] args) + { + Console.WriteLine (String.Format (format, args)); + } + + int unixtime() { + TimeSpan t = (DateTime.UtcNow - new DateTime(1970, 1, 1)); + + return (int) t.TotalSeconds; + } + + static void SetupAtoms() { + // make sure this array stays in sync with the statements below + string [] atom_names = new string[] { + "WM_PROTOCOLS", + "WM_DELETE_WINDOW", + "WM_TAKE_FOCUS", + //"_NET_SUPPORTED", + //"_NET_CLIENT_LIST", + //"_NET_NUMBER_OF_DESKTOPS", + "_NET_DESKTOP_GEOMETRY", + //"_NET_DESKTOP_VIEWPORT", + "_NET_CURRENT_DESKTOP", + //"_NET_DESKTOP_NAMES", + "_NET_ACTIVE_WINDOW", + "_NET_WORKAREA", + //"_NET_SUPPORTING_WM_CHECK", + //"_NET_VIRTUAL_ROOTS", + //"_NET_DESKTOP_LAYOUT", + //"_NET_SHOWING_DESKTOP", + //"_NET_CLOSE_WINDOW", + //"_NET_MOVERESIZE_WINDOW", + "_NET_WM_MOVERESIZE", + //"_NET_RESTACK_WINDOW", + //"_NET_REQUEST_FRAME_EXTENTS", + "_NET_WM_NAME", + //"_NET_WM_VISIBLE_NAME", + //"_NET_WM_ICON_NAME", + //"_NET_WM_VISIBLE_ICON_NAME", + //"_NET_WM_DESKTOP", + "_NET_WM_WINDOW_TYPE", + "_NET_WM_STATE", + //"_NET_WM_ALLOWED_ACTIONS", + //"_NET_WM_STRUT", + //"_NET_WM_STRUT_PARTIAL", + //"_NET_WM_ICON_GEOMETRY", + "_NET_WM_ICON", + //"_NET_WM_PID", + //"_NET_WM_HANDLED_ICONS", + "_NET_WM_USER_TIME", + "_NET_FRAME_EXTENTS", + //"_NET_WM_PING", + //"_NET_WM_SYNC_REQUEST", + "_NET_SYSTEM_TRAY_OPCODE", + //"_NET_SYSTEM_TRAY_ORIENTATION", + "_NET_WM_STATE_MAXIMIZED_HORZ", + "_NET_WM_STATE_MAXIMIZED_VERT", + "_NET_WM_STATE_HIDDEN", + "_XEMBED", + "_XEMBED_INFO", + "_MOTIF_WM_HINTS", + "_NET_WM_STATE_SKIP_TASKBAR", + "_NET_WM_STATE_ABOVE", + "_NET_WM_STATE_MODAL", + "_NET_WM_CONTEXT_HELP", + "_NET_WM_WINDOW_OPACITY", + //"_NET_WM_WINDOW_TYPE_DESKTOP", + //"_NET_WM_WINDOW_TYPE_DOCK", + //"_NET_WM_WINDOW_TYPE_TOOLBAR", + //"_NET_WM_WINDOW_TYPE_MENU", + "_NET_WM_WINDOW_TYPE_UTILITY", + // "_NET_WM_WINDOW_TYPE_DIALOG", + //"_NET_WM_WINDOW_TYPE_SPLASH", + "_NET_WM_WINDOW_TYPE_NORMAL", + "CLIPBOARD", + "PRIMARY", + "COMPOUND_TEXT", + "UTF8_STRING", + "UTF16_STRING", + "RICHTEXTFORMAT", + "TARGETS", + "_SWF_AsyncAtom", + "_SWF_PostMessageAtom", + "_SWF_HoverAtom" }; + + IntPtr[] atoms = new IntPtr [atom_names.Length];; + + XInternAtoms (DisplayHandle, atom_names, atom_names.Length, false, atoms); + + int off = 0; + WM_PROTOCOLS = atoms [off++]; + WM_DELETE_WINDOW = atoms [off++]; + WM_TAKE_FOCUS = atoms [off++]; + //_NET_SUPPORTED = atoms [off++]; + //_NET_CLIENT_LIST = atoms [off++]; + //_NET_NUMBER_OF_DESKTOPS = atoms [off++]; + _NET_DESKTOP_GEOMETRY = atoms [off++]; + //_NET_DESKTOP_VIEWPORT = atoms [off++]; + _NET_CURRENT_DESKTOP = atoms [off++]; + //_NET_DESKTOP_NAMES = atoms [off++]; + _NET_ACTIVE_WINDOW = atoms [off++]; + _NET_WORKAREA = atoms [off++]; + //_NET_SUPPORTING_WM_CHECK = atoms [off++]; + //_NET_VIRTUAL_ROOTS = atoms [off++]; + //_NET_DESKTOP_LAYOUT = atoms [off++]; + //_NET_SHOWING_DESKTOP = atoms [off++]; + //_NET_CLOSE_WINDOW = atoms [off++]; + //_NET_MOVERESIZE_WINDOW = atoms [off++]; + _NET_WM_MOVERESIZE = atoms [off++]; + //_NET_RESTACK_WINDOW = atoms [off++]; + //_NET_REQUEST_FRAME_EXTENTS = atoms [off++]; + _NET_WM_NAME = atoms [off++]; + //_NET_WM_VISIBLE_NAME = atoms [off++]; + //_NET_WM_ICON_NAME = atoms [off++]; + //_NET_WM_VISIBLE_ICON_NAME = atoms [off++]; + //_NET_WM_DESKTOP = atoms [off++]; + _NET_WM_WINDOW_TYPE = atoms [off++]; + _NET_WM_STATE = atoms [off++]; + //_NET_WM_ALLOWED_ACTIONS = atoms [off++]; + //_NET_WM_STRUT = atoms [off++]; + //_NET_WM_STRUT_PARTIAL = atoms [off++]; + //_NET_WM_ICON_GEOMETRY = atoms [off++]; + _NET_WM_ICON = atoms [off++]; + //_NET_WM_PID = atoms [off++]; + //_NET_WM_HANDLED_ICONS = atoms [off++]; + _NET_WM_USER_TIME = atoms [off++]; + _NET_FRAME_EXTENTS = atoms [off++]; + //_NET_WM_PING = atoms [off++]; + //_NET_WM_SYNC_REQUEST = atoms [off++]; + _NET_SYSTEM_TRAY_OPCODE = atoms [off++]; + //_NET_SYSTEM_TRAY_ORIENTATION = atoms [off++]; + _NET_WM_STATE_MAXIMIZED_HORZ = atoms [off++]; + _NET_WM_STATE_MAXIMIZED_VERT = atoms [off++]; + _NET_WM_STATE_HIDDEN = atoms [off++]; + _XEMBED = atoms [off++]; + _XEMBED_INFO = atoms [off++]; + _MOTIF_WM_HINTS = atoms [off++]; + _NET_WM_STATE_SKIP_TASKBAR = atoms [off++]; + _NET_WM_STATE_ABOVE = atoms [off++]; + _NET_WM_STATE_MODAL = atoms [off++]; + _NET_WM_CONTEXT_HELP = atoms [off++]; + _NET_WM_WINDOW_OPACITY = atoms [off++]; + //_NET_WM_WINDOW_TYPE_DESKTOP = atoms [off++]; + //_NET_WM_WINDOW_TYPE_DOCK = atoms [off++]; + //_NET_WM_WINDOW_TYPE_TOOLBAR = atoms [off++]; + //_NET_WM_WINDOW_TYPE_MENU = atoms [off++]; + _NET_WM_WINDOW_TYPE_UTILITY = atoms [off++]; + // _NET_WM_WINDOW_TYPE_DIALOG = atoms [off++]; + //_NET_WM_WINDOW_TYPE_SPLASH = atoms [off++]; + _NET_WM_WINDOW_TYPE_NORMAL = atoms [off++]; + CLIPBOARD = atoms [off++]; + PRIMARY = atoms [off++]; + OEMTEXT = atoms [off++]; + UTF8_STRING = atoms [off++]; + UTF16_STRING = atoms [off++]; + RICHTEXTFORMAT = atoms [off++]; + TARGETS = atoms [off++]; + AsyncAtom = atoms [off++]; + PostAtom = atoms [off++]; + HoverState.Atom = atoms [off++]; + + //DIB = (IntPtr)Atom.XA_PIXMAP; + _NET_SYSTEM_TRAY_S = XInternAtom (DisplayHandle, "_NET_SYSTEM_TRAY_S" + ScreenNo.ToString(), false); + } + + void GetSystrayManagerWindow() { + XGrabServer(DisplayHandle); + SystrayMgrWindow = XGetSelectionOwner(DisplayHandle, _NET_SYSTEM_TRAY_S); + XUngrabServer(DisplayHandle); + XFlush(DisplayHandle); + } + + void SendNetWMMessage(IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) { + SendNetWMMessage (window, message_type, l0, l1, l2, IntPtr.Zero); + } + + void SendNetWMMessage(IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2, IntPtr l3) { + XEvent xev; + + xev = new XEvent(); + xev.ClientMessageEvent.type = XEventName.ClientMessage; + xev.ClientMessageEvent.send_event = true; + xev.ClientMessageEvent.window = window; + xev.ClientMessageEvent.message_type = message_type; + xev.ClientMessageEvent.format = 32; + xev.ClientMessageEvent.ptr1 = l0; + xev.ClientMessageEvent.ptr2 = l1; + xev.ClientMessageEvent.ptr3 = l2; + xev.ClientMessageEvent.ptr4 = l3; + XSendEvent(DisplayHandle, RootWindow, false, new IntPtr ((int) (EventMask.SubstructureRedirectMask | EventMask.SubstructureNotifyMask)), ref xev); + } + + void SendNetClientMessage(IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) { + XEvent xev; + + xev = new XEvent(); + xev.ClientMessageEvent.type = XEventName.ClientMessage; + xev.ClientMessageEvent.send_event = true; + xev.ClientMessageEvent.window = window; + xev.ClientMessageEvent.message_type = message_type; + xev.ClientMessageEvent.format = 32; + xev.ClientMessageEvent.ptr1 = l0; + xev.ClientMessageEvent.ptr2 = l1; + xev.ClientMessageEvent.ptr3 = l2; + XSendEvent(DisplayHandle, window, false, new IntPtr ((int)EventMask.NoEventMask), ref xev); + } + + // For WM_LBUTTONDOWN, WM_MBUTTONDOWN, WM_RBUTTONDOWN, WM_XBUTTONDOWN + // WM_CREATE and WM_DESTROY causes + void SendParentNotify(IntPtr child, Msg cause, int x, int y) + { + Hwnd hwnd; + + if (child == IntPtr.Zero) { + return; + } + + hwnd = Hwnd.GetObjectFromWindow (child); + + if (hwnd == null) { + return; + } + + if (hwnd.Handle == IntPtr.Zero) { + return; + } + + if (ExStyleSet ((int) hwnd.initial_ex_style, WindowExStyles.WS_EX_NOPARENTNOTIFY)) { + return; + } + + if (hwnd.Parent == null) { + return; + } + + if (hwnd.Parent.Handle == IntPtr.Zero) { + return; + } + + if (cause == Msg.WM_CREATE || cause == Msg.WM_DESTROY) { + SendMessage(hwnd.Parent.Handle, Msg.WM_PARENTNOTIFY, Widget.MakeParam((int)cause, 0), child); + } else { + SendMessage(hwnd.Parent.Handle, Msg.WM_PARENTNOTIFY, Widget.MakeParam((int)cause, 0), Widget.MakeParam(x, y)); + } + + SendParentNotify (hwnd.Parent.Handle, cause, x, y); + } + + bool StyleSet (int s, WindowStyles ws) + { + return (s & (int)ws) == (int)ws; + } + + bool ExStyleSet (int ex, WindowExStyles exws) + { + return (ex & (int)exws) == (int)exws; + } + + internal static Rectangle TranslateClientRectangleToXClientRectangle (Hwnd hwnd) + { + return TranslateClientRectangleToXClientRectangle (hwnd, Widget.FromHandle (hwnd.Handle)); + } + + internal static Rectangle TranslateClientRectangleToXClientRectangle (Hwnd hwnd, Widget ctrl) + { + /* + * If this is a form with no window manager, X is handling all the border and caption painting + * so remove that from the area (since the area we set of the window here is the part of the window + * we're painting in only) + */ + Rectangle rect = hwnd.ClientRect; + Form form = ctrl as Form; + CreateParams cp = null; + + if (form != null) + cp = form.GetCreateParams (); + + if (form != null && (form.window_manager == null && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) { + Hwnd.Borders borders = Hwnd.GetBorders (cp, null); + Rectangle xrect = rect; + + xrect.Y -= borders.top; + xrect.X -= borders.left; + xrect.Width += borders.left + borders.right; + xrect.Height += borders.top + borders.bottom; + + rect = xrect; + } + + if (rect.Width < 1 || rect.Height < 1) { + rect.Width = 1; + rect.Height = 1; + rect.X = -5; + rect.Y = -5; + } + + return rect; + } + + internal static Size TranslateWindowSizeToXWindowSize (CreateParams cp) + { + return TranslateWindowSizeToXWindowSize (cp, new Size (cp.Width, cp.Height)); + } + + internal static Size TranslateWindowSizeToXWindowSize (CreateParams cp, Size size) + { + /* + * If this is a form with no window manager, X is handling all the border and caption painting + * so remove that from the area (since the area we set of the window here is the part of the window + * we're painting in only) + */ + Form form = cp.control as Form; + if (form != null && (form.window_manager == null && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) { + Hwnd.Borders borders = Hwnd.GetBorders (cp, null); + Size xrect = size; + + xrect.Width -= borders.left + borders.right; + xrect.Height -= borders.top + borders.bottom; + + size = xrect; + } + if (size.Height == 0) + size.Height = 1; + if (size.Width == 0) + size.Width = 1; + return size; + } + + internal static Size TranslateXWindowSizeToWindowSize (CreateParams cp, int xWidth, int xHeight) + { + /* + * If this is a form with no window manager, X is handling all the border and caption painting + * so remove that from the area (since the area we set of the window here is the part of the window + * we're painting in only) + */ + Size rect = new Size (xWidth, xHeight); + Form form = cp.control as Form; + if (form != null && (form.window_manager == null && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW))) { + Hwnd.Borders borders = Hwnd.GetBorders (cp, null); + Size xrect = rect; + + xrect.Width += borders.left + borders.right; + xrect.Height += borders.top + borders.bottom; + + rect = xrect; + } + return rect; + } + + internal static Point GetTopLevelWindowLocation (Hwnd hwnd) + { + IntPtr dummy; + int x, y; + Hwnd.Borders frame; + + XTranslateCoordinates (DisplayHandle, hwnd.whole_window, RootWindow, 0, 0, out x, out y, out dummy); + frame = FrameExtents (hwnd.whole_window); + + x -= frame.left; + y -= frame.top; + + return new Point (x, y); + } + + void DeriveStyles(int Style, int ExStyle, out FormBorderStyle border_style, out bool border_static, out TitleStyle title_style, out int caption_height, out int tool_caption_height) { + + caption_height = 0; + tool_caption_height = 19; + border_static = false; + + if (StyleSet (Style, WindowStyles.WS_CHILD)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_CLIENTEDGE)) { + border_style = FormBorderStyle.Fixed3D; + } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_STATICEDGE)) { + border_style = FormBorderStyle.Fixed3D; + border_static = true; + } else if (!StyleSet (Style, WindowStyles.WS_BORDER)) { + border_style = FormBorderStyle.None; + } else { + border_style = FormBorderStyle.FixedSingle; + } + title_style = TitleStyle.None; + + if (StyleSet (Style, WindowStyles.WS_CAPTION)) { + caption_height = 19; + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + title_style = TitleStyle.Tool; + } else { + title_style = TitleStyle.Normal; + } + } + + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_MDICHILD)) { + caption_height = 19; + + if (StyleSet (Style, WindowStyles.WS_OVERLAPPEDWINDOW) || + ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + border_style = (FormBorderStyle) 0xFFFF; + } else { + border_style = FormBorderStyle.None; + } + } + + } else { + title_style = TitleStyle.None; + if (StyleSet (Style, WindowStyles.WS_CAPTION)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + title_style = TitleStyle.Tool; + } else { + title_style = TitleStyle.Normal; + } + } + + border_style = FormBorderStyle.None; + + if (StyleSet (Style, WindowStyles.WS_THICKFRAME)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + border_style = FormBorderStyle.SizableToolWindow; + } else { + border_style = FormBorderStyle.Sizable; + } + } else { + if (StyleSet (Style, WindowStyles.WS_CAPTION)) { + if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_CLIENTEDGE)) { + border_style = FormBorderStyle.Fixed3D; + } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_STATICEDGE)) { + border_style = FormBorderStyle.Fixed3D; + border_static = true; + } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_DLGMODALFRAME)) { + border_style = FormBorderStyle.FixedDialog; + } else if (ExStyleSet (ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + border_style = FormBorderStyle.FixedToolWindow; + } else if (StyleSet (Style, WindowStyles.WS_BORDER)) { + border_style = FormBorderStyle.FixedSingle; + } + } else { + if (StyleSet (Style, WindowStyles.WS_BORDER)) { + border_style = FormBorderStyle.FixedSingle; + } + } + } + } + } + + void SetHwndStyles(Hwnd hwnd, CreateParams cp) { + DeriveStyles(cp.Style, cp.ExStyle, out hwnd.border_style, out hwnd.border_static, out hwnd.title_style, out hwnd.caption_height, out hwnd.tool_caption_height); + } + + void SetWMStyles(Hwnd hwnd, CreateParams cp) { + MotifWmHints mwmHints; + MotifFunctions functions; + MotifDecorations decorations; + int[] atoms; + int atom_count; + Rectangle client_rect; + Form form; + IntPtr window_type; + bool hide_from_taskbar; + IntPtr transient_for_parent; + + // Windows we manage ourselves don't need WM window styles. + if (cp.HasWindowManager && !cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) { + return; + } + + atoms = new int[8]; + mwmHints = new MotifWmHints(); + functions = 0; + decorations = 0; + window_type = _NET_WM_WINDOW_TYPE_NORMAL; + transient_for_parent = IntPtr.Zero; + + mwmHints.flags = (IntPtr)(MotifFlags.Functions | MotifFlags.Decorations); + mwmHints.functions = (IntPtr)0; + mwmHints.decorations = (IntPtr)0; + + form = cp.control as Form; + + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + /* tool windows get no window manager + decorations. + */ + + /* just because the window doesn't get any decorations doesn't + mean we should disable the functions. for instance, without + MotifFunctions.Maximize, changing the windowstate to Maximized + is ignored by metacity. */ + functions |= MotifFunctions.Move | MotifFunctions.Resize | MotifFunctions.Minimize | MotifFunctions.Maximize; + } else if (form != null && form.FormBorderStyle == FormBorderStyle.None) { + /* allow borderless window to be maximized */ + functions |= MotifFunctions.All | MotifFunctions.Resize; + } else { + if (StyleSet (cp.Style, WindowStyles.WS_CAPTION)) { + functions |= MotifFunctions.Move; + decorations |= MotifDecorations.Title | MotifDecorations.Menu; + } + + if (StyleSet (cp.Style, WindowStyles.WS_THICKFRAME)) { + functions |= MotifFunctions.Move | MotifFunctions.Resize; + decorations |= MotifDecorations.Border | MotifDecorations.ResizeH; + } + + if (StyleSet (cp.Style, WindowStyles.WS_MINIMIZEBOX)) { + functions |= MotifFunctions.Minimize; + decorations |= MotifDecorations.Minimize; + } + + if (StyleSet (cp.Style, WindowStyles.WS_MAXIMIZEBOX)) { + functions |= MotifFunctions.Maximize; + decorations |= MotifDecorations.Maximize; + } + + if (StyleSet (cp.Style, WindowStyles.WS_SIZEBOX)) { + functions |= MotifFunctions.Resize; + decorations |= MotifDecorations.ResizeH; + } + + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_DLGMODALFRAME)) { + decorations |= MotifDecorations.Border; + } + + if (StyleSet (cp.Style, WindowStyles.WS_BORDER)) { + decorations |= MotifDecorations.Border; + } + + if (StyleSet (cp.Style, WindowStyles.WS_DLGFRAME)) { + decorations |= MotifDecorations.Border; + } + + if (StyleSet (cp.Style, WindowStyles.WS_SYSMENU)) { + functions |= MotifFunctions.Close; + } + else { + functions &= ~(MotifFunctions.Maximize | MotifFunctions.Minimize | MotifFunctions.Close); + decorations &= ~(MotifDecorations.Menu | MotifDecorations.Maximize | MotifDecorations.Minimize); + if (cp.Caption == "") { + functions &= ~MotifFunctions.Move; + decorations &= ~(MotifDecorations.Title | MotifDecorations.ResizeH); + } + } + } + + if ((functions & MotifFunctions.Resize) == 0) { + hwnd.fixed_size = true; + Rectangle fixed_rectangle = new Rectangle (cp.X, cp.Y, cp.Width, cp.Height); + SetWindowMinMax(hwnd.Handle, fixed_rectangle, fixed_rectangle.Size, fixed_rectangle.Size, cp); + } else { + hwnd.fixed_size = false; + } + + mwmHints.functions = (IntPtr)functions; + mwmHints.decorations = (IntPtr)decorations; + + DriverDebug ("SetWMStyles ({0}, {1}) functions = {2}, decorations = {3}", hwnd, cp, functions, decorations); + + if (cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) { + // needed! map toolwindows to _NET_WM_WINDOW_TYPE_UTILITY to make newer metacity versions happy + // and get those windows in front of their parents + window_type = _NET_WM_WINDOW_TYPE_UTILITY; + } else { + window_type = _NET_WM_WINDOW_TYPE_NORMAL; + } + + if (!cp.IsSet (WindowExStyles.WS_EX_APPWINDOW)) { + hide_from_taskbar = true; + } else if (cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW) && form != null && form.Parent != null && !form.ShowInTaskbar) { + hide_from_taskbar = true; + } else { + hide_from_taskbar = false; + } + + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + if (form != null && !hwnd.reparented) { + if (form.Owner != null && form.Owner.Handle != IntPtr.Zero) { + Hwnd owner_hwnd = Hwnd.ObjectFromHandle (form.Owner.Handle); + if (owner_hwnd != null) + transient_for_parent = owner_hwnd.whole_window; + } + } + } + if (StyleSet (cp.Style, WindowStyles.WS_POPUP) && (hwnd.parent != null) && (hwnd.parent.whole_window != IntPtr.Zero)) { + transient_for_parent = hwnd.parent.whole_window; + } + + FormWindowState current_state = GetWindowState (hwnd.Handle); + if (current_state == (FormWindowState)(-1)) + current_state = FormWindowState.Normal; + + client_rect = TranslateClientRectangleToXClientRectangle (hwnd); + + lock (XlibLock) { + atom_count = 0; + + atoms [0] = window_type.ToInt32 (); + XChangeProperty (DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_TYPE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1); + + XChangeProperty(DisplayHandle, hwnd.whole_window, _MOTIF_WM_HINTS, _MOTIF_WM_HINTS, 32, PropertyMode.Replace, ref mwmHints, 5); + + if (transient_for_parent != IntPtr.Zero) { + XSetTransientForHint (DisplayHandle, hwnd.whole_window, transient_for_parent); + } + + MoveResizeWindow(DisplayHandle, hwnd.client_window, client_rect.X, client_rect.Y, client_rect.Width, client_rect.Height); + + if (hide_from_taskbar) { + /* this line keeps the window from showing up in gnome's taskbar */ + atoms[atom_count++] = _NET_WM_STATE_SKIP_TASKBAR.ToInt32(); + } + /* we need to add these atoms in the + * event we're maximized, since we're + * replacing the existing + * _NET_WM_STATE here. If we don't + * add them, future calls to + * GetWindowState will return Normal + * for a window which is maximized. */ + if (current_state == FormWindowState.Maximized) { + atoms[atom_count++] = _NET_WM_STATE_MAXIMIZED_HORZ.ToInt32(); + atoms[atom_count++] = _NET_WM_STATE_MAXIMIZED_VERT.ToInt32(); + } + + if (form != null && form.Modal) { + atoms[atom_count++] = _NET_WM_STATE_MODAL.ToInt32 (); + } + + XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, atom_count); + + atom_count = 0; + IntPtr[] atom_ptrs = new IntPtr[2]; + atom_ptrs[atom_count++] = WM_DELETE_WINDOW; + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_CONTEXTHELP)) { + atom_ptrs[atom_count++] = _NET_WM_CONTEXT_HELP; + } + + XSetWMProtocols(DisplayHandle, hwnd.whole_window, atom_ptrs, atom_count); + } + } + + void SetIcon(Hwnd hwnd, Icon icon) + { + if (icon == null) { + // XXX + + // This really needs to do whatever it + // takes to remove the window manager + // menu, not just delete the ICON + // property. This will cause metacity + // to use the "no icon set" icon, and + // we'll still have an icon. + XDeleteProperty (DisplayHandle, hwnd.whole_window, _NET_WM_ICON); + } + else { + Bitmap bitmap; + int size; + IntPtr[] data; + int index; + + bitmap = icon.ToBitmap(); + index = 0; + size = bitmap.Width * bitmap.Height + 2; + data = new IntPtr[size]; + + data[index++] = (IntPtr)bitmap.Width; + data[index++] = (IntPtr)bitmap.Height; + + for (int y = 0; y < bitmap.Height; y++) { + for (int x = 0; x < bitmap.Width; x++) { + data[index++] = (IntPtr)bitmap.GetPixel (x, y).ToArgb (); + } + } + + XChangeProperty (DisplayHandle, hwnd.whole_window, + _NET_WM_ICON, (IntPtr)Atom.XA_CARDINAL, 32, + PropertyMode.Replace, data, size); + } + } + + void WakeupMain () { + try { + wake.Send (new byte [] { 0xFF }); + } catch (SocketException ex) { + if (ex.SocketErrorCode != SocketError.WouldBlock) { + throw; + } + } + } + + XEventQueue ThreadQueue(Thread thread) { + XEventQueue queue; + + queue = (XEventQueue)MessageQueues[thread]; + if (queue == null) { + queue = new XEventQueue(thread); + MessageQueues[thread] = queue; + } + + return queue; + } + + void TranslatePropertyToClipboard(IntPtr property) { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + + Clipboard.Item = null; + + XGetWindowProperty(DisplayHandle, FosterParent, property, IntPtr.Zero, new IntPtr (0x7fffffff), true, (IntPtr)Atom.AnyPropertyType, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + + if ((long)nitems > 0) { + if (property == (IntPtr)Atom.XA_STRING) { + // Xamarin-5116: PtrToStringAnsi expects to get UTF-8, but we might have + // Latin-1 instead, in which case it will return null. + var s = Marshal.PtrToStringAnsi (prop); + if (string.IsNullOrEmpty (s)) { + var sb = new StringBuilder (); + for (int i = 0; i < (int)nitems; i++) { + var b = Marshal.ReadByte (prop, i); + sb.Append ((char)b); + } + s = sb.ToString (); + } + // Some X managers/apps pass unicode chars as escaped strings, so + // we may need to unescape them. + Clipboard.Item = UnescapeUnicodeFromAnsi (s); + } else if (property == (IntPtr)Atom.XA_BITMAP) { + // FIXME - convert bitmap to image + } else if (property == (IntPtr)Atom.XA_PIXMAP) { + // FIXME - convert pixmap to image + } else if (property == OEMTEXT) { + Clipboard.Item = UnescapeUnicodeFromAnsi (Marshal.PtrToStringAnsi(prop)); + } else if (property == UTF8_STRING) { + byte [] buffer = new byte [(int)nitems]; + for (int i = 0; i < (int)nitems; i++) + buffer [i] = Marshal.ReadByte (prop, i); + Clipboard.Item = Encoding.UTF8.GetString (buffer); + } else if (property == UTF16_STRING) { + byte [] buffer = new byte [(int)nitems]; + for (int i = 0; i < (int)nitems; i++) + buffer [i] = Marshal.ReadByte (prop, i); + Clipboard.Item = Encoding.Unicode.GetString (buffer); + } else if (property == RICHTEXTFORMAT) + Clipboard.Item = Marshal.PtrToStringAnsi(prop); + else if (DataFormats.ContainsFormat (property.ToInt32 ())) { + if (DataFormats.GetFormat (property.ToInt32 ()).is_serializable) { + MemoryStream memory_stream = new MemoryStream ((int)nitems); + for (int i = 0; i < (int)nitems; i++) + memory_stream.WriteByte (Marshal.ReadByte (prop, i)); + + memory_stream.Position = 0; + BinaryFormatter formatter = new BinaryFormatter (); + Clipboard.Item = formatter.Deserialize (memory_stream); + memory_stream.Close (); + } + } + + XFree(prop); + } + } + + string UnescapeUnicodeFromAnsi (string value) + { + if (value == null || value.IndexOf ("\\u") == -1) + return value; + + StringBuilder sb = new StringBuilder (value.Length); + int start, pos; + + start = pos = 0; + while (start < value.Length) { + pos = value.IndexOf ("\\u", start); + if (pos == -1) + break; + + sb.Append (value, start, pos - start); + pos += 2; + start = pos; + + int length = 0; + while (pos < value.Length && length < 4) { + if (!ValidHexDigit (value [pos])) + break; + length++; + pos++; + } + + int res; + if (!Int32.TryParse (value.Substring (start, length), System.Globalization.NumberStyles.HexNumber, + null, out res)) + return value; // Error, return the unescaped original value. + + sb.Append ((char)res); + start = pos; + } + + // Append any remaining data. + if (start < value.Length) + sb.Append (value, start, value.Length - start); + + return sb.ToString (); + } + + private static bool ValidHexDigit (char e) + { + return Char.IsDigit (e) || (e >= 'A' && e <= 'F') || (e >= 'a' && e <= 'f'); + } + + void AddExpose (Hwnd hwnd, bool client, int x, int y, int width, int height) { + // Don't waste time + if ((hwnd == null) || (x > hwnd.Width) || (y > hwnd.Height) || ((x + width) < 0) || ((y + height) < 0)) { + return; + } + + // Keep the invalid area as small as needed + if ((x + width) > hwnd.width) { + width = hwnd.width - x; + } + + if ((y + height) > hwnd.height) { + height = hwnd.height - y; + } + + if (client) { + hwnd.AddInvalidArea(x, y, width, height); + if (!hwnd.expose_pending) { + if (!hwnd.nc_expose_pending) { + hwnd.Queue.Paint.Enqueue(hwnd); + } + hwnd.expose_pending = true; + } + } else { + hwnd.AddNcInvalidArea (x, y, width, height); + + if (!hwnd.nc_expose_pending) { + if (!hwnd.expose_pending) { + hwnd.Queue.Paint.Enqueue(hwnd); + } + hwnd.nc_expose_pending = true; + } + } + } + + static Hwnd.Borders FrameExtents (IntPtr window) + { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + Hwnd.Borders rect = new Hwnd.Borders (); + + XGetWindowProperty (DisplayHandle, window, _NET_FRAME_EXTENTS, IntPtr.Zero, new IntPtr (16), false, (IntPtr)Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + if (prop != IntPtr.Zero) { + if (nitems.ToInt32 () == 4) { + rect.left = Marshal.ReadInt32 (prop, 0); + rect.right = Marshal.ReadInt32 (prop, IntPtr.Size); + rect.top = Marshal.ReadInt32 (prop, 2 * IntPtr.Size); + rect.bottom = Marshal.ReadInt32 (prop, 3 * IntPtr.Size); + } + XFree (prop); + } + + return rect; + } + + void AddConfigureNotify (XEvent xevent) { + Hwnd hwnd; + + hwnd = Hwnd.GetObjectFromWindow(xevent.ConfigureEvent.window); + + // Don't waste time + if (hwnd == null || hwnd.zombie) { + return; + } + if ((xevent.ConfigureEvent.window == hwnd.whole_window)/* && (xevent.ConfigureEvent.window == xevent.ConfigureEvent.xevent)*/) { + if (hwnd.parent == null) { + // The location given by the event is not reliable between different wm's, + // so use an alternative way of getting it. + Point location = GetTopLevelWindowLocation (hwnd); + hwnd.x = location.X; + hwnd.y = location.Y; + } + + // XXX this sucks. this isn't thread safe + Widget ctrl = Widget.FromHandle (hwnd.Handle); + Size TranslatedSize; + if (ctrl != null) { + TranslatedSize = TranslateXWindowSizeToWindowSize (ctrl.GetCreateParams (), xevent.ConfigureEvent.width, xevent.ConfigureEvent.height); + } else { + TranslatedSize = new Size (xevent.ConfigureEvent.width, xevent.ConfigureEvent.height); + } + hwnd.width = TranslatedSize.Width; + hwnd.height = TranslatedSize.Height; + hwnd.ClientRect = Rectangle.Empty; + + DriverDebug ("AddConfigureNotify (hwnd.Handle = {1}, final hwnd.rect = {0}, reported rect={2})", + new Rectangle (hwnd.x, hwnd.y, hwnd.width, hwnd.height), hwnd.Handle, + new Rectangle (xevent.ConfigureEvent.x, xevent.ConfigureEvent.y, xevent.ConfigureEvent.width, xevent.ConfigureEvent.width)); + lock (hwnd.configure_lock) { + if (!hwnd.configure_pending) { + hwnd.Queue.EnqueueLocked (xevent); + hwnd.configure_pending = true; + } + } + } + // We drop configure events for Client windows + } + + void ShowCaret() { + if ((Caret.gc == IntPtr.Zero) || Caret.On) { + return; + } + Caret.On = true; + + lock (XlibLock) { + XDrawLine(DisplayHandle, Caret.Window, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height); + } + } + + void HideCaret() { + if ((Caret.gc == IntPtr.Zero) || !Caret.On) { + return; + } + Caret.On = false; + + lock (XlibLock) { + XDrawLine(DisplayHandle, Caret.Window, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height); + } + } + + int NextTimeout (ArrayList timers, DateTime now) { + int timeout = 0; + + foreach (Timer timer in timers) { + int next = (int) (timer.Expires - now).TotalMilliseconds; + if (next < 0) { + return 0; // Have a timer that has already expired + } + + if (next < timeout) { + timeout = next; + } + } + if (timeout < Timer.Minimum) { + timeout = Timer.Minimum; + } + + if (timeout > 1000) + timeout = 1000; + return timeout; + } + + void CheckTimers (ArrayList timers, DateTime now) { + int count; + + count = timers.Count; + + if (count == 0) + return; + + for (int i = 0; i < timers.Count; i++) { + Timer timer; + + timer = (Timer) timers [i]; + + if (timer.Enabled && timer.Expires <= now && !timer.Busy) { + // Timer ticks: + // - Before MainForm.OnLoad if DoEvents () is called. + // - After MainForm.OnLoad if not. + // + if (in_doevents || + (Application.MWFThread.Current.Context != null && + (Application.MWFThread.Current.Context.MainForm == null || + Application.MWFThread.Current.Context.MainForm.IsLoaded))) { + timer.Busy = true; + timer.Update (now); + timer.FireTick (); + timer.Busy = false; + } + } + } + } + + void WaitForHwndMessage (Hwnd hwnd, Msg message) { + WaitForHwndMessage (hwnd, message, false); + + } + + void WaitForHwndMessage (Hwnd hwnd, Msg message, bool process) { + MSG msg = new MSG (); + XEventQueue queue; + + queue = ThreadQueue(Thread.CurrentThread); + + queue.DispatchIdle = false; + + bool done = false; + string key = hwnd.Handle + ":" + message; + if (!messageHold.ContainsKey (key)) + messageHold.Add (key, 1); + else + messageHold[key] = ((int)messageHold[key]) + 1; + + + do { + + DebugHelper.WriteLine ("Waiting for message " + message + " on hwnd " + String.Format("0x{0:x}", hwnd.Handle.ToInt32 ())); + DebugHelper.Indent (); + + if (PeekMessage(queue, ref msg, IntPtr.Zero, 0, 0, (uint)PeekMessageFlags.PM_REMOVE)) { + if ((Msg)msg.message == Msg.WM_QUIT) { + PostQuitMessage (0); + done = true; + } + else { + + DebugHelper.WriteLine ("PeekMessage got " + msg); + + if (msg.hwnd == hwnd.Handle) { + if ((Msg)msg.message == message) { + if (process) { + TranslateMessage (ref msg); + DispatchMessage (ref msg); + } + break; + } + else if ((Msg)msg.message == Msg.WM_DESTROY) + done = true; + } + + TranslateMessage (ref msg); + DispatchMessage (ref msg); + } + } + + done = !messageHold.ContainsKey (key) || ((int)messageHold[key] < 1) || done; + } while (!done); + + messageHold.Remove (key); + + DebugHelper.Unindent (); + DebugHelper.WriteLine ("Finished waiting for " + key); + + queue.DispatchIdle = true; + + } + + void MapWindow(Hwnd hwnd, WindowType windows) { + if (!hwnd.mapped) { + Form f = Widget.FromHandle(hwnd.Handle) as Form; + if (f != null) { + if (f.WindowState == FormWindowState.Normal) { + f.waiting_showwindow = true; + SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, (IntPtr)1, IntPtr.Zero); + } + } + + // it's possible that our Hwnd is no + // longer valid after making that + // SendMessage call, so check here. + if (hwnd.zombie) + return; + + if (hwnd.topmost) { + // Most window managers will respect the _NET_WM_STATE property. + // If not, use XMapRaised to map the window at the top level as + // a last ditch effort. + if ((windows & WindowType.Whole) != 0) { + XMapRaised(DisplayHandle, hwnd.whole_window); + } + if ((windows & WindowType.Client) != 0) { + XMapRaised(DisplayHandle, hwnd.client_window); + } + } else { + if ((windows & WindowType.Whole) != 0) { + XMapWindow(DisplayHandle, hwnd.whole_window); + } + if ((windows & WindowType.Client) != 0) { + XMapWindow(DisplayHandle, hwnd.client_window); + } + } + + hwnd.mapped = true; + + if (f != null) { + if (f.waiting_showwindow) { + WaitForHwndMessage (hwnd, Msg.WM_SHOWWINDOW); + CreateParams cp = f.GetCreateParams(); + if (!ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_MDICHILD) && + !StyleSet (cp.Style, WindowStyles.WS_CHILD)) { + WaitForHwndMessage (hwnd, Msg.WM_ACTIVATE, true); + } + } + } + } + } + + void UnmapWindow(Hwnd hwnd, WindowType windows) { + if (hwnd.mapped) { + Form f = null; + if (Widget.FromHandle(hwnd.Handle) is Form) { + f = Widget.FromHandle(hwnd.Handle) as Form; + if (f.WindowState == FormWindowState.Normal) { + f.waiting_showwindow = true; + SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, IntPtr.Zero, IntPtr.Zero); + } + } + + // it's possible that our Hwnd is no + // longer valid after making that + // SendMessage call, so check here. + // FIXME: it is likely wrong, as it has already sent WM_SHOWWINDOW + if (hwnd.zombie) + return; + + if ((windows & WindowType.Client) != 0) { + XUnmapWindow(DisplayHandle, hwnd.client_window); + } + if ((windows & WindowType.Whole) != 0) { + XUnmapWindow(DisplayHandle, hwnd.whole_window); + } + + hwnd.mapped = false; + + if (f != null) { + if (f.waiting_showwindow) { + WaitForHwndMessage (hwnd, Msg.WM_SHOWWINDOW); + CreateParams cp = f.GetCreateParams(); + if (!ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_MDICHILD) && + !StyleSet (cp.Style, WindowStyles.WS_CHILD)) { + WaitForHwndMessage (hwnd, Msg.WM_ACTIVATE, true); + } + } + } + } + } + + void UpdateMessageQueue (XEventQueue queue) { + UpdateMessageQueue(queue, true); + } + + void UpdateMessageQueue (XEventQueue queue, bool allowIdle) { + DateTime now; + int pending; + Hwnd hwnd; + + now = DateTime.UtcNow; + + lock (XlibLock) { + pending = XPending (DisplayHandle); + } + + if (pending == 0 && allowIdle) { + if ((queue == null || queue.DispatchIdle) && Idle != null) { + Idle (this, EventArgs.Empty); + } + + lock (XlibLock) { + pending = XPending (DisplayHandle); + } + } + + if (pending == 0) { + int timeout = 0; + + if (queue != null) { + if (queue.Paint.Count > 0) + return; + + timeout = NextTimeout (queue.timer_list, now); + } + + if (timeout > 0) { + #if __MonoCS__ + int length = pollfds.Length - 1; + lock (wake_waiting_lock) { + if (wake_waiting == false) { + length ++; + wake_waiting = true; + } + } + + Syscall.poll (pollfds, (uint)length, timeout); + // Clean out buffer, so we're not busy-looping on the same data + if (length == pollfds.Length) { + if (pollfds[1].revents != 0) + wake_receive.Receive(network_buffer, 0, 1, SocketFlags.None); + lock (wake_waiting_lock) { + wake_waiting = false; + } + } + #endif + lock (XlibLock) { + pending = XPending (DisplayHandle); + } + } + } + + if (queue != null) + CheckTimers (queue.timer_list, now); + + while (true) { + XEvent xevent = new XEvent (); + + lock (XlibLock) { + if (XPending (DisplayHandle) == 0) + break; + + XNextEvent (DisplayHandle, ref xevent); + + if (xevent.AnyEvent.type == XEventName.KeyPress || + xevent.AnyEvent.type == XEventName.KeyRelease) { + // PreFilter() handles "shift key state updates. + Keyboard.PreFilter (xevent); + if (XFilterEvent (ref xevent, Keyboard.ClientWindow)) { + // probably here we could raise WM_IME_KEYDOWN and + // WM_IME_KEYUP, but I'm not sure it is worthy. + continue; + } + } + else if (XFilterEvent (ref xevent, IntPtr.Zero)) + continue; + } + + hwnd = Hwnd.GetObjectFromWindow(xevent.AnyEvent.window); + if (hwnd == null) + continue; + + DebugHelper.WriteLine ("UpdateMessageQueue got Event: " + xevent.ToString ()); + + switch (xevent.type) { + case XEventName.Expose: + AddExpose (hwnd, xevent.ExposeEvent.window == hwnd.ClientWindow, xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height); + break; + + case XEventName.SelectionClear: { + // Should we do something? + break; + } + + case XEventName.SelectionRequest: { + if (Dnd.HandleSelectionRequestEvent (ref xevent)) + break; + XEvent sel_event; + + sel_event = new XEvent(); + sel_event.SelectionEvent.type = XEventName.SelectionNotify; + sel_event.SelectionEvent.send_event = true; + sel_event.SelectionEvent.display = DisplayHandle; + sel_event.SelectionEvent.selection = xevent.SelectionRequestEvent.selection; + sel_event.SelectionEvent.target = xevent.SelectionRequestEvent.target; + sel_event.SelectionEvent.requestor = xevent.SelectionRequestEvent.requestor; + sel_event.SelectionEvent.time = xevent.SelectionRequestEvent.time; + sel_event.SelectionEvent.property = IntPtr.Zero; + + IntPtr format_atom = xevent.SelectionRequestEvent.target; + + // Seems that some apps support asking for supported types + if (format_atom == TARGETS) { + int[] atoms; + int atom_count; + + atoms = new int[5]; + atom_count = 0; + + if (Clipboard.IsSourceText) { + atoms[atom_count++] = (int)Atom.XA_STRING; + atoms[atom_count++] = (int)OEMTEXT; + atoms[atom_count++] = (int)UTF8_STRING; + atoms[atom_count++] = (int)UTF16_STRING; + atoms[atom_count++] = (int)RICHTEXTFORMAT; + } else if (Clipboard.IsSourceImage) { + atoms[atom_count++] = (int)Atom.XA_PIXMAP; + atoms[atom_count++] = (int)Atom.XA_BITMAP; + } else { + // FIXME - handle other types + } + + XChangeProperty(DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property, + (IntPtr)xevent.SelectionRequestEvent.target, 32, PropertyMode.Replace, atoms, atom_count); + sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property; + } else if (format_atom == (IntPtr)RICHTEXTFORMAT) { + string rtf_text = Clipboard.GetRtfText (); + if (rtf_text != null) { + // The RTF spec mentions that ascii is enough to contain it + Byte [] bytes = Encoding.ASCII.GetBytes (rtf_text); + int buflen = bytes.Length; + IntPtr buffer = Marshal.AllocHGlobal (buflen); + + for (int i = 0; i < buflen; i++) + Marshal.WriteByte (buffer, i, bytes[i]); + + XChangeProperty(DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property, + (IntPtr)xevent.SelectionRequestEvent.target, 8, PropertyMode.Replace, buffer, buflen); + sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property; + Marshal.FreeHGlobal(buffer); + } + } else if (Clipboard.IsSourceText && + (format_atom == (IntPtr)Atom.XA_STRING + || format_atom == OEMTEXT + || format_atom == UTF16_STRING + || format_atom == UTF8_STRING)) { + IntPtr buffer = IntPtr.Zero; + int buflen; + Encoding encoding = null; + + buflen = 0; + + // Select an encoding depending on the target + IntPtr target_atom = xevent.SelectionRequestEvent.target; + if (target_atom == (IntPtr)Atom.XA_STRING || target_atom == OEMTEXT) + // FIXME - EOMTEXT should encode into ISO2022 + encoding = Encoding.ASCII; + else if (target_atom == UTF16_STRING) + encoding = Encoding.Unicode; + else if (target_atom == UTF8_STRING) + encoding = Encoding.UTF8; + + Byte [] bytes; + + bytes = encoding.GetBytes (Clipboard.GetPlainText ()); + buffer = Marshal.AllocHGlobal (bytes.Length); + buflen = bytes.Length; + + for (int i = 0; i < buflen; i++) + Marshal.WriteByte (buffer, i, bytes [i]); + + if (buffer != IntPtr.Zero) { + XChangeProperty(DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property, (IntPtr)xevent.SelectionRequestEvent.target, 8, PropertyMode.Replace, buffer, buflen); + sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property; + Marshal.FreeHGlobal(buffer); + } + } else if (Clipboard.GetSource (format_atom.ToInt32 ()) != null) { // check if we have an available value of this format + if (DataFormats.GetFormat (format_atom.ToInt32 ()).is_serializable) { + object serializable = Clipboard.GetSource (format_atom.ToInt32 ()); + + BinaryFormatter formatter = new BinaryFormatter (); + MemoryStream memory_stream = new MemoryStream (); + formatter.Serialize (memory_stream, serializable); + + int buflen = (int)memory_stream.Length; + IntPtr buffer = Marshal.AllocHGlobal (buflen); + memory_stream.Position = 0; + for (int i = 0; i < buflen; i++) + Marshal.WriteByte (buffer, i, (byte)memory_stream.ReadByte ()); + memory_stream.Close (); + + XChangeProperty (DisplayHandle, xevent.SelectionRequestEvent.requestor, (IntPtr)xevent.SelectionRequestEvent.property, (IntPtr)xevent.SelectionRequestEvent.target, + 8, PropertyMode.Replace, buffer, buflen); + sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property; + Marshal.FreeHGlobal (buffer); + } + + } else if (Clipboard.IsSourceImage) { + if (xevent.SelectionEvent.target == (IntPtr)Atom.XA_PIXMAP) { + // FIXME - convert image and store as property + } else if (xevent.SelectionEvent.target == (IntPtr)Atom.XA_PIXMAP) { + // FIXME - convert image and store as property + } + } + + XSendEvent(DisplayHandle, xevent.SelectionRequestEvent.requestor, false, new IntPtr ((int)EventMask.NoEventMask), ref sel_event); + break; + } + + case XEventName.SelectionNotify: { + if (Clipboard.Enumerating) { + Clipboard.Enumerating = false; + if (xevent.SelectionEvent.property != IntPtr.Zero) { + XDeleteProperty(DisplayHandle, FosterParent, (IntPtr)xevent.SelectionEvent.property); + if (!Clipboard.Formats.Contains(xevent.SelectionEvent.property)) { + Clipboard.Formats.Add(xevent.SelectionEvent.property); + DriverDebug("Got supported clipboard atom format: {0}", xevent.SelectionEvent.property); + } + } + } else if (Clipboard.Retrieving) { + Clipboard.Retrieving = false; + if (xevent.SelectionEvent.property != IntPtr.Zero) { + TranslatePropertyToClipboard(xevent.SelectionEvent.property); + } else { + Clipboard.ClearSources (); + Clipboard.Item = null; + } + } else { + Dnd.HandleSelectionNotifyEvent (ref xevent); + } + break; + } + + case XEventName.KeyRelease: + if (!detectable_key_auto_repeat && XPending (DisplayHandle) != 0) { + XEvent nextevent = new XEvent (); + + XPeekEvent (DisplayHandle, ref nextevent); + + if (nextevent.type == XEventName.KeyPress && + nextevent.KeyEvent.keycode == xevent.KeyEvent.keycode && + nextevent.KeyEvent.time == xevent.KeyEvent.time) { + continue; + } + } + goto case XEventName.KeyPress; + + case XEventName.MotionNotify: { + XEvent peek; + + /* we can't do motion compression across threads, so just punt if we don't match up */ + if (Thread.CurrentThread == hwnd.Queue.Thread && hwnd.Queue.Count > 0) { + peek = hwnd.Queue.Peek(); + if (peek.AnyEvent.type == XEventName.MotionNotify) { + continue; + } + } + goto case XEventName.KeyPress; + } + + case XEventName.KeyPress: + hwnd.Queue.EnqueueLocked (xevent); + /* Process KeyPresses immediately. Otherwise multiple Compose messages as a result of a + * single physical keypress are not processed correctly */ + return; + case XEventName.ButtonPress: + case XEventName.ButtonRelease: + case XEventName.EnterNotify: + case XEventName.LeaveNotify: + case XEventName.CreateNotify: + case XEventName.DestroyNotify: + case XEventName.FocusIn: + case XEventName.FocusOut: + case XEventName.ClientMessage: + case XEventName.ReparentNotify: + case XEventName.MapNotify: + case XEventName.UnmapNotify: + hwnd.Queue.EnqueueLocked (xevent); + break; + + case XEventName.ConfigureNotify: + AddConfigureNotify(xevent); + break; + + case XEventName.PropertyNotify: + DriverDebug ("UpdateMessageQueue (), got Event: {0}", xevent.ToString ()); + if (xevent.PropertyEvent.atom == _NET_ACTIVE_WINDOW) { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + IntPtr prev_active; + + prev_active = ActiveWindow; + XGetWindowProperty(DisplayHandle, RootWindow, _NET_ACTIVE_WINDOW, IntPtr.Zero, new IntPtr (1), false, (IntPtr)Atom.XA_WINDOW, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + if (((long)nitems > 0) && (prop != IntPtr.Zero)) { + ActiveWindow = Hwnd.GetHandleFromWindow((IntPtr)Marshal.ReadInt32(prop)); + XFree(prop); + + DebugHelper.WriteLine ("PropertyNotify: _NET_ACTIVE_WINDOW: previous = 0x{0:x}, new = 0x{1:x}", prev_active.ToInt32 (), ActiveWindow.ToInt32 ()); + + if (prev_active != ActiveWindow) { + if (prev_active != IntPtr.Zero) { + PostMessage(prev_active, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_INACTIVE, IntPtr.Zero); + } + if (ActiveWindow != IntPtr.Zero) { + PostMessage(ActiveWindow, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_ACTIVE, IntPtr.Zero); + } + } + if (ModalWindows.Count == 0) { + break; + } else { + // Modality Handling + // + // If there is a modal window on the stack and the new active + // window is MWF window, but not the modal one and not a non-modal + // child of the modal one, switch back to the modal window. + // + // To identify if a non-modal form is child of a modal form + // we match their ApplicationContexts, which will be the same. + // This is because each modal form runs the loop with a + // new ApplicationContext, which is inherited by the non-modal + // forms. + + Form activeForm = Widget.FromHandle (ActiveWindow) as Form; + if (activeForm != null) { + Form modalForm = Widget.FromHandle ((IntPtr)ModalWindows.Peek()) as Form; + if (ActiveWindow != (IntPtr)ModalWindows.Peek() && + (modalForm == null || activeForm.context == modalForm.context)) { + Activate((IntPtr)ModalWindows.Peek()); + } + } + break; + } + } + } + else if (xevent.PropertyEvent.atom == _NET_WM_STATE) { + // invalidate our cache - we'll query again the next time someone does GetWindowState. + hwnd.cached_window_state = (FormWindowState)(-1); + PostMessage (hwnd.Handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + } + break; + + } + } + } + + IntPtr GetMousewParam(int Delta) { + int result = 0; + + if ((MouseState & MouseButtons.Left) != 0) { + result |= (int)MsgButtons.MK_LBUTTON; + } + + if ((MouseState & MouseButtons.Middle) != 0) { + result |= (int)MsgButtons.MK_MBUTTON; + } + + if ((MouseState & MouseButtons.Right) != 0) { + result |= (int)MsgButtons.MK_RBUTTON; + } + + Keys mods = ModifierKeys; + if ((mods & Keys.Widget) != 0) { + result |= (int)MsgButtons.MK_CONTROL; + } + + if ((mods & Keys.Shift) != 0) { + result |= (int)MsgButtons.MK_SHIFT; + } + + result |= Delta << 16; + + return (IntPtr)result; + } + IntPtr XGetParent(IntPtr handle) { + IntPtr Root; + IntPtr Parent; + IntPtr Children; + int ChildCount; + + lock (XlibLock) { + XQueryTree(DisplayHandle, handle, out Root, out Parent, out Children, out ChildCount); + } + + if (Children!=IntPtr.Zero) { + lock (XlibLock) { + XFree(Children); + } + } + return Parent; + } + + int HandleError (IntPtr display, ref XErrorEvent error_event) + { + // we need to workaround a problem with the + // ordering of destruction of Drawables and + // Pictures that exists between cairo and + // RENDER on the server. + if (error_event.request_code == (XRequest)render_major_opcode + && error_event.minor_code == 7 /* X_RenderFreePicture from render.h */ + && error_event.error_code == render_first_error + 1 /* BadPicture from render.h */) { + return 0; + } + + if (ErrorExceptions) { + XUngrabPointer (display, IntPtr.Zero); + throw new XException (error_event.display, error_event.resourceid, + error_event.serial, error_event.error_code, + error_event.request_code, error_event.minor_code); + } else { + Console.WriteLine("X11 Error encountered: {0}{1}\n", + XException.GetMessage (error_event.display, error_event.resourceid, + error_event.serial, error_event.error_code, + error_event.request_code, error_event.minor_code), + Environment.StackTrace); + } + return 0; + } + + void AccumulateDestroyedHandles (Widget c, ArrayList list) + { + DebugHelper.Enter (); + if (c != null) { + + Widget[] Widgets = c.Widgets.GetAllWidgets (); + + DebugHelper.WriteLine ("Checking Widget:0x{0:x}", c.IsHandleCreated ? c.Handle.ToInt32() : 0); + + if (c.IsHandleCreated && !c.IsDisposed) { + Hwnd hwnd = Hwnd.ObjectFromHandle(c.Handle); + + DriverDebug (" + adding {0} to the list of zombie windows", XplatUI.Window (hwnd.Handle)); + DriverDebug (" + parent X window is {0:X}", XGetParent (hwnd.whole_window).ToInt32()); + + list.Add (hwnd); + CleanupCachedWindows (hwnd); + } + + for (int i = 0; i < Widgets.Length; i ++) { + AccumulateDestroyedHandles (Widgets[i], list); + } + } + DebugHelper.Leave (); + } + + void CleanupCachedWindows (Hwnd hwnd) + { + if (ActiveWindow == hwnd.Handle) { + SendMessage(hwnd.client_window, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_INACTIVE, IntPtr.Zero); + ActiveWindow = IntPtr.Zero; + } + + if (FocusWindow == hwnd.Handle) { + SendMessage(hwnd.client_window, Msg.WM_KILLFOCUS, IntPtr.Zero, IntPtr.Zero); + FocusWindow = IntPtr.Zero; + } + + if (Grab.Hwnd == hwnd.Handle) { + Grab.Hwnd = IntPtr.Zero; + Grab.Confined = false; + } + + DestroyCaret (hwnd.Handle); + } + + void PerformNCCalc(Hwnd hwnd) { + XplatUIWin32.NCCALCSIZE_PARAMS ncp; + IntPtr ptr; + Rectangle rect; + + rect = new Rectangle (0, 0, hwnd.Width, hwnd.Height); + + ncp = new XplatUIWin32.NCCALCSIZE_PARAMS(); + ptr = Marshal.AllocHGlobal(Marshal.SizeOf(ncp)); + + ncp.rgrc1.left = rect.Left; + ncp.rgrc1.top = rect.Top; + ncp.rgrc1.right = rect.Right; + ncp.rgrc1.bottom = rect.Bottom; + + Marshal.StructureToPtr(ncp, ptr, true); + NativeWindow.WndProc(hwnd.client_window, Msg.WM_NCCALCSIZE, (IntPtr)1, ptr); + ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure(ptr, typeof(XplatUIWin32.NCCALCSIZE_PARAMS)); + Marshal.FreeHGlobal(ptr); + + + rect = new Rectangle(ncp.rgrc1.left, ncp.rgrc1.top, ncp.rgrc1.right - ncp.rgrc1.left, ncp.rgrc1.bottom - ncp.rgrc1.top); + hwnd.ClientRect = rect; + + rect = TranslateClientRectangleToXClientRectangle (hwnd); + + if (hwnd.visible) { + MoveResizeWindow (DisplayHandle, hwnd.client_window, rect.X, rect.Y, rect.Width, rect.Height); + } + + AddExpose (hwnd, hwnd.WholeWindow == hwnd.ClientWindow, 0, 0, hwnd.Width, hwnd.Height); + } + #endregion // Methods + + #region Callbacks + void MouseHover(object sender, EventArgs e) { + XEvent xevent; + Hwnd hwnd; + + HoverState.Timer.Enabled = false; + + if (HoverState.Window != IntPtr.Zero) { + hwnd = Hwnd.GetObjectFromWindow(HoverState.Window); + if (hwnd != null) { + xevent = new XEvent (); + + xevent.type = XEventName.ClientMessage; + xevent.ClientMessageEvent.display = DisplayHandle; + xevent.ClientMessageEvent.window = HoverState.Window; + xevent.ClientMessageEvent.message_type = HoverState.Atom; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = (IntPtr) (HoverState.Y << 16 | HoverState.X); + + hwnd.Queue.EnqueueLocked (xevent); + + WakeupMain (); + } + } + } + + void CaretCallback(object sender, EventArgs e) { + if (Caret.Paused) { + return; + } + Caret.On = !Caret.On; + + XDrawLine(DisplayHandle, Caret.Hwnd, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height); + } + #endregion // Callbacks + + #region Public Properties + + internal override int CaptionHeight { + get { + return 19; + } + } + + internal override Size CursorSize { + get { + int x; + int y; + + if (XQueryBestCursor(DisplayHandle, RootWindow, 32, 32, out x, out y) != 0) { + return new Size(x, y); + } else { + return new Size(16, 16); + } + } + } + + internal override bool DragFullWindows { + get { + return true; + } + } + + internal override Size DragSize { + get { + return new Size(4, 4); + } + } + + internal override Size FrameBorderSize { + get { + return new Size (4, 4); + } + } + + internal override Size IconSize { + get { + IntPtr list; + XIconSize size; + int count; + + if (XGetIconSizes(DisplayHandle, RootWindow, out list, out count) != 0) { + long current; + int largest; + + current = (long)list; + largest = 0; + + size = new XIconSize(); + + for (int i = 0; i < count; i++) { + size = (XIconSize)Marshal.PtrToStructure((IntPtr)current, size.GetType()); + current += Marshal.SizeOf(size); + + // Look for our preferred size + if (size.min_width == 32) { + XFree(list); + return new Size(32, 32); + } + + if (size.max_width == 32) { + XFree(list); + return new Size(32, 32); + } + + if (size.min_width < 32 && size.max_width > 32) { + int x; + + // check if we can fit one + x = size.min_width; + while (x < size.max_width) { + x += size.width_inc; + if (x == 32) { + XFree(list); + return new Size(32, 32); + } + } + } + + if (largest < size.max_width) { + largest = size.max_width; + } + } + + // We didn't find a match or we wouldn't be here + return new Size(largest, largest); + + } else { + return new Size(32, 32); + } + } + } + + internal override int KeyboardSpeed { + get{ + // + // A lot harder: need to do: + // XkbQueryExtension(0x08051008, 0xbfffdf4c, 0xbfffdf50, 0xbfffdf54, 0xbfffdf58) = 1 + // XkbAllocKeyboard(0x08051008, 0xbfffdf4c, 0xbfffdf50, 0xbfffdf54, 0xbfffdf58) = 0x080517a8 + // XkbGetWidgets(0x08051008, 1, 0x080517a8, 0xbfffdf54, 0xbfffdf58) = 0 + // + // And from that we can tell the repetition rate + // + // Notice, the values must map to: + // [0, 31] which maps to 2.5 to 30 repetitions per second. + // + return 0; + } + } + + internal override int KeyboardDelay { + get { + // + // Return values must range from 0 to 4, 0 meaning 250ms, + // and 4 meaning 1000 ms. + // + return 1; // ie, 500 ms + } + } + + internal override Size MaxWindowTrackSize { + get { + return new Size (WorkingArea.Width, WorkingArea.Height); + } + } + + internal override bool MenuAccessKeysUnderlined { + get { + return false; + } + } + + internal override Size MinimizedWindowSpacingSize { + get { + return new Size(1, 1); + } + } + + internal override Size MinimumWindowSize { + get { + return new Size(110, 22); + } + } + + internal override Size MinimumFixedToolWindowSize { + get { return new Size (27, 22); } + } + + internal override Size MinimumSizeableToolWindowSize { + get { return new Size (37, 22); } + } + + internal override Size MinimumNoBorderWindowSize { + get { return new Size (2, 2); } + } + + internal override Keys ModifierKeys { + get { + return Keyboard.ModifierKeys; + } + } + + internal override Size SmallIconSize { + get { + IntPtr list; + XIconSize size; + int count; + + if (XGetIconSizes(DisplayHandle, RootWindow, out list, out count) != 0) { + long current; + int smallest; + + current = (long)list; + smallest = 0; + + size = new XIconSize(); + + for (int i = 0; i < count; i++) { + size = (XIconSize)Marshal.PtrToStructure((IntPtr)current, size.GetType()); + current += Marshal.SizeOf(size); + + // Look for our preferred size + if (size.min_width == 16) { + XFree(list); + return new Size(16, 16); + } + + if (size.max_width == 16) { + XFree(list); + return new Size(16, 16); + } + + if (size.min_width < 16 && size.max_width > 16) { + int x; + + // check if we can fit one + x = size.min_width; + while (x < size.max_width) { + x += size.width_inc; + if (x == 16) { + XFree(list); + return new Size(16, 16); + } + } + } + + if (smallest == 0 || smallest > size.min_width) { + smallest = size.min_width; + } + } + + // We didn't find a match or we wouldn't be here + return new Size(smallest, smallest); + + } else { + return new Size(16, 16); + } + } + } + + internal override int MouseButtonCount { + get { + return 3; + } + } + + internal override bool MouseButtonsSwapped { + get { + return false; // FIXME - how to detect? + } + } + + internal override Point MousePosition { + get { + return mouse_position; + } + } + + internal override Size MouseHoverSize { + get { + return new Size (1, 1); + } + } + + internal override int MouseHoverTime { + get { + return HoverState.Interval; + } + } + + + + internal override bool MouseWheelPresent { + get { + return true; // FIXME - how to detect? + } + } + + internal override MouseButtons MouseButtons { + get { + return MouseState; + } + } + + internal override Rectangle VirtualScreen { + get { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + int width; + int height; + + XGetWindowProperty(DisplayHandle, RootWindow, _NET_DESKTOP_GEOMETRY, IntPtr.Zero, new IntPtr (256), false, (IntPtr)Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + if ((long)nitems < 2) + goto failsafe; + + width = Marshal.ReadIntPtr(prop, 0).ToInt32(); + height = Marshal.ReadIntPtr(prop, IntPtr.Size).ToInt32(); + + XFree(prop); + + return new Rectangle(0, 0, width, height); + + failsafe: + XWindowAttributes attributes=new XWindowAttributes(); + + lock (XlibLock) { + XGetWindowAttributes(DisplayHandle, XRootWindow(DisplayHandle, 0), ref attributes); + } + + return new Rectangle(0, 0, attributes.width, attributes.height); + } + } + + internal override Rectangle WorkingArea { + get { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + int width; + int height; + int current_desktop; + int x; + int y; + + XGetWindowProperty(DisplayHandle, RootWindow, _NET_CURRENT_DESKTOP, IntPtr.Zero, new IntPtr(1), false, (IntPtr)Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + if ((long)nitems < 1) { + goto failsafe; + } + + current_desktop = Marshal.ReadIntPtr(prop, 0).ToInt32(); + XFree(prop); + + XGetWindowProperty(DisplayHandle, RootWindow, _NET_WORKAREA, IntPtr.Zero, new IntPtr (256), false, (IntPtr)Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + if ((long)nitems < 4 * (current_desktop + 1)) { + goto failsafe; + } + + x = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop).ToInt32(); + y = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size).ToInt32(); + width = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size * 2).ToInt32(); + height = Marshal.ReadIntPtr(prop, IntPtr.Size * 4 * current_desktop + IntPtr.Size * 3).ToInt32(); + XFree(prop); + + return new Rectangle(x, y, width, height); + + failsafe: + XWindowAttributes attributes=new XWindowAttributes(); + + lock (XlibLock) { + XGetWindowAttributes(DisplayHandle, XRootWindow(DisplayHandle, 0), ref attributes); + } + + return new Rectangle(0, 0, attributes.width, attributes.height); + } + } + + internal override Screen[] AllScreens { + get { + if (!XineramaIsActive (DisplayHandle)) + return null; + int nScreens; + IntPtr xineramaScreens = XineramaQueryScreens (DisplayHandle, out nScreens); + var screens = new Screen [nScreens]; + IntPtr current = xineramaScreens; + for (int i = 0; i < nScreens; i++) { + var screen = (XineramaScreenInfo)Marshal.PtrToStructure (current, + typeof (XineramaScreenInfo)); + var screenRect = new Rectangle (screen.x_org, screen.y_org, screen.width, + screen.height); + var name = string.Format ("Display {0}", screen.screen_number); + screens [i] = new Screen (i == 0, name, screenRect, screenRect); + current = (IntPtr)( (ulong)current + (ulong)Marshal.SizeOf(typeof (XineramaScreenInfo))); + } + XFree (xineramaScreens); + return screens; + } + } + + internal override bool ThemesEnabled { + get { + return XplatUIX11.themes_enabled; + } + } + + + #endregion // Public properties + + #region Public Static Methods + internal override void RaiseIdle (EventArgs e) + { + if (Idle != null) + Idle (this, e); + } + + internal override IntPtr InitializeDriver() + { + lock (this) { + if (DisplayHandle==IntPtr.Zero) { + SetDisplay(XOpenDisplay(IntPtr.Zero)); + } + } + return IntPtr.Zero; + } + + internal override void ShutdownDriver(IntPtr token) + { + lock (this) { + if (DisplayHandle!=IntPtr.Zero) { + XCloseDisplay(DisplayHandle); + DisplayHandle=IntPtr.Zero; + } + } + } + + internal override void EnableThemes() + { + themes_enabled = true; + } + + + internal override void Activate(IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) { + lock (XlibLock) { + if (true /* the window manager supports NET_ACTIVE_WINDOW */) { + SendNetWMMessage(hwnd.whole_window, _NET_ACTIVE_WINDOW, (IntPtr)1, IntPtr.Zero, IntPtr.Zero); + XEventQueue q = null; + lock (unattached_timer_list) { + foreach (Timer t in unattached_timer_list) { + if (q == null) + q= (XEventQueue) MessageQueues [Thread.CurrentThread]; + t.thread = q.Thread; + q.timer_list.Add (t); + } + unattached_timer_list.Clear (); + } + } +// else { +// XRaiseWindow(DisplayHandle, handle); +// } + } + } + } + + internal override void AudibleAlert(AlertType alert) + { + XBell(DisplayHandle, 0); + return; + } + + + internal override void CaretVisible(IntPtr handle, bool visible) + { + if (Caret.Hwnd == handle) { + if (visible) { + if (!Caret.Visible) { + Caret.Visible = true; + ShowCaret(); + Caret.Timer.Start(); + } + } else { + Caret.Visible = false; + Caret.Timer.Stop(); + HideCaret(); + } + } + } + + internal override bool CalculateWindowRect(ref Rectangle ClientRect, CreateParams cp, Menu menu, out Rectangle WindowRect) + { + WindowRect = Hwnd.GetWindowRectangle (cp, menu, ClientRect); + return true; + } + + internal override void ClientToScreen(IntPtr handle, ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + IntPtr child; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + lock (XlibLock) { + XTranslateCoordinates(handle, hwnd.client_window, RootWindow, x, y, out dest_x_return, out dest_y_return, out child); + } + + x = dest_x_return; + y = dest_y_return; + } + + internal override int[] ClipboardAvailableFormats(IntPtr handle) + { + DataFormats.Format f; + int[] result; + + f = DataFormats.Format.List; + + if (XGetSelectionOwner(DisplayHandle, CLIPBOARD) == IntPtr.Zero) { + return null; + } + + Clipboard.Formats = new ArrayList(); + + while (f != null) { + XConvertSelection(DisplayHandle, CLIPBOARD, (IntPtr)f.Id, (IntPtr)f.Id, FosterParent, IntPtr.Zero); + + var timeToWaitForSelectionFormats = TimeSpan.FromSeconds(4); + var startTime = DateTime.Now; + Clipboard.Enumerating = true; + while (Clipboard.Enumerating) { + UpdateMessageQueue(null, false); + + if (DateTime.Now - startTime > timeToWaitForSelectionFormats) + break; + } + f = f.Next; + } + + result = new int[Clipboard.Formats.Count]; + + for (int i = 0; i < Clipboard.Formats.Count; i++) { + result[i] = ((IntPtr)Clipboard.Formats[i]).ToInt32 (); + } + + Clipboard.Formats = null; + return result; + } + + internal override void ClipboardClose(IntPtr handle) + { + if (handle != ClipMagic) { + throw new ArgumentException("handle is not a valid clipboard handle"); + } + return; + } + + internal override int ClipboardGetID(IntPtr handle, string format) + { + if (handle != ClipMagic) { + throw new ArgumentException("handle is not a valid clipboard handle"); + } + + if (format == "Text" ) return (int)Atom.XA_STRING; + else if (format == "Bitmap" ) return (int)Atom.XA_BITMAP; + //else if (format == "MetaFilePict" ) return 3; + //else if (format == "SymbolicLink" ) return 4; + //else if (format == "DataInterchangeFormat" ) return 5; + //else if (format == "Tiff" ) return 6; + else if (format == "OEMText" ) return OEMTEXT.ToInt32(); + else if (format == "DeviceIndependentBitmap" ) return (int)Atom.XA_PIXMAP; + else if (format == "Palette" ) return (int)Atom.XA_COLORMAP; // Useless + //else if (format == "PenData" ) return 10; + //else if (format == "RiffAudio" ) return 11; + //else if (format == "WaveAudio" ) return 12; + else if (format == "UnicodeText" ) return UTF16_STRING.ToInt32(); + //else if (format == "EnhancedMetafile" ) return 14; + //else if (format == "FileDrop" ) return 15; + //else if (format == "Locale" ) return 16; + else if (format == "Rich Text Format") return RICHTEXTFORMAT.ToInt32 (); + + return XInternAtom(DisplayHandle, format, false).ToInt32(); + } + + internal override IntPtr ClipboardOpen(bool primary_selection) + { + if (!primary_selection) + ClipMagic = CLIPBOARD; + else + ClipMagic = PRIMARY; + return ClipMagic; + } + + internal override object ClipboardRetrieve(IntPtr handle, int type, XplatUI.ClipboardToObject converter) + { + XConvertSelection(DisplayHandle, handle, (IntPtr)type, (IntPtr)type, FosterParent, IntPtr.Zero); + + Clipboard.Retrieving = true; + while (Clipboard.Retrieving) { + UpdateMessageQueue(null, false); + } + + return Clipboard.Item; + } + + internal override void ClipboardStore (IntPtr handle, object obj, int type, XplatUI.ObjectToClipboard converter, bool copy) + { + Clipboard.Converter = converter; + + if (obj != null) { + Clipboard.AddSource (type, obj); + XSetSelectionOwner (DisplayHandle, CLIPBOARD, FosterParent, IntPtr.Zero); + + if (copy) { + try { + var clipboardAtom = gdk_atom_intern ("CLIPBOARD", true); + var clipboard = gtk_clipboard_get (clipboardAtom); + if (clipboard != null) { + // for now we only store text + var text = Clipboard.GetRtfText (); + if (string.IsNullOrEmpty (text)) + text = Clipboard.GetPlainText (); + if (!string.IsNullOrEmpty (text)) { + gtk_clipboard_set_text (clipboard, text, text.Length); + gtk_clipboard_store (clipboard); + } + } + } catch { + // ignore any errors - most likely because gtk isn't installed? + } + } + } else { + // Clearing the selection + Clipboard.ClearSources (); + XSetSelectionOwner (DisplayHandle, CLIPBOARD, IntPtr.Zero, IntPtr.Zero); + } + } + + internal override void CreateCaret (IntPtr handle, int width, int height) + { + XGCValues gc_values; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (Caret.Hwnd != IntPtr.Zero) { + DestroyCaret(Caret.Hwnd); + } + + Caret.Hwnd = handle; + Caret.Window = hwnd.client_window; + Caret.Width = width; + Caret.Height = height; + Caret.Visible = false; + Caret.On = false; + + gc_values = new XGCValues(); + gc_values.line_width = width; + + Caret.gc = XCreateGC(DisplayHandle, Caret.Window, new IntPtr ((int)GCFunction.GCLineWidth), ref gc_values); + if (Caret.gc == IntPtr.Zero) { + Caret.Hwnd = IntPtr.Zero; + return; + } + + XSetFunction(DisplayHandle, Caret.gc, GXFunction.GXinvert); + } + + internal override IntPtr CreateWindow (CreateParams cp) + { + XSetWindowAttributes Attributes; + Hwnd hwnd; + Hwnd parent_hwnd = null; + int X; + int Y; + int Width; + int Height; + IntPtr ParentHandle; + IntPtr WholeWindow; + IntPtr ClientWindow; + SetWindowValuemask ValueMask; + + hwnd = new Hwnd(); + + Attributes = new XSetWindowAttributes(); + X = cp.X; + Y = cp.Y; + Width = cp.Width; + Height = cp.Height; + + if (Width<1) Width=1; + if (Height<1) Height=1; + + if (cp.Parent != IntPtr.Zero) { + parent_hwnd = Hwnd.ObjectFromHandle(cp.Parent); + ParentHandle = parent_hwnd.client_window; + } else { + if (StyleSet (cp.Style, WindowStyles.WS_CHILD)) { + // We need to use our foster parent window until this poor child gets it's parent assigned + ParentHandle=FosterParent; + } else { + ParentHandle=RootWindow; + } + } + + // Set the default location location for forms. + Point next; + if (cp.control is Form) { + next = Hwnd.GetNextStackedFormLocation (cp, parent_hwnd); + X = next.X; + Y = next.Y; + } + ValueMask = SetWindowValuemask.BitGravity | SetWindowValuemask.WinGravity; + + Attributes.bit_gravity = Gravity.NorthWestGravity; + Attributes.win_gravity = Gravity.NorthWestGravity; + + // Save what's under the toolwindow + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOOLWINDOW)) { + Attributes.save_under = true; + ValueMask |= SetWindowValuemask.SaveUnder; + } + + + // If we're a popup without caption we override the WM + if (StyleSet (cp.Style, WindowStyles.WS_POPUP) && !StyleSet (cp.Style, WindowStyles.WS_CAPTION)) { + Attributes.override_redirect = true; + ValueMask |= SetWindowValuemask.OverrideRedirect; + } + + hwnd.x = X; + hwnd.y = Y; + hwnd.width = Width; + hwnd.height = Height; + hwnd.parent = Hwnd.ObjectFromHandle(cp.Parent); + hwnd.initial_style = cp.WindowStyle; + hwnd.initial_ex_style = cp.WindowExStyle; + + if (StyleSet (cp.Style, WindowStyles.WS_DISABLED)) { + hwnd.enabled = false; + } + + ClientWindow = IntPtr.Zero; + + Size XWindowSize = TranslateWindowSizeToXWindowSize (cp); + Rectangle XClientRect = TranslateClientRectangleToXClientRectangle (hwnd, cp.control); + + lock (XlibLock) { + WholeWindow = XCreateWindow(DisplayHandle, ParentHandle, X, Y, XWindowSize.Width, XWindowSize.Height, 0, (int)CreateWindowArgs.CopyFromParent, (int)CreateWindowArgs.InputOutput, IntPtr.Zero, new UIntPtr ((uint)ValueMask), ref Attributes); + if (WholeWindow != IntPtr.Zero) { + ValueMask &= ~(SetWindowValuemask.OverrideRedirect | SetWindowValuemask.SaveUnder); + + if (CustomVisual != IntPtr.Zero && CustomColormap != IntPtr.Zero) { + ValueMask = SetWindowValuemask.ColorMap; + Attributes.colormap = CustomColormap; + } + ClientWindow = XCreateWindow(DisplayHandle, WholeWindow, XClientRect.X, XClientRect.Y, XClientRect.Width, XClientRect.Height, 0, (int)CreateWindowArgs.CopyFromParent, (int)CreateWindowArgs.InputOutput, CustomVisual, new UIntPtr ((uint)ValueMask), ref Attributes); + } + } + + if ((WholeWindow == IntPtr.Zero) || (ClientWindow == IntPtr.Zero)) { + throw new Exception("Could not create X11 windows"); + } + + hwnd.Queue = ThreadQueue(Thread.CurrentThread); + hwnd.WholeWindow = WholeWindow; + hwnd.ClientWindow = ClientWindow; + + DriverDebug("Created window {0:X} / {1:X} parent {2:X}, Style {3}, ExStyle {4}", ClientWindow.ToInt32(), WholeWindow.ToInt32(), hwnd.parent != null ? hwnd.parent.Handle.ToInt32() : 0, (WindowStyles)cp.Style, (WindowExStyles)cp.ExStyle); + + if (!StyleSet (cp.Style, WindowStyles.WS_CHILD)) { + if ((X != unchecked((int)0x80000000)) && (Y != unchecked((int)0x80000000))) { + XSizeHints hints; + + hints = new XSizeHints(); + hints.x = X; + hints.y = Y; + hints.flags = (IntPtr)(XSizeHintsFlags.USPosition | XSizeHintsFlags.PPosition); + XSetWMNormalHints(DisplayHandle, WholeWindow, ref hints); + } + } + + lock (XlibLock) { + XSelectInput(DisplayHandle, hwnd.whole_window, new IntPtr ((int)(SelectInputMask | EventMask.StructureNotifyMask | EventMask.PropertyChangeMask | Keyboard.KeyEventMask))); + if (hwnd.whole_window != hwnd.client_window) + XSelectInput(DisplayHandle, hwnd.client_window, new IntPtr ((int)(SelectInputMask | EventMask.StructureNotifyMask | Keyboard.KeyEventMask))); + } + + if (ExStyleSet (cp.ExStyle, WindowExStyles.WS_EX_TOPMOST)) + SetTopmost(hwnd.whole_window, true); + + SetWMStyles(hwnd, cp); + + // set the group leader + XWMHints wm_hints = new XWMHints (); + + wm_hints.flags = (IntPtr)(XWMHintsFlags.InputHint | XWMHintsFlags.StateHint | XWMHintsFlags.WindowGroupHint); + wm_hints.input = !StyleSet (cp.Style, WindowStyles.WS_DISABLED); + wm_hints.initial_state = StyleSet (cp.Style, WindowStyles.WS_MINIMIZE) ? XInitialState.IconicState : XInitialState.NormalState; + + if (ParentHandle != RootWindow) { + wm_hints.window_group = hwnd.whole_window; + } else { + wm_hints.window_group = ParentHandle; + } + + lock (XlibLock) { + XSetWMHints(DisplayHandle, hwnd.whole_window, ref wm_hints ); + } + + if (StyleSet (cp.Style, WindowStyles.WS_MINIMIZE)) { + SetWindowState(hwnd.Handle, FormWindowState.Minimized); + } else if (StyleSet (cp.Style, WindowStyles.WS_MAXIMIZE)) { + SetWindowState(hwnd.Handle, FormWindowState.Maximized); + } + + // for now make all windows dnd enabled + Dnd.SetAllowDrop (hwnd, true); + + // Set caption/window title + Text(hwnd.Handle, cp.Caption); + + SendMessage (hwnd.Handle, Msg.WM_CREATE, (IntPtr)1, IntPtr.Zero /* XXX unused */); + SendParentNotify (hwnd.Handle, Msg.WM_CREATE, int.MaxValue, int.MaxValue); + + if (StyleSet (cp.Style, WindowStyles.WS_VISIBLE)) { + hwnd.visible = true; + MapWindow(hwnd, WindowType.Both); + if (!(Widget.FromHandle(hwnd.Handle) is Form)) + SendMessage(hwnd.Handle, Msg.WM_SHOWWINDOW, (IntPtr)1, IntPtr.Zero); + } + + return hwnd.Handle; + } + + internal override IntPtr CreateWindow(IntPtr Parent, int X, int Y, int Width, int Height) + { + CreateParams create_params = new CreateParams(); + + create_params.Caption = ""; + create_params.X = X; + create_params.Y = Y; + create_params.Width = Width; + create_params.Height = Height; + + create_params.ClassName=XplatUI.GetDefaultClassName (GetType ()); + create_params.ClassStyle = 0; + create_params.ExStyle=0; + create_params.Parent=IntPtr.Zero; + create_params.Param=0; + + return CreateWindow(create_params); + } + + internal override IntPtr DefineCursor(Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot) + { + IntPtr cursor; + Bitmap cursor_bitmap; + Bitmap cursor_mask; + Byte[] cursor_bits; + Byte[] mask_bits; + Color c_pixel; + Color m_pixel; + int width; + int height; + IntPtr cursor_pixmap; + IntPtr mask_pixmap; + XColor fg; + XColor bg; + bool and; + bool xor; + + if (XQueryBestCursor(DisplayHandle, RootWindow, bitmap.Width, bitmap.Height, out width, out height) == 0) { + return IntPtr.Zero; + } + + // Win32 only allows creation cursors of a certain size + if ((bitmap.Width != width) || (bitmap.Width != height)) { + cursor_bitmap = new Bitmap(bitmap, new Size(width, height)); + cursor_mask = new Bitmap(mask, new Size(width, height)); + } else { + cursor_bitmap = bitmap; + cursor_mask = mask; + } + + width = cursor_bitmap.Width; + height = cursor_bitmap.Height; + + cursor_bits = new Byte[(width / 8) * height]; + mask_bits = new Byte[(width / 8) * height]; + + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + c_pixel = cursor_bitmap.GetPixel(x, y); + m_pixel = cursor_mask.GetPixel(x, y); + + and = c_pixel == cursor_pixel; + xor = m_pixel == mask_pixel; + + if (!and && !xor) { + // Black + // cursor_bits[y * width / 8 + x / 8] &= (byte)~((1 << (x % 8))); // The bit already is 0 + mask_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8)); + } else if (and && !xor) { + // White + cursor_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8)); + mask_bits[y * width / 8 + x / 8] |= (byte)(1 << (x % 8)); +#if notneeded + } else if (and && !xor) { + // Screen + } else if (and && xor) { + // Inverse Screen + + // X11 doesn't know the 'reverse screen' concept, so we'll treat them the same + // we want both to be 0 so nothing to be done + //cursor_bits[y * width / 8 + x / 8] &= (byte)~((1 << (x % 8))); + //mask_bits[y * width / 8 + x / 8] |= (byte)(01 << (x % 8)); +#endif + } + } + } + + cursor_pixmap = XCreatePixmapFromBitmapData(DisplayHandle, RootWindow, cursor_bits, width, height, (IntPtr)1, (IntPtr)0, 1); + mask_pixmap = XCreatePixmapFromBitmapData(DisplayHandle, RootWindow, mask_bits, width, height, (IntPtr)1, (IntPtr)0, 1); + fg = new XColor(); + bg = new XColor(); + + fg.pixel = XWhitePixel(DisplayHandle, ScreenNo); + fg.red = (ushort)65535; + fg.green = (ushort)65535; + fg.blue = (ushort)65535; + + bg.pixel = XBlackPixel(DisplayHandle, ScreenNo); + + cursor = XCreatePixmapCursor(DisplayHandle, cursor_pixmap, mask_pixmap, ref fg, ref bg, xHotSpot, yHotSpot); + + XFreePixmap(DisplayHandle, cursor_pixmap); + XFreePixmap(DisplayHandle, mask_pixmap); + + return cursor; + } + + internal override Bitmap DefineStdCursorBitmap (StdCursor id) + { + CursorFontShape shape; + string name; + IntPtr theme; + int size; + Bitmap bmp = null; + + try { + shape = StdCursorToFontShape (id); + name = shape.ToString ().Replace ("XC_", string.Empty); + size = XcursorGetDefaultSize (DisplayHandle); + theme = XcursorGetTheme (DisplayHandle); + IntPtr images_ptr = XcursorLibraryLoadImages (name, theme, size); + DriverDebug ("DefineStdCursorBitmap, id={0}, #id={1}, name{2}, size={3}, theme: {4}, images_ptr={5}", id, (int) id, name, size, Marshal.PtrToStringAnsi (theme), images_ptr); + + if (images_ptr == IntPtr.Zero) { + return null; + } + + XcursorImages images = (XcursorImages) Marshal.PtrToStructure (images_ptr, typeof (XcursorImages)); + DriverDebug ("DefineStdCursorBitmap, cursor has {0} images", images.nimage); + + if (images.nimage > 0) { + // We only care about the first image. + XcursorImage image = (XcursorImage)Marshal.PtrToStructure (Marshal.ReadIntPtr (images.images), typeof (XcursorImage)); + + DriverDebug ("DefineStdCursorBitmap, loaded image <size={0}, height={1}, width={2}, xhot={3}, yhot={4}, pixels={5}", image.size, image.height, image.width, image.xhot, image.yhot, image.pixels); + // A sanity check + if (image.width <= short.MaxValue && image.height <= short.MaxValue) { + int [] pixels = new int [image.width * image.height]; + Marshal.Copy (image.pixels, pixels, 0, pixels.Length); + bmp = new Bitmap (image.width, image.height); + for (int w = 0; w < image.width; w++) { + for (int h = 0; h < image.height; h++) { + bmp.SetPixel (w, h, Color.FromArgb (pixels [h * image.width + w])); + } + } + } + } + + XcursorImagesDestroy (images_ptr); + + } catch (DllNotFoundException ex) { + Console.WriteLine ("Could not load libXcursor: " + ex.Message + " (" + ex.GetType ().Name + ")"); + return null; + } + + return bmp; + } + + + internal override IntPtr DefineStdCursor(StdCursor id) + { + CursorFontShape shape; + IntPtr cursor; + + shape = StdCursorToFontShape (id); + + lock (XlibLock) { + cursor = XCreateFontCursor(DisplayHandle, shape); + } + return cursor; + } + + internal static CursorFontShape StdCursorToFontShape (StdCursor id) + { + CursorFontShape shape; + // FIXME - define missing shapes + + switch (id) { + case StdCursor.AppStarting: { + shape = CursorFontShape.XC_watch; + break; + } + + case StdCursor.Arrow: { + shape = CursorFontShape.XC_top_left_arrow; + break; + } + + case StdCursor.Cross: { + shape = CursorFontShape.XC_crosshair; + break; + } + + case StdCursor.Default: { + shape = CursorFontShape.XC_top_left_arrow; + break; + } + + case StdCursor.Hand: { + shape = CursorFontShape.XC_hand1; + break; + } + + case StdCursor.Help: { + shape = CursorFontShape.XC_question_arrow; + break; + } + + case StdCursor.HSplit: { + shape = CursorFontShape.XC_sb_v_double_arrow; + break; + } + + case StdCursor.IBeam: { + shape = CursorFontShape.XC_xterm; + break; + } + + case StdCursor.No: { + shape = CursorFontShape.XC_circle; + break; + } + + case StdCursor.NoMove2D: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.NoMoveHoriz: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.NoMoveVert: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanEast: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanNE: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanNorth: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanNW: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanSE: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanSouth: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanSW: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanWest: { + shape = CursorFontShape.XC_sizing; + break; + } + + case StdCursor.SizeAll: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.SizeNESW: { + shape = CursorFontShape.XC_top_right_corner; + break; + } + + case StdCursor.SizeNS: { + shape = CursorFontShape.XC_sb_v_double_arrow; + break; + } + + case StdCursor.SizeNWSE: { + shape = CursorFontShape.XC_top_left_corner; + break; + } + + case StdCursor.SizeWE: { + shape = CursorFontShape.XC_sb_h_double_arrow; + break; + } + + case StdCursor.UpArrow: { + shape = CursorFontShape.XC_center_ptr; + break; + } + + case StdCursor.VSplit: { + shape = CursorFontShape.XC_sb_h_double_arrow; + break; + } + + case StdCursor.WaitCursor: { + shape = CursorFontShape.XC_watch; + break; + } + + default: { + shape = (CursorFontShape) 0; + break; + } + } + + return shape; + } + + internal override IntPtr DefWndProc(ref Message msg) + { + switch ((Msg)msg.Msg) { + + case Msg.WM_IME_COMPOSITION: + string s = Keyboard.GetCompositionString (); + foreach (char c in s) + SendMessage (msg.HWnd, Msg.WM_IME_CHAR, (IntPtr) c, msg.LParam); + return IntPtr.Zero; + + case Msg.WM_IME_CHAR: + // On Windows API it sends two WM_CHAR messages for each byte, but + // I wonder if it is worthy to emulate it (also no idea how to + // reconstruct those bytes into chars). + SendMessage (msg.HWnd, Msg.WM_CHAR, msg.WParam, msg.LParam); + return IntPtr.Zero; + + case Msg.WM_PAINT: { + Hwnd hwnd; + + hwnd = Hwnd.GetObjectFromWindow(msg.HWnd); + if (hwnd != null) { + hwnd.expose_pending = false; + } + + return IntPtr.Zero; + } + + case Msg.WM_NCPAINT: { + Hwnd hwnd; + + hwnd = Hwnd.GetObjectFromWindow(msg.HWnd); + if (hwnd != null) { + hwnd.nc_expose_pending = false; + } + + return IntPtr.Zero; + } + + case Msg.WM_NCCALCSIZE: { + Hwnd hwnd; + + if (msg.WParam == (IntPtr)1) { + hwnd = Hwnd.GetObjectFromWindow (msg.HWnd); + + XplatUIWin32.NCCALCSIZE_PARAMS ncp; + ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure (msg.LParam, typeof (XplatUIWin32.NCCALCSIZE_PARAMS)); + + // Add all the stuff X is supposed to draw. + Widget ctrl = Widget.FromHandle (hwnd.Handle); + + if (ctrl != null) { + Hwnd.Borders rect = Hwnd.GetBorders (ctrl.GetCreateParams (), null); + + ncp.rgrc1.top += rect.top; + ncp.rgrc1.bottom -= rect.bottom; + ncp.rgrc1.left += rect.left; + ncp.rgrc1.right -= rect.right; + + Marshal.StructureToPtr (ncp, msg.LParam, true); + } + } + + return IntPtr.Zero; + } + + case Msg.WM_CONTEXTMENU: { + Hwnd hwnd; + + hwnd = Hwnd.GetObjectFromWindow(msg.HWnd); + + if ((hwnd != null) && (hwnd.parent != null)) { + SendMessage(hwnd.parent.client_window, Msg.WM_CONTEXTMENU, msg.WParam, msg.LParam); + } + return IntPtr.Zero; + } + + case Msg.WM_MOUSEWHEEL: { + Hwnd hwnd; + + hwnd = Hwnd.GetObjectFromWindow(msg.HWnd); + + if ((hwnd != null) && (hwnd.parent != null)) { + SendMessage(hwnd.parent.client_window, Msg.WM_MOUSEWHEEL, msg.WParam, msg.LParam); + if (msg.Result == IntPtr.Zero) { + return IntPtr.Zero; + } + } + return IntPtr.Zero; + } + + case Msg.WM_SETCURSOR: { + Hwnd hwnd; + + hwnd = Hwnd.GetObjectFromWindow(msg.HWnd); + if (hwnd == null) + break; // not sure how this happens, but it does + + // Pass to parent window first + while ((hwnd.parent != null) && (msg.Result == IntPtr.Zero)) { + hwnd = hwnd.parent; + msg.Result = NativeWindow.WndProc(hwnd.Handle, Msg.WM_SETCURSOR, msg.HWnd, msg.LParam); + } + + if (msg.Result == IntPtr.Zero) { + IntPtr handle; + + switch((HitTest)(msg.LParam.ToInt32() & 0xffff)) { + case HitTest.HTBOTTOM: handle = Cursors.SizeNS.handle; break; + case HitTest.HTBORDER: handle = Cursors.SizeNS.handle; break; + case HitTest.HTBOTTOMLEFT: handle = Cursors.SizeNESW.handle; break; + case HitTest.HTBOTTOMRIGHT: handle = Cursors.SizeNWSE.handle; break; + case HitTest.HTERROR: if ((msg.LParam.ToInt32() >> 16) == (int)Msg.WM_LBUTTONDOWN) { + AudibleAlert(AlertType.Default); + } + handle = Cursors.Default.handle; + break; + + case HitTest.HTHELP: handle = Cursors.Help.handle; break; + case HitTest.HTLEFT: handle = Cursors.SizeWE.handle; break; + case HitTest.HTRIGHT: handle = Cursors.SizeWE.handle; break; + case HitTest.HTTOP: handle = Cursors.SizeNS.handle; break; + case HitTest.HTTOPLEFT: handle = Cursors.SizeNWSE.handle; break; + case HitTest.HTTOPRIGHT: handle = Cursors.SizeNESW.handle; break; + + #if SameAsDefault + case HitTest.HTGROWBOX: + case HitTest.HTSIZE: + case HitTest.HTZOOM: + case HitTest.HTVSCROLL: + case HitTest.HTSYSMENU: + case HitTest.HTREDUCE: + case HitTest.HTNOWHERE: + case HitTest.HTMAXBUTTON: + case HitTest.HTMINBUTTON: + case HitTest.HTMENU: + case HitTest.HSCROLL: + case HitTest.HTBOTTOM: + case HitTest.HTCAPTION: + case HitTest.HTCLIENT: + case HitTest.HTCLOSE: + #endif + default: handle = Cursors.Default.handle; break; + } + SetCursor(msg.HWnd, handle); + } + return (IntPtr)1; + } + } + return IntPtr.Zero; + } + + internal override void DestroyCaret(IntPtr handle) + { + if (Caret.Hwnd == handle) { + if (Caret.Visible) { + HideCaret (); + Caret.Timer.Stop(); + } + if (Caret.gc != IntPtr.Zero) { + XFreeGC(DisplayHandle, Caret.gc); + Caret.gc = IntPtr.Zero; + } + Caret.Hwnd = IntPtr.Zero; + Caret.Visible = false; + Caret.On = false; + } + } + + internal override void DestroyCursor(IntPtr cursor) + { + lock (XlibLock) { + XFreeCursor(DisplayHandle, cursor); + } + } + + internal override void DestroyWindow(IntPtr handle) + { + Hwnd hwnd; + hwnd = Hwnd.ObjectFromHandle(handle); + + // The window should never ever be a zombie here, since we should + // wait until it's completely dead before returning from + // "destroying" calls, but just in case.... + if (hwnd == null || hwnd.zombie) { + DriverDebug ("window {0:X} already destroyed", handle.ToInt32()); + return; + } + + DriverDebug ("Destroying window {0}", XplatUI.Window(hwnd.client_window)); + + SendParentNotify (hwnd.Handle, Msg.WM_DESTROY, int.MaxValue, int.MaxValue); + + CleanupCachedWindows (hwnd); + + ArrayList windows = new ArrayList (); + + AccumulateDestroyedHandles (Widget.WidgetNativeWindow.WidgetFromHandle(hwnd.Handle), windows); + + + foreach (Hwnd h in windows) { + SendMessage (h.Handle, Msg.WM_DESTROY, IntPtr.Zero, IntPtr.Zero); + h.zombie = true; + } + + lock (XlibLock) { + if (hwnd.whole_window != IntPtr.Zero) { + DriverDebug ("XDestroyWindow (whole_window = {0:X})", hwnd.whole_window.ToInt32()); + Keyboard.DestroyICForWindow (hwnd.whole_window); + XDestroyWindow(DisplayHandle, hwnd.whole_window); + } + else if (hwnd.client_window != IntPtr.Zero) { + DriverDebug ("XDestroyWindow (client_window = {0:X})", hwnd.client_window.ToInt32()); + Keyboard.DestroyICForWindow (hwnd.client_window); + XDestroyWindow(DisplayHandle, hwnd.client_window); + } + + } + } + + internal override IntPtr DispatchMessage(ref MSG msg) + { + return NativeWindow.WndProc(msg.hwnd, msg.message, msg.wParam, msg.lParam); + } + + IntPtr GetReversibleScreenGC (Color backColor) + { + XGCValues gc_values; + IntPtr gc; + uint pixel; + + XColor xcolor = new XColor(); + xcolor.red = (ushort)(backColor.R * 257); + xcolor.green = (ushort)(backColor.G * 257); + xcolor.blue = (ushort)(backColor.B * 257); + XAllocColor(DisplayHandle, DefaultColormap, ref xcolor); + pixel = (uint)xcolor.pixel.ToInt32(); + + + gc_values = new XGCValues(); + + gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors; + gc_values.foreground = (IntPtr)pixel; + + gc = XCreateGC(DisplayHandle, RootWindow, new IntPtr ((int) (GCFunction.GCSubwindowMode | GCFunction.GCForeground)), ref gc_values); + XSetForeground(DisplayHandle, gc, (UIntPtr)pixel); + XSetFunction(DisplayHandle, gc, GXFunction.GXxor); + + return gc; + } + + IntPtr GetReversibleWidgetGC (Widget Widget, int line_width) + { + XGCValues gc_values; + IntPtr gc; + + gc_values = new XGCValues(); + + gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors; + gc_values.line_width = line_width; + gc_values.foreground = XBlackPixel(DisplayHandle, ScreenNo); + + // This logic will give us true rubber bands: (libsx, SANE_XOR) + //mask = foreground ^ background; + //XSetForeground(DisplayHandle, gc, 0xffffffff); + //XSetBackground(DisplayHandle, gc, background); + //XSetFunction(DisplayHandle, gc, GXxor); + //XSetPlaneMask(DisplayHandle, gc, mask); + + + gc = XCreateGC(DisplayHandle, Widget.Handle, new IntPtr ((int) (GCFunction.GCSubwindowMode | GCFunction.GCLineWidth | GCFunction.GCForeground)), ref gc_values); + uint foreground; + uint background; + + XColor xcolor = new XColor(); + + xcolor.red = (ushort)(Widget.ForeColor.R * 257); + xcolor.green = (ushort)(Widget.ForeColor.G * 257); + xcolor.blue = (ushort)(Widget.ForeColor.B * 257); + XAllocColor(DisplayHandle, DefaultColormap, ref xcolor); + foreground = (uint)xcolor.pixel.ToInt32(); + + xcolor.red = (ushort)(Widget.BackColor.R * 257); + xcolor.green = (ushort)(Widget.BackColor.G * 257); + xcolor.blue = (ushort)(Widget.BackColor.B * 257); + XAllocColor(DisplayHandle, DefaultColormap, ref xcolor); + background = (uint)xcolor.pixel.ToInt32(); + + uint mask = foreground ^ background; + + XSetForeground(DisplayHandle, gc, (UIntPtr)0xffffffff); + XSetBackground(DisplayHandle, gc, (UIntPtr)background); + XSetFunction(DisplayHandle, gc, GXFunction.GXxor); + XSetPlaneMask(DisplayHandle, gc, (IntPtr)mask); + + return gc; + } + + internal override void DrawReversibleLine(Point start, Point end, Color backColor) + { + if (backColor.GetBrightness() < 0.5) + backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B); + + IntPtr gc = GetReversibleScreenGC (backColor); + + XDrawLine (DisplayHandle, RootWindow, gc, start.X, start.Y, end.X, end.Y); + + XFreeGC(DisplayHandle, gc); + } + + internal override void DrawReversibleFrame (Rectangle rectangle, Color backColor, FrameStyle style) + { + if (backColor.GetBrightness() < 0.5) + backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B); + + IntPtr gc = GetReversibleScreenGC (backColor); + + if (rectangle.Width < 0) { + rectangle.X += rectangle.Width; + rectangle.Width = -rectangle.Width; + } + if (rectangle.Height < 0) { + rectangle.Y += rectangle.Height; + rectangle.Height = -rectangle.Height; + } + + int line_width = 1; + GCLineStyle line_style = GCLineStyle.LineSolid; + GCCapStyle cap_style = GCCapStyle.CapButt; + GCJoinStyle join_style = GCJoinStyle.JoinMiter; + + switch (style) { + case FrameStyle.Dashed: + line_style = GCLineStyle.LineOnOffDash; + break; + case FrameStyle.Thick: + line_width = 2; + break; + } + + XSetLineAttributes (DisplayHandle, gc, line_width, line_style, cap_style, join_style); + + XDrawRectangle(DisplayHandle, RootWindow, gc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height); + + XFreeGC(DisplayHandle, gc); + } + + internal override void FillReversibleRectangle (Rectangle rectangle, Color backColor) + { + if (backColor.GetBrightness() < 0.5) + backColor = Color.FromArgb(255 - backColor.R, 255 - backColor.G, 255 - backColor.B); + + IntPtr gc = GetReversibleScreenGC (backColor); + + if (rectangle.Width < 0) { + rectangle.X += rectangle.Width; + rectangle.Width = -rectangle.Width; + } + if (rectangle.Height < 0) { + rectangle.Y += rectangle.Height; + rectangle.Height = -rectangle.Height; + } + XFillRectangle(DisplayHandle, RootWindow, gc, rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height); + + XFreeGC(DisplayHandle, gc); + } + + internal override void DrawReversibleRectangle(IntPtr handle, Rectangle rect, int line_width) + { + IntPtr gc; + Widget Widget = Widget.FromHandle(handle); + + gc = GetReversibleWidgetGC (Widget, line_width); + + if ((rect.Width > 0) && (rect.Height > 0)) { + XDrawRectangle(DisplayHandle, Widget.Handle, gc, rect.Left, rect.Top, rect.Width, rect.Height); + } else { + if (rect.Width > 0) { + XDrawLine(DisplayHandle, Widget.Handle, gc, rect.X, rect.Y, rect.Right, rect.Y); + } else { + XDrawLine(DisplayHandle, Widget.Handle, gc, rect.X, rect.Y, rect.X, rect.Bottom); + } + } + XFreeGC(DisplayHandle, gc); + } + + internal override void DoEvents() + { + DebugHelper.Enter (); + + MSG msg = new MSG (); + XEventQueue queue; + + if (OverrideCursorHandle != IntPtr.Zero) { + OverrideCursorHandle = IntPtr.Zero; + } + + queue = ThreadQueue(Thread.CurrentThread); + + queue.DispatchIdle = false; + in_doevents = true; + + while (PeekMessage(queue, ref msg, IntPtr.Zero, 0, 0, (uint)PeekMessageFlags.PM_REMOVE)) { + Message m = Message.Create (msg.hwnd, (int)msg.message, msg.wParam, msg.lParam); + + if (Application.FilterMessage (ref m)) + continue; + + TranslateMessage (ref msg); + DispatchMessage (ref msg); + + string key = msg.hwnd + ":" + msg.message; + if (messageHold[key] != null) { + messageHold[key] = ((int)messageHold[key]) - 1; + DebugHelper.WriteLine ("Got " + msg + " for " + key); + } + } + + in_doevents = false; + queue.DispatchIdle = true; + + DebugHelper.Leave (); + } + + internal override void EnableWindow(IntPtr handle, bool Enable) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + if (hwnd != null) { + hwnd.Enabled = Enable; + } + } + + internal override void EndLoop(Thread thread) + { + // This is where we one day will shut down the loop for the thread + } + + internal override IntPtr GetActive() + { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + IntPtr active = IntPtr.Zero; + + XGetWindowProperty(DisplayHandle, RootWindow, _NET_ACTIVE_WINDOW, IntPtr.Zero, new IntPtr (1), false, (IntPtr)Atom.XA_WINDOW, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + if (((long)nitems > 0) && (prop != IntPtr.Zero)) { + active = (IntPtr)Marshal.ReadInt32(prop); + XFree(prop); + } else { + // The window manager does not support _NET_ACTIVE_WINDOW. Fall back to XGetInputFocus. + IntPtr revert_to = IntPtr.Zero; + XGetInputFocus(DisplayHandle, out active, out revert_to); + } + + if (active != IntPtr.Zero) { + Hwnd hwnd; + + hwnd = Hwnd.GetObjectFromWindow(active); + if (hwnd != null) { + active = hwnd.Handle; + } else { + active = IntPtr.Zero; + } + } + return active; + } + + internal override Region GetClipRegion(IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + if (hwnd != null) { + return hwnd.UserClip; + } + + return null; + } + + internal override void GetCursorInfo(IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y) + { + width = 20; + height = 20; + hotspot_x = 0; + hotspot_y = 0; + } + + internal override void GetDisplaySize(out Size size) + { + XWindowAttributes attributes=new XWindowAttributes(); + + lock (XlibLock) { + // FIXME - use _NET_WM messages instead? + XGetWindowAttributes(DisplayHandle, XRootWindow(DisplayHandle, 0), ref attributes); + } + + size = new Size(attributes.width, attributes.height); + } + + internal override SizeF GetAutoScaleSize(Font font) + { + Graphics g; + float width; + string magic_string = "The quick brown fox jumped over the lazy dog."; + double magic_number = 44.549996948242189; + + g = Graphics.FromHwnd(FosterParent); + + width = (float) (g.MeasureString (magic_string, font).Width / magic_number); + return new SizeF(width, font.Height); + } + + internal override IntPtr GetParent(IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + if (hwnd != null && hwnd.parent != null) { + return hwnd.parent.Handle; + } + return IntPtr.Zero; + } + + // This is a nop on win32 and x11 + internal override IntPtr GetPreviousWindow(IntPtr handle) + { + return handle; + } + + internal override void GetCursorPos(IntPtr handle, out int x, out int y) + { + IntPtr use_handle; + IntPtr root; + IntPtr child; + int root_x; + int root_y; + int win_x; + int win_y; + int keys_buttons; + + if (handle != IntPtr.Zero) { + use_handle = Hwnd.ObjectFromHandle(handle).client_window; + } else { + use_handle = RootWindow; + } + + lock (XlibLock) { + QueryPointer (DisplayHandle, use_handle, out root, out child, out root_x, out root_y, out win_x, out win_y, out keys_buttons); + } + + if (handle != IntPtr.Zero) { + x = win_x; + y = win_y; + } else { + x = root_x; + y = root_y; + } + } + + internal override IntPtr GetFocus() + { + return FocusWindow; + } + + + internal override bool GetFontMetrics(Graphics g, Font font, out int ascent, out int descent) + { + FontFamily ff = font.FontFamily; + ascent = ff.GetCellAscent (font.Style); + descent = ff.GetCellDescent (font.Style); + return true; + } + + internal override Point GetMenuOrigin(IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) { + return hwnd.MenuOrigin; + } + return Point.Empty; + } + + [MonoTODO("Implement filtering")] + internal override bool GetMessage(Object queue_id, ref MSG msg, IntPtr handle, int wFilterMin, int wFilterMax) + { + XEvent xevent; + bool client; + Hwnd hwnd; + + ProcessNextMessage: + + if (((XEventQueue)queue_id).Count > 0) { + xevent = (XEvent) ((XEventQueue)queue_id).Dequeue (); + } else { + UpdateMessageQueue ((XEventQueue)queue_id); + + if (((XEventQueue)queue_id).Count > 0) { + xevent = (XEvent) ((XEventQueue)queue_id).Dequeue (); + } else if (((XEventQueue)queue_id).Paint.Count > 0) { + xevent = ((XEventQueue)queue_id).Paint.Dequeue(); + } else { + msg.hwnd= IntPtr.Zero; + msg.message = Msg.WM_ENTERIDLE; + return true; + } + } + + hwnd = Hwnd.GetObjectFromWindow(xevent.AnyEvent.window); + +#if DriverDebugDestroy + if (hwnd != null) + if (hwnd.zombie) + Console.WriteLine ( "GetMessage zombie, got Event: " + xevent.ToString () + " for 0x{0:x}", hwnd.Handle.ToInt32()); + else + Console.WriteLine ( "GetMessage, got Event: " + xevent.ToString () + " for 0x{0:x}", hwnd.Handle.ToInt32()); +#endif + // Handle messages for windows that are already or are about to be destroyed. + + // we need a special block for this because unless we remove the hwnd from the paint + // queue it will always stay there (since we don't handle the expose), and we'll + // effectively loop infinitely trying to repaint a non-existant window. + if (hwnd != null && hwnd.zombie && xevent.type == XEventName.Expose) { + hwnd.expose_pending = hwnd.nc_expose_pending = false; + hwnd.Queue.Paint.Remove (hwnd); + goto ProcessNextMessage; + } + + // We need to make sure we only allow DestroyNotify events through for zombie + // hwnds, since much of the event handling code makes requests using the hwnd's + // client_window, and that'll result in BadWindow errors if there's some lag + // between the XDestroyWindow call and the DestroyNotify event. + if (hwnd == null || hwnd.zombie && xevent.AnyEvent.type != XEventName.ClientMessage) { + DriverDebug("GetMessage(): Got message {0} for non-existent or already destroyed window {1:X}", xevent.type, xevent.AnyEvent.window.ToInt32()); + goto ProcessNextMessage; + } + + + // If we get here, that means the window is no more but there are Client Messages + // to be processed, probably a Posted message (for instance, an WM_ACTIVATE message) + // We don't want anything else to run but the ClientMessage block, so reset all hwnd + // properties that might cause other processing to occur. + if (hwnd.zombie) { + hwnd.resizing_or_moving = false; + } + + if (hwnd.client_window == xevent.AnyEvent.window) { + client = true; + //Console.WriteLine("Client message {1}, sending to window {0:X}", msg.hwnd.ToInt32(), xevent.type); + } else { + client = false; + //Console.WriteLine("Non-Client message, sending to window {0:X}", msg.hwnd.ToInt32()); + } + + msg.hwnd = hwnd.Handle; + + // Windows sends WM_ENTERSIZEMOVE when a form resize/move operation starts and WM_EXITSIZEMOVE + // when it is done. The problem in X11 is that there is no concept of start-end of a moving/sizing. + // Configure events ("this window has resized/moved") are sent for each step of the resize. We send a + // WM_ENTERSIZEMOVE when we get the first Configure event. The problem is the WM_EXITSIZEMOVE. + // + // - There is no way for us to know which is the last Configure event. We can't traverse the events + // queue, because the next configure event might not be pending yet. + // - We can't get ButtonPress/Release events for the window decorations, because they are not part + // of the window(s) we manage. + // - We can't rely on the mouse state to change to "up" before the last Configure event. It doesn't. + // + // We are almost 100% guaranteed to get another event (e.g Expose or other), but we can't know for sure + // which, so we have here to check if the mouse buttons state is "up" and send the WM_EXITSIZEMOVE + // + if (hwnd.resizing_or_moving) { + int root_x, root_y, win_x, win_y, keys_buttons; + IntPtr root, child; + XQueryPointer (DisplayHandle, hwnd.Handle, out root, out child, out root_x, out root_y, + out win_x, out win_y, out keys_buttons); + if ((keys_buttons & (int)MouseKeyMasks.Button1Mask) == 0 && + (keys_buttons & (int)MouseKeyMasks.Button2Mask) == 0 && + (keys_buttons & (int)MouseKeyMasks.Button3Mask) == 0) { + hwnd.resizing_or_moving = false; + SendMessage (hwnd.Handle, Msg.WM_EXITSIZEMOVE, IntPtr.Zero, IntPtr.Zero); + } + } + + // + // If you add a new event to this switch make sure to add it in + // UpdateMessage also unless it is not coming through the X event system. + // + switch(xevent.type) { + case XEventName.KeyPress: { + Keyboard.KeyEvent (FocusWindow, xevent, ref msg); + + // F1 key special case - WM_HELP sending + if (msg.wParam == (IntPtr)VirtualKeys.VK_F1 || msg.wParam == (IntPtr)VirtualKeys.VK_HELP) { + // Send wM_HELP and then return it as a keypress message in + // case it needs to be preproccessed. + HELPINFO helpInfo = new HELPINFO (); + GetCursorPos (IntPtr.Zero, out helpInfo.MousePos.x, out helpInfo.MousePos.y); + IntPtr helpInfoPtr = Marshal.AllocHGlobal (Marshal.SizeOf (helpInfo)); + Marshal.StructureToPtr (helpInfo, helpInfoPtr, true); + NativeWindow.WndProc (FocusWindow, Msg.WM_HELP, IntPtr.Zero, helpInfoPtr); + Marshal.FreeHGlobal (helpInfoPtr); + } + break; + } + + case XEventName.KeyRelease: { + Keyboard.KeyEvent (FocusWindow, xevent, ref msg); + break; + } + + case XEventName.ButtonPress: { + switch(xevent.ButtonEvent.button) { + case 1: { + MouseState |= MouseButtons.Left; + if (client) { + msg.message = Msg.WM_LBUTTONDOWN; + msg.wParam = GetMousewParam (0); + } else { + msg.message = Msg.WM_NCLBUTTONDOWN; + msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y); + MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + break; + } + + case 2: { + MouseState |= MouseButtons.Middle; + if (client) { + msg.message = Msg.WM_MBUTTONDOWN; + msg.wParam = GetMousewParam (0); + } else { + msg.message = Msg.WM_NCMBUTTONDOWN; + msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y); + MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + break; + } + + case 3: { + MouseState |= MouseButtons.Right; + if (client) { + msg.message = Msg.WM_RBUTTONDOWN; + msg.wParam = GetMousewParam (0); + } else { + msg.message = Msg.WM_NCRBUTTONDOWN; + msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y); + MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + break; + } + + case 4: { + msg.hwnd = FocusWindow; + msg.message=Msg.WM_MOUSEWHEEL; + msg.wParam=GetMousewParam(120); + break; + } + + case 5: { + msg.hwnd = FocusWindow; + msg.message=Msg.WM_MOUSEWHEEL; + msg.wParam=GetMousewParam(-120); + break; + } + + } + + msg.lParam=(IntPtr) (xevent.ButtonEvent.y << 16 | xevent.ButtonEvent.x); + mouse_position.X = xevent.ButtonEvent.x; + mouse_position.Y = xevent.ButtonEvent.y; + + if (!hwnd.Enabled) { + IntPtr dummy; + + msg.hwnd = hwnd.EnabledHwnd; + XTranslateCoordinates(DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, xevent.ButtonEvent.x, xevent.ButtonEvent.y, out xevent.ButtonEvent.x, out xevent.ButtonEvent.y, out dummy); + msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X); + } + + if (Grab.Hwnd != IntPtr.Zero) { + msg.hwnd = Grab.Hwnd; + } + + if (ClickPending.Pending && ((((long)xevent.ButtonEvent.time - ClickPending.Time) < DoubleClickInterval) && (msg.wParam == ClickPending.wParam) && (msg.lParam == ClickPending.lParam) && (msg.message == ClickPending.Message))) { + // Looks like a genuine double click, clicked twice on the same spot with the same keys + switch(xevent.ButtonEvent.button) { + case 1: { + msg.message = client ? Msg.WM_LBUTTONDBLCLK : Msg.WM_NCLBUTTONDBLCLK; + break; + } + + case 2: { + msg.message = client ? Msg.WM_MBUTTONDBLCLK : Msg.WM_NCMBUTTONDBLCLK; + break; + } + + case 3: { + msg.message = client ? Msg.WM_RBUTTONDBLCLK : Msg.WM_NCRBUTTONDBLCLK; + break; + } + } + ClickPending.Pending = false; + } else { + ClickPending.Pending = true; + ClickPending.Hwnd = msg.hwnd; + ClickPending.Message = msg.message; + ClickPending.wParam = msg.wParam; + ClickPending.lParam = msg.lParam; + ClickPending.Time = (long)xevent.ButtonEvent.time; + } + + if (msg.message == Msg.WM_LBUTTONDOWN || msg.message == Msg.WM_MBUTTONDOWN || msg.message == Msg.WM_RBUTTONDOWN) { + SendParentNotify(msg.hwnd, msg.message, mouse_position.X, mouse_position.Y); + } + + break; + } + + case XEventName.ButtonRelease: { + switch(xevent.ButtonEvent.button) { + case 1: { + if (client) { + msg.message = Msg.WM_LBUTTONUP; + } else { + msg.message = Msg.WM_NCLBUTTONUP; + msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y); + MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + MouseState &= ~MouseButtons.Left; + msg.wParam = GetMousewParam (0); + break; + } + + case 2: { + if (client) { + msg.message = Msg.WM_MBUTTONUP; + } else { + msg.message = Msg.WM_NCMBUTTONUP; + msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y); + MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + MouseState &= ~MouseButtons.Middle; + msg.wParam = GetMousewParam (0); + break; + } + + case 3: { + if (client) { + msg.message = Msg.WM_RBUTTONUP; + } else { + msg.message = Msg.WM_NCRBUTTONUP; + msg.wParam = (IntPtr) NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y); + MenuToScreen (xevent.AnyEvent.window, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + MouseState &= ~MouseButtons.Right; + msg.wParam = GetMousewParam (0); + break; + } + + case 4: { + goto ProcessNextMessage; + } + + case 5: { + goto ProcessNextMessage; + } + } + + if (!hwnd.Enabled) { + IntPtr dummy; + + msg.hwnd = hwnd.EnabledHwnd; + XTranslateCoordinates(DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, xevent.ButtonEvent.x, xevent.ButtonEvent.y, out xevent.ButtonEvent.x, out xevent.ButtonEvent.y, out dummy); + msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X); + } + + if (Grab.Hwnd != IntPtr.Zero) { + msg.hwnd = Grab.Hwnd; + } + + msg.lParam=(IntPtr) (xevent.ButtonEvent.y << 16 | xevent.ButtonEvent.x); + mouse_position.X = xevent.ButtonEvent.x; + mouse_position.Y = xevent.ButtonEvent.y; + + // Win32 splurts MouseMove events all over the place, regardless of whether the mouse is actually moving or + // not, especially after mousedown and mouseup. To support apps relying on mousemove events between and after + // mouse clicks to repaint or whatever, we generate a mousemove event here. *sigh* + if (msg.message == Msg.WM_LBUTTONUP || msg.message == Msg.WM_MBUTTONUP || msg.message == Msg.WM_RBUTTONUP) { + XEvent motionEvent = new XEvent (); + motionEvent.type = XEventName.MotionNotify; + motionEvent.MotionEvent.display = DisplayHandle; + motionEvent.MotionEvent.window = xevent.ButtonEvent.window; + motionEvent.MotionEvent.x = xevent.ButtonEvent.x; + motionEvent.MotionEvent.y = xevent.ButtonEvent.y; + hwnd.Queue.EnqueueLocked (motionEvent); + } + break; + } + + case XEventName.MotionNotify: { + if (client) { + DriverDebug("GetMessage(): Window {0:X} MotionNotify x={1} y={2}", + client ? hwnd.client_window.ToInt32() : hwnd.whole_window.ToInt32(), + xevent.MotionEvent.x, xevent.MotionEvent.y); + + if (Grab.Hwnd != IntPtr.Zero) { + msg.hwnd = Grab.Hwnd; + } else { + if (hwnd.Enabled) { + NativeWindow.WndProc(msg.hwnd, Msg.WM_SETCURSOR, msg.hwnd, (IntPtr)HitTest.HTCLIENT); + } + } + + if (xevent.MotionEvent.is_hint != 0) + { + IntPtr root, child; + int mask; + XQueryPointer (DisplayHandle, xevent.AnyEvent.window, + out root, out child, + out xevent.MotionEvent.x_root, + out xevent.MotionEvent.y_root, + out xevent.MotionEvent.x, + out xevent.MotionEvent.y, out mask); + } + + msg.message = Msg.WM_MOUSEMOVE; + msg.wParam = GetMousewParam(0); + msg.lParam = (IntPtr) (xevent.MotionEvent.y << 16 | xevent.MotionEvent.x & 0xFFFF); + + if (!hwnd.Enabled) { + IntPtr dummy; + + msg.hwnd = hwnd.EnabledHwnd; + XTranslateCoordinates(DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, xevent.MotionEvent.x, xevent.MotionEvent.y, out xevent.MotionEvent.x, out xevent.MotionEvent.y, out dummy); + msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X); + } + + mouse_position.X = xevent.MotionEvent.x; + mouse_position.Y = xevent.MotionEvent.y; + + if ((HoverState.Timer.Enabled) && + (((mouse_position.X + HoverState.Size.Width) < HoverState.X) || + ((mouse_position.X - HoverState.Size.Width) > HoverState.X) || + ((mouse_position.Y + HoverState.Size.Height) < HoverState.Y) || + ((mouse_position.Y - HoverState.Size.Height) > HoverState.Y))) { + HoverState.Timer.Stop(); + HoverState.Timer.Start(); + HoverState.X = mouse_position.X; + HoverState.Y = mouse_position.Y; + } + + break; + } else { + HitTest ht; + IntPtr dummy; + + DriverDebug("GetMessage(): non-client area {0:X} MotionNotify x={1} y={2}", + client ? hwnd.client_window.ToInt32() : hwnd.whole_window.ToInt32(), + xevent.MotionEvent.x, xevent.MotionEvent.y); + msg.message = Msg.WM_NCMOUSEMOVE; + + if (!hwnd.Enabled) { + msg.hwnd = hwnd.EnabledHwnd; + XTranslateCoordinates(DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle(msg.hwnd).ClientWindow, xevent.MotionEvent.x, xevent.MotionEvent.y, out xevent.MotionEvent.x, out xevent.MotionEvent.y, out dummy); + msg.lParam = (IntPtr)(mouse_position.Y << 16 | mouse_position.X); + } + + ht = NCHitTest (hwnd, xevent.MotionEvent.x, xevent.MotionEvent.y); + NativeWindow.WndProc(hwnd.client_window, Msg.WM_SETCURSOR, msg.hwnd, (IntPtr)ht); + + mouse_position.X = xevent.MotionEvent.x; + mouse_position.Y = xevent.MotionEvent.y; + } + + break; + } + + case XEventName.EnterNotify: { + if (!hwnd.Enabled) { + goto ProcessNextMessage; + } + if (xevent.CrossingEvent.mode == NotifyMode.NotifyGrab || xevent.AnyEvent.window != hwnd.client_window) { + goto ProcessNextMessage; + } + if (xevent.CrossingEvent.mode == NotifyMode.NotifyUngrab) { // Pseudo motion caused by grabbing + if (LastPointerWindow == xevent.AnyEvent.window) + goto ProcessNextMessage; + + if (LastPointerWindow != IntPtr.Zero) { + Point enter_loc = new Point (xevent.ButtonEvent.x, xevent.ButtonEvent.y); + + // We need this due to EnterNotify being fired on all the parent Widgets + // of the Widget being grabbed, and obviously in that scenario we are not + // actuallty entering them + Widget ctrl = Widget.FromHandle (hwnd.client_window); + foreach (Widget child_Widget in ctrl.Widgets.GetAllWidgets ()) + if (child_Widget.Bounds.Contains (enter_loc)) + goto ProcessNextMessage; + + // A MouseLeave/LeaveNotify event is sent to the previous window + // until the mouse is ungrabbed, not when actually leaving its bounds + int x = xevent.CrossingEvent.x_root; + int y = xevent.CrossingEvent.y_root; + ScreenToClient (LastPointerWindow, ref x, ref y); + + XEvent leaveEvent = new XEvent (); + leaveEvent.type = XEventName.LeaveNotify; + leaveEvent.CrossingEvent.display = DisplayHandle; + leaveEvent.CrossingEvent.window = LastPointerWindow; + leaveEvent.CrossingEvent.x = x; + leaveEvent.CrossingEvent.y = y; + leaveEvent.CrossingEvent.mode = NotifyMode.NotifyNormal; + Hwnd last_pointer_hwnd = Hwnd.ObjectFromHandle (LastPointerWindow); + last_pointer_hwnd.Queue.EnqueueLocked (leaveEvent); + } + } + + LastPointerWindow = xevent.AnyEvent.window; + + msg.message = Msg.WM_MOUSE_ENTER; + HoverState.X = xevent.CrossingEvent.x; + HoverState.Y = xevent.CrossingEvent.y; + HoverState.Timer.Enabled = true; + HoverState.Window = xevent.CrossingEvent.window; + + // Win32 sends a WM_MOUSEMOVE after mouse enter + XEvent motionEvent = new XEvent (); + motionEvent.type = XEventName.MotionNotify; + motionEvent.MotionEvent.display = DisplayHandle; + motionEvent.MotionEvent.window = xevent.ButtonEvent.window; + motionEvent.MotionEvent.x = xevent.ButtonEvent.x; + motionEvent.MotionEvent.y = xevent.ButtonEvent.y; + hwnd.Queue.EnqueueLocked (motionEvent); + break; + } + + case XEventName.LeaveNotify: { + if (xevent.CrossingEvent.mode == NotifyMode.NotifyUngrab) { + WindowUngrabbed (hwnd.Handle); + goto ProcessNextMessage; + } + if (!hwnd.Enabled) { + goto ProcessNextMessage; + } + if ((xevent.CrossingEvent.mode != NotifyMode.NotifyNormal) || (xevent.CrossingEvent.window != hwnd.client_window)) { + goto ProcessNextMessage; + } + // If a grab is taking place, ignore it - we handle it in EnterNotify + if (Grab.Hwnd != IntPtr.Zero) + goto ProcessNextMessage; + + // Reset the cursor explicitly on X11. + // X11 remembers the last set cursor for the window and in cases where + // the Widget won't get a WM_SETCURSOR X11 will restore the last + // known cursor, which we don't want. + // + SetCursor (hwnd.client_window, IntPtr.Zero); + + msg.message=Msg.WM_MOUSELEAVE; + HoverState.Timer.Enabled = false; + HoverState.Window = IntPtr.Zero; + break; + } + + #if later + case XEventName.CreateNotify: { + if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { + msg.message = WM_CREATE; + // Set up CreateStruct + } else { + goto ProcessNextMessage; + } + break; + } + #endif + + + case XEventName.ReparentNotify: { + if (hwnd.parent == null) { // Toplevel + if ((xevent.ReparentEvent.parent != IntPtr.Zero) && (xevent.ReparentEvent.window == hwnd.whole_window)) { + hwnd.Reparented = true; + + // The location given by the event is not reliable between different wm's, + // so use an alternative way of getting it. + Point location = GetTopLevelWindowLocation (hwnd); + hwnd.X = location.X; + hwnd.Y = location.Y; + + if (hwnd.opacity != 0xffffffff) { + IntPtr opacity; + + opacity = (IntPtr)(Int32)hwnd.opacity; + XChangeProperty(DisplayHandle, XGetParent(hwnd.whole_window), _NET_WM_WINDOW_OPACITY, (IntPtr)Atom.XA_CARDINAL, 32, PropertyMode.Replace, ref opacity, 1); + } + SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, msg.wParam, msg.lParam); + goto ProcessNextMessage; + } else { + hwnd.Reparented = false; + goto ProcessNextMessage; + } + } + goto ProcessNextMessage; + } + + case XEventName.ConfigureNotify: { + if (!client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { // Ignore events for children (SubstructureNotify) and client areas + DriverDebug("GetMessage(): Window {0:X} ConfigureNotify x={1} y={2} width={3} height={4}", + hwnd.client_window.ToInt32(), xevent.ConfigureEvent.x, + xevent.ConfigureEvent.y, xevent.ConfigureEvent.width, xevent.ConfigureEvent.height); + + lock (hwnd.configure_lock) { + Form form = Widget.FromHandle (hwnd.client_window) as Form; + if (form != null && !hwnd.resizing_or_moving) { + if (hwnd.x != form.Bounds.X || hwnd.y != form.Bounds.Y) { + SendMessage (form.Handle, Msg.WM_SYSCOMMAND, (IntPtr)SystemCommands.SC_MOVE, IntPtr.Zero); + hwnd.resizing_or_moving = true; + } else if (hwnd.width != form.Bounds.Width || hwnd.height != form.Bounds.Height) { + SendMessage (form.Handle, Msg.WM_SYSCOMMAND, (IntPtr)SystemCommands.SC_SIZE, IntPtr.Zero); + hwnd.resizing_or_moving = true; + } + if (hwnd.resizing_or_moving) + SendMessage (form.Handle, Msg.WM_ENTERSIZEMOVE, IntPtr.Zero, IntPtr.Zero); + } + + SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + hwnd.configure_pending = false; + + // We need to adjust our client window to track the resize of whole_window + if (hwnd.whole_window != hwnd.client_window) + PerformNCCalc(hwnd); + } + } + goto ProcessNextMessage; + } + + case XEventName.FocusIn: { + // We received focus. We use X11 focus only to know if the app window does or does not have focus + // We do not track the actual focussed window via it. Instead, this is done via FocusWindow internally + // Receiving focus means we've gotten activated and therefore we need to let the actual FocusWindow know + // about it having focus again + if (xevent.FocusChangeEvent.detail != NotifyDetail.NotifyNonlinear) { + goto ProcessNextMessage; + } + + + if (FocusWindow == IntPtr.Zero) { + Widget c = Widget.FromHandle (hwnd.client_window); + + if (c == null) + goto ProcessNextMessage; + Form form = c.FindForm (); + if (form == null) + goto ProcessNextMessage; + + if (ActiveWindow != form.Handle) { + ActiveWindow = form.Handle; + SendMessage (ActiveWindow, Msg.WM_ACTIVATE, (IntPtr) WindowActiveFlags.WA_ACTIVE, IntPtr.Zero); + } + goto ProcessNextMessage; + } + Keyboard.FocusIn (FocusWindow); + SendMessage(FocusWindow, Msg.WM_SETFOCUS, IntPtr.Zero, IntPtr.Zero); + goto ProcessNextMessage; + } + + case XEventName.FocusOut: { + // Se the comment for our FocusIn handler + if (xevent.FocusChangeEvent.detail != NotifyDetail.NotifyNonlinear) { + goto ProcessNextMessage; + } + + while (Keyboard.ResetKeyState(FocusWindow, ref msg)) { + SendMessage(FocusWindow, msg.message, msg.wParam, msg.lParam); + } + + Keyboard.FocusOut(hwnd.client_window); + SendMessage(FocusWindow, Msg.WM_KILLFOCUS, IntPtr.Zero, IntPtr.Zero); + goto ProcessNextMessage; + } + + // We are already firing WM_SHOWWINDOW messages in the proper places, but I'm leaving this code + // in case we break a scenario not taken into account in the tests + case XEventName.MapNotify: { + /*if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { // Ignore events for children (SubstructureNotify) and client areas + hwnd.mapped = true; + msg.message = Msg.WM_SHOWWINDOW; + msg.wParam = (IntPtr) 1; + // XXX we're missing the lParam.. + break; + }*/ + goto ProcessNextMessage; + } + + case XEventName.UnmapNotify: { + /*if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { // Ignore events for children (SubstructureNotify) and client areas + hwnd.mapped = false; + msg.message = Msg.WM_SHOWWINDOW; + msg.wParam = (IntPtr) 0; + // XXX we're missing the lParam.. + break; + }*/ + goto ProcessNextMessage; + } + + case XEventName.Expose: { + if (!hwnd.Mapped) { + if (client) { + hwnd.expose_pending = false; + } else { + hwnd.nc_expose_pending = false; + } + goto ProcessNextMessage; + } + + if (client) { + if (!hwnd.expose_pending) { + goto ProcessNextMessage; + } + } else { + if (!hwnd.nc_expose_pending) { + goto ProcessNextMessage; + } + + switch (hwnd.border_style) { + case FormBorderStyle.Fixed3D: { + Graphics g; + + g = Graphics.FromHwnd(hwnd.whole_window); + if (hwnd.border_static) + WidgetPaint.DrawBorder3D(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Border3DStyle.SunkenOuter); + else + WidgetPaint.DrawBorder3D(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Border3DStyle.Sunken); + g.Dispose(); + break; + } + + case FormBorderStyle.FixedSingle: { + Graphics g; + + g = Graphics.FromHwnd(hwnd.whole_window); + WidgetPaint.DrawBorder(g, new Rectangle(0, 0, hwnd.Width, hwnd.Height), Color.Black, ButtonBorderStyle.Solid); + g.Dispose(); + break; + } + } + DriverDebug("GetMessage(): Window {0:X} Exposed non-client area {1},{2} {3}x{4}", + hwnd.client_window.ToInt32(), xevent.ExposeEvent.x, xevent.ExposeEvent.y, + xevent.ExposeEvent.width, xevent.ExposeEvent.height); + + Rectangle rect = new Rectangle (xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height); + Region region = new Region (rect); + IntPtr hrgn = region.GetHrgn (null); // Graphics object isn't needed + msg.message = Msg.WM_NCPAINT; + msg.wParam = hrgn == IntPtr.Zero ? (IntPtr)1 : hrgn; + msg.refobject = region; + break; + } + DriverDebug("GetMessage(): Window {0:X} Exposed area {1},{2} {3}x{4}", + hwnd.client_window.ToInt32(), xevent.ExposeEvent.x, xevent.ExposeEvent.y, + xevent.ExposeEvent.width, xevent.ExposeEvent.height); + if (Caret.Visible == true) { + Caret.Paused = true; + HideCaret(); + } + + if (Caret.Visible == true) { + ShowCaret(); + Caret.Paused = false; + } + msg.message = Msg.WM_PAINT; + break; + } + + case XEventName.DestroyNotify: { + + // This is a bit tricky, we don't receive our own DestroyNotify, we only get those for our children + hwnd = Hwnd.ObjectFromHandle(xevent.DestroyWindowEvent.window); + + // We may get multiple for the same window, act only one the first (when Hwnd still knows about it) + if ((hwnd != null) && (hwnd.client_window == xevent.DestroyWindowEvent.window)) { + CleanupCachedWindows (hwnd); + + DriverDebug("Received X11 Destroy Notification for {0}", XplatUI.Window(hwnd.client_window)); + + msg.hwnd = hwnd.client_window; + msg.message=Msg.WM_DESTROY; + hwnd.Dispose(); + } else { + goto ProcessNextMessage; + } + + break; + } + + case XEventName.ClientMessage: { + if (Dnd.HandleClientMessage (ref xevent)) { + goto ProcessNextMessage; + } + + if (xevent.ClientMessageEvent.message_type == AsyncAtom) { + XplatUIDriverSupport.ExecuteClientMessage((GCHandle)xevent.ClientMessageEvent.ptr1); + goto ProcessNextMessage; + } + + if (xevent.ClientMessageEvent.message_type == HoverState.Atom) { + msg.message = Msg.WM_MOUSEHOVER; + msg.wParam = GetMousewParam(0); + msg.lParam = (IntPtr) (xevent.ClientMessageEvent.ptr1); + return true; + } + + if (xevent.ClientMessageEvent.message_type == (IntPtr)PostAtom) { + DebugHelper.Indent (); + DebugHelper.WriteLine (String.Format ("Posted message:" + (Msg) xevent.ClientMessageEvent.ptr2.ToInt32 () + " for 0x{0:x}", xevent.ClientMessageEvent.ptr1.ToInt32 ())); + DebugHelper.Unindent (); + msg.hwnd = xevent.ClientMessageEvent.ptr1; + msg.message = (Msg) xevent.ClientMessageEvent.ptr2.ToInt32 (); + msg.wParam = xevent.ClientMessageEvent.ptr3; + msg.lParam = xevent.ClientMessageEvent.ptr4; + if (msg.message == (Msg)Msg.WM_QUIT) + return false; + else + return true; + } + + if (xevent.ClientMessageEvent.message_type == _XEMBED) { +#if DriverDebugXEmbed + Console.WriteLine("GOT EMBED MESSAGE {0:X}, detail {1:X}", xevent.ClientMessageEvent.ptr2.ToInt32(), xevent.ClientMessageEvent.ptr3.ToInt32()); +#endif + + if (xevent.ClientMessageEvent.ptr2.ToInt32() == (int)XEmbedMessage.EmbeddedNotify) { + XSizeHints hints = new XSizeHints(); + IntPtr dummy; + + XGetWMNormalHints(DisplayHandle, hwnd.whole_window, ref hints, out dummy); + + hwnd.width = hints.max_width; + hwnd.height = hints.max_height; + hwnd.ClientRect = Rectangle.Empty; + SendMessage(msg.hwnd, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + } + } + + if (xevent.ClientMessageEvent.message_type == WM_PROTOCOLS) { + if (xevent.ClientMessageEvent.ptr1 == WM_DELETE_WINDOW) { + SendMessage (msg.hwnd, Msg.WM_SYSCOMMAND, (IntPtr)SystemCommands.SC_CLOSE, IntPtr.Zero); + msg.message = Msg.WM_CLOSE; + return true; + } + + // We should not get this, but I'll leave the code in case we need it in the future + if (xevent.ClientMessageEvent.ptr1 == WM_TAKE_FOCUS) { + goto ProcessNextMessage; + } + } + goto ProcessNextMessage; + } + + default: { + goto ProcessNextMessage; + } + } + + return true; + } + + HitTest NCHitTest (Hwnd hwnd, int x, int y) + { + // The hit test is sent in screen coordinates + IntPtr dummy; + int screen_x, screen_y; + XTranslateCoordinates (DisplayHandle, hwnd.WholeWindow, RootWindow, x, y, out screen_x, out screen_y, out dummy); + return (HitTest) NativeWindow.WndProc (hwnd.client_window, Msg.WM_NCHITTEST, IntPtr.Zero, + (IntPtr) (screen_y << 16 | screen_x & 0xFFFF)); + } + + // Our very basic implementation of MoveResize - we can extend it later + // *if* needed + internal override void BeginMoveResize (IntPtr handle) + { + // We *need* to ungrab the pointer in the current display + XplatUI.UngrabWindow (Grab.Hwnd); + + int x_root, y_root; + GetCursorPos (IntPtr.Zero, out x_root, out y_root); + + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + SendNetWMMessage (hwnd.whole_window, _NET_WM_MOVERESIZE, (IntPtr) x_root, (IntPtr) y_root, + (IntPtr) NetWmMoveResize._NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT, + (IntPtr) 1); // left button + } + + internal override bool GetText(IntPtr handle, out string text) + { + + lock (XlibLock) { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + + XGetWindowProperty(DisplayHandle, handle, + _NET_WM_NAME, IntPtr.Zero, new IntPtr (1), false, + UTF8_STRING, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + + if ((long)nitems > 0 && prop != IntPtr.Zero) { + text = Marshal.PtrToStringUni (prop, (int)nitems); + XFree (prop); + return true; + } + else { + // fallback on the non-_NET property + IntPtr textptr; + + textptr = IntPtr.Zero; + + XFetchName(DisplayHandle, Hwnd.ObjectFromHandle(handle).whole_window, ref textptr); + if (textptr != IntPtr.Zero) { + text = Marshal.PtrToStringAnsi(textptr); + XFree(textptr); + return true; + } else { + text = ""; + return false; + } + } + } + } + + internal override void GetWindowPos(IntPtr handle, bool is_toplevel, out int x, out int y, out int width, out int height, out int client_width, out int client_height) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd != null) { + x = hwnd.x; + y = hwnd.y; + width = hwnd.width; + height = hwnd.height; + + PerformNCCalc(hwnd); + + client_width = hwnd.ClientRect.Width; + client_height = hwnd.ClientRect.Height; + + return; + } + + // Should we throw an exception or fail silently? + // throw new ArgumentException("Called with an invalid window handle", "handle"); + + x = 0; + y = 0; + width = 0; + height = 0; + client_width = 0; + client_height = 0; + } + + internal override FormWindowState GetWindowState(IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd.cached_window_state == (FormWindowState)(-1)) + hwnd.cached_window_state = UpdateWindowState (handle); + + return hwnd.cached_window_state; + } + + FormWindowState UpdateWindowState (IntPtr handle) { + IntPtr actual_atom; + int actual_format; + IntPtr nitems; + IntPtr bytes_after; + IntPtr prop = IntPtr.Zero; + IntPtr atom; + int maximized; + bool minimized; + XWindowAttributes attributes; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + maximized = 0; + minimized = false; + XGetWindowProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE, IntPtr.Zero, new IntPtr (256), false, (IntPtr)Atom.XA_ATOM, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + if (((long)nitems > 0) && (prop != IntPtr.Zero)) { + for (int i = 0; i < (long)nitems; i++) { + atom = (IntPtr)Marshal.ReadInt32(prop, i * 4); + if ((atom == _NET_WM_STATE_MAXIMIZED_HORZ) || (atom == _NET_WM_STATE_MAXIMIZED_VERT)) { + maximized++; + } else if (atom == _NET_WM_STATE_HIDDEN) { + minimized = true; + } + } + XFree(prop); + } + + if (minimized) { + return FormWindowState.Minimized; + } else if (maximized == 2) { + return FormWindowState.Maximized; + } + + attributes = new XWindowAttributes(); + XGetWindowAttributes(DisplayHandle, hwnd.client_window, ref attributes); + if (attributes.map_state == MapState.IsUnmapped) { + return (FormWindowState)(-1); + } + + + return FormWindowState.Normal; + } + + internal override void GrabInfo(out IntPtr handle, out bool GrabConfined, out Rectangle GrabArea) + { + handle = Grab.Hwnd; + GrabConfined = Grab.Confined; + GrabArea = Grab.Area; + } + + internal override void GrabWindow(IntPtr handle, IntPtr confine_to_handle) + { + Hwnd hwnd; + IntPtr confine_to_window; + + confine_to_window = IntPtr.Zero; + + if (confine_to_handle != IntPtr.Zero) { + XWindowAttributes attributes = new XWindowAttributes(); + + hwnd = Hwnd.ObjectFromHandle(confine_to_handle); + + lock (XlibLock) { + XGetWindowAttributes(DisplayHandle, hwnd.client_window, ref attributes); + } + Grab.Area.X = attributes.x; + Grab.Area.Y = attributes.y; + Grab.Area.Width = attributes.width; + Grab.Area.Height = attributes.height; + Grab.Confined = true; + confine_to_window = hwnd.client_window; + } + + Grab.Hwnd = handle; + + hwnd = Hwnd.ObjectFromHandle(handle); + + lock (XlibLock) { + XGrabPointer(DisplayHandle, hwnd.client_window, false, + EventMask.ButtonPressMask | EventMask.ButtonMotionMask | + EventMask.ButtonReleaseMask | EventMask.PointerMotionMask | + EventMask.PointerMotionHintMask | EventMask.LeaveWindowMask, + GrabMode.GrabModeAsync, GrabMode.GrabModeAsync, confine_to_window, IntPtr.Zero, IntPtr.Zero); + } + } + + internal override void UngrabWindow(IntPtr hwnd) + { + lock (XlibLock) { + XUngrabPointer(DisplayHandle, IntPtr.Zero); + XFlush(DisplayHandle); + } + WindowUngrabbed (hwnd); + } + + void WindowUngrabbed (IntPtr hwnd) { + bool was_grabbed = Grab.Hwnd != IntPtr.Zero; + + Grab.Hwnd = IntPtr.Zero; + Grab.Confined = false; + + if (was_grabbed) { + // lparam should be the handle to the window gaining the mouse capture, + // but X doesn't seem to give us that information. + // Also only generate WM_CAPTURECHANGED if the window actually was grabbed. + // X will send a NotifyUngrab, but since it comes late sometimes we're + // calling WindowUngrabbed directly from UngrabWindow in order to send + // this WM right away. + SendMessage (hwnd, Msg.WM_CAPTURECHANGED, IntPtr.Zero, IntPtr.Zero); + } + } + + internal override void HandleException(Exception e) + { + StackTrace st = new StackTrace(e, true); + Console.WriteLine("Exception '{0}'", e.Message+st.ToString()); + Console.WriteLine("{0}{1}", e.Message, st.ToString()); + } + + internal override void Invalidate(IntPtr handle, Rectangle rc, bool clear) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (clear) { + AddExpose (hwnd, true, hwnd.X, hwnd.Y, hwnd.Width, hwnd.Height); + } else { + AddExpose (hwnd, true, rc.X, rc.Y, rc.Width, rc.Height); + } + } + + internal override void InvalidateNC (IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + AddExpose (hwnd, hwnd.WholeWindow == hwnd.ClientWindow, 0, 0, hwnd.Width, hwnd.Height); + } + + internal override bool IsEnabled(IntPtr handle) + { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + return (hwnd != null && hwnd.Enabled); + } + + internal override bool IsVisible(IntPtr handle) + { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + return (hwnd != null && hwnd.visible); + } + + internal override void KillTimer(Timer timer) + { + XEventQueue queue = (XEventQueue) MessageQueues [timer.thread]; + + if (queue == null) { + // This isn't really an error, MS doesn't start the timer if + // it has no assosciated queue. In this case, remove the timer + // from the list of unattached timers (if it was enabled). + lock (unattached_timer_list) { + if (unattached_timer_list.Contains (timer)) + unattached_timer_list.Remove (timer); + } + return; + } + queue.timer_list.Remove (timer); + } + + internal override void MenuToScreen(IntPtr handle, ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + IntPtr child; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + lock (XlibLock) { + XTranslateCoordinates(DisplayHandle, hwnd.whole_window, RootWindow, x, y, out dest_x_return, out dest_y_return, out child); + } + + x = dest_x_return; + y = dest_y_return; + } + + internal override void OverrideCursor(IntPtr cursor) + { + if (Grab.Hwnd != IntPtr.Zero) { + XChangeActivePointerGrab (DisplayHandle, + EventMask.ButtonMotionMask | + EventMask.PointerMotionMask | + EventMask.PointerMotionHintMask | + EventMask.ButtonPressMask | + EventMask.ButtonReleaseMask, + cursor, IntPtr.Zero); + return; + } + + OverrideCursorHandle = cursor; + } + + internal override PaintEventArgs PaintEventStart(ref Message msg, IntPtr handle, bool client) + { + PaintEventArgs paint_event; + Hwnd hwnd; + Hwnd paint_hwnd; + + // + // handle (and paint_hwnd) refers to the window that is should be painted. + // msg.HWnd (and hwnd) refers to the window that got the paint message. + // + + hwnd = Hwnd.ObjectFromHandle(msg.HWnd); + if (msg.HWnd == handle) { + paint_hwnd = hwnd; + } else { + paint_hwnd = Hwnd.ObjectFromHandle (handle); + } + + if (Caret.Visible == true) { + Caret.Paused = true; + HideCaret(); + } + + Graphics dc; + + if (client) { + dc = Graphics.FromHwnd (paint_hwnd.client_window); + + Region clip_region = new Region (); + clip_region.MakeEmpty(); + + foreach (Rectangle r in hwnd.ClipRectangles) { + /* Expand the region slightly. + * See bug 464464. + */ + Rectangle r2 = Rectangle.FromLTRB (r.Left, r.Top, r.Right, r.Bottom + 1); + clip_region.Union (r2); + } + + if (hwnd.UserClip != null) { + clip_region.Intersect(hwnd.UserClip); + } + + dc.Clip = clip_region; + paint_event = new PaintEventArgs(dc, hwnd.Invalid); + hwnd.expose_pending = false; + + hwnd.ClearInvalidArea(); + + hwnd.drawing_stack.Push (paint_event); + hwnd.drawing_stack.Push (dc); + + return paint_event; + } else { + dc = Graphics.FromHwnd (paint_hwnd.whole_window); + + if (!hwnd.nc_invalid.IsEmpty) { + dc.SetClip (hwnd.nc_invalid); + paint_event = new PaintEventArgs(dc, hwnd.nc_invalid); + } else { + paint_event = new PaintEventArgs(dc, new Rectangle(0, 0, hwnd.width, hwnd.height)); + } + hwnd.nc_expose_pending = false; + + hwnd.ClearNcInvalidArea (); + + hwnd.drawing_stack.Push (paint_event); + hwnd.drawing_stack.Push (dc); + + return paint_event; + } + } + + internal override void PaintEventEnd(ref Message msg, IntPtr handle, bool client) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (msg.HWnd); + + Graphics dc = (Graphics)hwnd.drawing_stack.Pop (); + dc.Flush(); + dc.Dispose(); + + PaintEventArgs pe = (PaintEventArgs)hwnd.drawing_stack.Pop(); + pe.SetGraphics (null); + pe.Dispose (); + + if (Caret.Visible == true) { + ShowCaret(); + Caret.Paused = false; + } + } + + [MonoTODO("Implement filtering and PM_NOREMOVE")] + internal override bool PeekMessage(Object queue_id, ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags) + { + XEventQueue queue = (XEventQueue) queue_id; + bool pending; + + if ((flags & (uint)PeekMessageFlags.PM_REMOVE) == 0) { + throw new NotImplementedException("PeekMessage PM_NOREMOVE is not implemented yet"); // FIXME - Implement PM_NOREMOVE flag + } + + pending = false; + if (queue.Count > 0) { + pending = true; + } else { + // Only call UpdateMessageQueue if real events are pending + // otherwise we go to sleep on the socket + if (XPending(DisplayHandle) != 0) { + UpdateMessageQueue((XEventQueue)queue_id); + pending = true; + } else if (((XEventQueue)queue_id).Paint.Count > 0) { + pending = true; + } + } + + CheckTimers(queue.timer_list, DateTime.UtcNow); + + if (!pending) { + return false; + } + return GetMessage(queue_id, ref msg, hWnd, wFilterMin, wFilterMax); + } + + internal override bool PostMessage (IntPtr handle, Msg message, IntPtr wparam, IntPtr lparam) + { + XEvent xevent = new XEvent (); + Hwnd hwnd = Hwnd.ObjectFromHandle(handle); + + xevent.type = XEventName.ClientMessage; + xevent.ClientMessageEvent.display = DisplayHandle; + + if (hwnd != null) { + xevent.ClientMessageEvent.window = hwnd.whole_window; + } else { + xevent.ClientMessageEvent.window = IntPtr.Zero; + } + + xevent.ClientMessageEvent.message_type = (IntPtr) PostAtom; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = handle; + xevent.ClientMessageEvent.ptr2 = (IntPtr) message; + xevent.ClientMessageEvent.ptr3 = wparam; + xevent.ClientMessageEvent.ptr4 = lparam; + + if (hwnd != null) + hwnd.Queue.EnqueueLocked (xevent); + else + ThreadQueue(Thread.CurrentThread).EnqueueLocked (xevent); + + return true; + } + + internal override void PostQuitMessage(int exitCode) + { + ApplicationContext ctx = Application.MWFThread.Current.Context; + Form f = ctx != null ? ctx.MainForm : null; + if (f != null) + PostMessage (Application.MWFThread.Current.Context.MainForm.window.Handle, Msg.WM_QUIT, IntPtr.Zero, IntPtr.Zero); + else + PostMessage (FosterParent, Msg.WM_QUIT, IntPtr.Zero, IntPtr.Zero); + XFlush(DisplayHandle); + } + + internal override void RequestAdditionalWM_NCMessages(IntPtr hwnd, bool hover, bool leave) + { + // TODO + } + + internal override void RequestNCRecalc(IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd == null) { + return; + } + + PerformNCCalc(hwnd); + SendMessage(handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + InvalidateNC(handle); + } + + internal override void ResetMouseHover(IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + if (hwnd == null) { + return; + } + + HoverState.Timer.Enabled = true; + HoverState.X = mouse_position.X; + HoverState.Y = mouse_position.Y; + HoverState.Window = handle; + } + + + internal override void ScreenToClient(IntPtr handle, ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + IntPtr child; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + lock (XlibLock) { + XTranslateCoordinates (DisplayHandle, RootWindow, hwnd.client_window, x, y, out dest_x_return, out dest_y_return, out child); + } + + x = dest_x_return; + y = dest_y_return; + } + + internal override void ScreenToMenu(IntPtr handle, ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + IntPtr child; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + lock (XlibLock) { + XTranslateCoordinates (DisplayHandle, RootWindow, hwnd.whole_window, x, y, out dest_x_return, out dest_y_return, out child); + } + + Form form = Widget.FromHandle (handle) as Form; + if (form != null && form.window_manager != null) { + dest_y_return -= form.window_manager.TitleBarHeight; + } + + x = dest_x_return; + y = dest_y_return; + } + + bool GraphicsExposePredicate (IntPtr display, ref XEvent xevent, IntPtr arg) + { + return (xevent.type == XEventName.GraphicsExpose || xevent.type == XEventName.NoExpose) && + arg == xevent.GraphicsExposeEvent.drawable; + } + + delegate bool EventPredicate (IntPtr display, ref XEvent xevent, IntPtr arg); + + void ProcessGraphicsExpose (Hwnd hwnd) + { + XEvent xevent = new XEvent (); + IntPtr handle = Hwnd.HandleFromObject (hwnd); + EventPredicate predicate = GraphicsExposePredicate; + + for (;;) { + XIfEvent (Display, ref xevent, predicate, handle); + if (xevent.type != XEventName.GraphicsExpose) + break; + + AddExpose (hwnd, xevent.ExposeEvent.window == hwnd.ClientWindow, xevent.GraphicsExposeEvent.x, xevent.GraphicsExposeEvent.y, + xevent.GraphicsExposeEvent.width, xevent.GraphicsExposeEvent.height); + + if (xevent.GraphicsExposeEvent.count == 0) + break; + } + } + + internal override void ScrollWindow(IntPtr handle, Rectangle area, int XAmount, int YAmount, bool with_children) + { + Hwnd hwnd; + IntPtr gc; + XGCValues gc_values; + + hwnd = Hwnd.ObjectFromHandle(handle); + + Rectangle r = Rectangle.Intersect (hwnd.Invalid, area); + if (!r.IsEmpty) { + /* We have an invalid area in the window we're scrolling. + Adjust our stored invalid rectangle to to match the scrolled amount */ + + r.X += XAmount; + r.Y += YAmount; + + if (r.X < 0) { + r.Width += r.X; + r.X =0; + } + + if (r.Y < 0) { + r.Height += r.Y; + r.Y =0; + } + + if (area.Contains (hwnd.Invalid)) + hwnd.ClearInvalidArea (); + hwnd.AddInvalidArea(r); + } + + gc_values = new XGCValues(); + + if (with_children) { + gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors; + } + + gc = XCreateGC(DisplayHandle, hwnd.client_window, IntPtr.Zero, ref gc_values); + + Rectangle visible_rect = GetTotalVisibleArea (hwnd.client_window); + visible_rect.Intersect (area); + + Rectangle dest_rect = visible_rect; + dest_rect.Y += YAmount; + dest_rect.X += XAmount; + dest_rect.Intersect (area); + + Point src = new Point (dest_rect.X - XAmount, dest_rect.Y - YAmount); + XCopyArea (DisplayHandle, hwnd.client_window, hwnd.client_window, gc, src.X, src.Y, + dest_rect.Width, dest_rect.Height, dest_rect.X, dest_rect.Y); + + Rectangle dirty_area = GetDirtyArea (area, dest_rect, XAmount, YAmount); + AddExpose (hwnd, true, dirty_area.X, dirty_area.Y, dirty_area.Width, dirty_area.Height); + + ProcessGraphicsExpose (hwnd); + + XFreeGC(DisplayHandle, gc); + } + + internal override void ScrollWindow(IntPtr handle, int XAmount, int YAmount, bool with_children) + { + Hwnd hwnd; + Rectangle rect; + + hwnd = Hwnd.GetObjectFromWindow(handle); + + rect = hwnd.ClientRect; + rect.X = 0; + rect.Y = 0; + ScrollWindow(handle, rect, XAmount, YAmount, with_children); + } + + Rectangle GetDirtyArea (Rectangle total_area, Rectangle valid_area, int XAmount, int YAmount) + { + Rectangle dirty_area = total_area; + + if (YAmount > 0) + dirty_area.Height -= valid_area.Height; + else if (YAmount < 0) { + dirty_area.Height -= valid_area.Height; + dirty_area.Y += valid_area.Height; + } + + if (XAmount > 0) + dirty_area.Width -= valid_area.Width; + else if (XAmount < 0) { + dirty_area.Width -= valid_area.Width; + dirty_area.X += valid_area.Width; + } + + return dirty_area; + } + + Rectangle GetTotalVisibleArea (IntPtr handle) + { + Widget c = Widget.FromHandle (handle); + + Rectangle visible_area = c.ClientRectangle; + visible_area.Location = c.PointToScreen (Point.Empty); + + for (Widget parent = c.Parent; parent != null; parent = parent.Parent) { + if (!parent.IsHandleCreated || !parent.Visible) + return visible_area; // Non visible, not need to finish computations + + Rectangle r = parent.ClientRectangle; + r.Location = parent.PointToScreen (Point.Empty); + + visible_area.Intersect (r); + } + + visible_area.Location = c.PointToClient (visible_area.Location); + return visible_area; + } + + internal override void SendAsyncMethod (AsyncMethodData method) + { + Hwnd hwnd; + XEvent xevent = new XEvent (); + + hwnd = Hwnd.ObjectFromHandle(method.Handle); + + xevent.type = XEventName.ClientMessage; + xevent.ClientMessageEvent.display = DisplayHandle; + xevent.ClientMessageEvent.window = method.Handle; + xevent.ClientMessageEvent.message_type = (IntPtr)AsyncAtom; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = (IntPtr) GCHandle.Alloc (method); + + hwnd.Queue.EnqueueLocked (xevent); + + WakeupMain (); + } + + delegate IntPtr WndProcDelegate (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam); + + internal override IntPtr SendMessage (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam) + { + Hwnd h; + h = Hwnd.ObjectFromHandle(hwnd); + + if (h != null && h.queue != ThreadQueue (Thread.CurrentThread)) { + AsyncMethodResult result; + AsyncMethodData data; + + result = new AsyncMethodResult (); + data = new AsyncMethodData (); + + data.Handle = hwnd; + data.Method = new WndProcDelegate (NativeWindow.WndProc); + data.Args = new object[] { hwnd, message, wParam, lParam }; + data.Result = result; + + SendAsyncMethod (data); + DriverDebug("Sending {0} message across.", message); + + return IntPtr.Zero; + } + string key = hwnd + ":" + message; + if (messageHold[key] != null) + messageHold[key] = ((int)messageHold[key]) - 1; + return NativeWindow.WndProc(hwnd, message, wParam, lParam); + } + + internal override int SendInput(IntPtr handle, Queue keys) + { + if (handle == IntPtr.Zero) + return 0; + + int count = keys.Count; + Hwnd hwnd = Hwnd.ObjectFromHandle(handle); + + while (keys.Count > 0) { + + MSG msg = (MSG)keys.Dequeue(); + + XEvent xevent = new XEvent (); + + xevent.type = (msg.message == Msg.WM_KEYUP ? XEventName.KeyRelease : XEventName.KeyPress); + xevent.KeyEvent.display = DisplayHandle; + + if (hwnd != null) { + xevent.KeyEvent.window = hwnd.whole_window; + } else { + xevent.KeyEvent.window = IntPtr.Zero; + } + + xevent.KeyEvent.keycode = Keyboard.ToKeycode((int)msg.wParam); + + hwnd.Queue.EnqueueLocked (xevent); + } + return count; + } + + internal override void SetAllowDrop (IntPtr handle, bool value) + { + // We allow drop on all windows + } + + internal override DragDropEffects StartDrag (IntPtr handle, object data, + DragDropEffects allowed_effects) + { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd == null) + throw new ArgumentException ("Attempt to begin drag from invalid window handle (" + handle.ToInt32 () + ")."); + + return Dnd.StartDrag (hwnd.client_window, data, allowed_effects); + } + + internal override void SetBorderStyle(IntPtr handle, FormBorderStyle border_style) + { + Form form = Widget.FromHandle (handle) as Form; + if (form != null && form.window_manager == null) { + CreateParams cp = form.GetCreateParams (); + if (border_style == FormBorderStyle.FixedToolWindow || + border_style == FormBorderStyle.SizableToolWindow || + cp.IsSet (WindowExStyles.WS_EX_TOOLWINDOW)) { + form.window_manager = new ToolWindowManager (form); + } + } + + RequestNCRecalc(handle); + } + + internal override void SetCaretPos(IntPtr handle, int x, int y) + { + if (Caret.Hwnd == handle) { + Caret.Timer.Stop(); + HideCaret(); + + Caret.X = x; + Caret.Y = y; + + Keyboard.SetCaretPos (Caret, handle, x, y); + + if (Caret.Visible == true) { + ShowCaret(); + Caret.Timer.Start(); + } + } + } + + internal override void SetClipRegion(IntPtr handle, Region region) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + if (hwnd == null) { + return; + } + + hwnd.UserClip = region; + } + + internal override void SetCursor(IntPtr handle, IntPtr cursor) + { + Hwnd hwnd; + + if (OverrideCursorHandle == IntPtr.Zero) { + if ((LastCursorWindow == handle) && (LastCursorHandle == cursor)) { + return; + } + + LastCursorHandle = cursor; + LastCursorWindow = handle; + + hwnd = Hwnd.ObjectFromHandle(handle); + lock (XlibLock) { + if (cursor != IntPtr.Zero) { + XDefineCursor(DisplayHandle, hwnd.whole_window, cursor); + } else { + XUndefineCursor(DisplayHandle, hwnd.whole_window); + } + XFlush(DisplayHandle); + } + return; + } + + hwnd = Hwnd.ObjectFromHandle(handle); + lock (XlibLock) { + XDefineCursor(DisplayHandle, hwnd.whole_window, OverrideCursorHandle); + } + } + + void QueryPointer (IntPtr display, IntPtr w, out IntPtr root, out IntPtr child, + out int root_x, out int root_y, out int child_x, out int child_y, + out int mask) + { + /* this code was written with the help of + glance at gdk. I never would have realized we + needed a loop in order to traverse down in the + hierarchy. I would have assumed you'd get the + most deeply nested child and have to do + XQueryTree to move back up the hierarchy.. + stupid me, of course. */ + IntPtr c; + + XGrabServer (display); + + XQueryPointer(display, w, out root, out c, + out root_x, out root_y, out child_x, out child_y, + out mask); + + if (root != w) + c = root; + + IntPtr child_last = IntPtr.Zero; + while (c != IntPtr.Zero) { + child_last = c; + XQueryPointer(display, c, out root, out c, + out root_x, out root_y, out child_x, out child_y, + out mask); + } + XUngrabServer (display); + XFlush (display); + + child = child_last; + } + + internal override void SetCursorPos(IntPtr handle, int x, int y) + { + if (handle == IntPtr.Zero) { + lock (XlibLock) { + IntPtr root, child; + int root_x, root_y, child_x, child_y, mask; + + /* we need to do a + * QueryPointer before warping + * because if the warp is on + * the RootWindow, the x/y are + * relative to the current + * mouse position + */ + QueryPointer (DisplayHandle, RootWindow, + out root, + out child, + out root_x, out root_y, + out child_x, out child_y, + out mask); + + XWarpPointer(DisplayHandle, IntPtr.Zero, IntPtr.Zero, 0, 0, 0, 0, x - root_x, y - root_y); + + XFlush (DisplayHandle); + + /* then we need to a + * QueryPointer after warping + * to manually generate a + * motion event for the window + * we move into. + */ + QueryPointer (DisplayHandle, RootWindow, + out root, + out child, + out root_x, out root_y, + out child_x, out child_y, + out mask); + + Hwnd child_hwnd = Hwnd.ObjectFromHandle(child); + if (child_hwnd == null) { + return; + } + + XEvent xevent = new XEvent (); + + xevent.type = XEventName.MotionNotify; + xevent.MotionEvent.display = DisplayHandle; + xevent.MotionEvent.window = child_hwnd.client_window; + xevent.MotionEvent.root = RootWindow; + xevent.MotionEvent.x = child_x; + xevent.MotionEvent.y = child_y; + xevent.MotionEvent.x_root = root_x; + xevent.MotionEvent.y_root = root_y; + xevent.MotionEvent.state = mask; + + child_hwnd.Queue.EnqueueLocked (xevent); + } + } else { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + lock (XlibLock) { + XWarpPointer(DisplayHandle, IntPtr.Zero, hwnd.client_window, 0, 0, 0, 0, x, y); + } + } + } + + internal override void SetFocus(IntPtr handle) + { + Hwnd hwnd; + IntPtr prev_focus_window; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd.client_window == FocusWindow) { + return; + } + + // Win32 doesn't do anything if disabled + if (!hwnd.enabled) + return; + + prev_focus_window = FocusWindow; + FocusWindow = hwnd.client_window; + + if (prev_focus_window != IntPtr.Zero) { + SendMessage(prev_focus_window, Msg.WM_KILLFOCUS, FocusWindow, IntPtr.Zero); + } + Keyboard.FocusIn (FocusWindow); + SendMessage(FocusWindow, Msg.WM_SETFOCUS, prev_focus_window, IntPtr.Zero); + + //XSetInputFocus(DisplayHandle, Hwnd.ObjectFromHandle(handle).client_window, RevertTo.None, IntPtr.Zero); + } + + internal override void SetIcon(IntPtr handle, Icon icon) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + if (hwnd != null) { + SetIcon(hwnd, icon); + } + } + + internal override void SetMenu(IntPtr handle, Menu menu) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + hwnd.menu = menu; + + RequestNCRecalc(handle); + } + + internal override void SetModal(IntPtr handle, bool Modal) + { + if (Modal) { + ModalWindows.Push(handle); + } else { + if (ModalWindows.Contains(handle)) { + ModalWindows.Pop(); + } + if (ModalWindows.Count > 0) { + Activate((IntPtr)ModalWindows.Peek()); + } + } + + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + Widget ctrl = Widget.FromHandle (handle); + SetWMStyles (hwnd, ctrl.GetCreateParams ()); + } + + internal override IntPtr SetParent(IntPtr handle, IntPtr parent) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + hwnd.parent = Hwnd.ObjectFromHandle(parent); + + lock (XlibLock) { + DriverDebug("Parent for window {0} = {1}", XplatUI.Window(hwnd.Handle), XplatUI.Window(hwnd.parent != null ? hwnd.parent.Handle : IntPtr.Zero)); + XReparentWindow(DisplayHandle, hwnd.whole_window, hwnd.parent == null ? FosterParent : hwnd.parent.client_window, hwnd.x, hwnd.y); + } + + return IntPtr.Zero; + } + + internal override void SetTimer (Timer timer) + { + XEventQueue queue = (XEventQueue) MessageQueues [timer.thread]; + + if (queue == null) { + // This isn't really an error, MS doesn't start the timer if + // it has no assosciated queue at this stage (it will be + // enabled when a window is activated). + unattached_timer_list.Add (timer); + return; + } + queue.timer_list.Add (timer); + WakeupMain (); + } + + internal override bool SetTopmost(IntPtr handle, bool enabled) + { + + Hwnd hwnd = Hwnd.ObjectFromHandle(handle); + hwnd.topmost = enabled; + + if (enabled) { + lock (XlibLock) { + if (hwnd.Mapped) { + SendNetWMMessage(hwnd.WholeWindow, _NET_WM_STATE, (IntPtr) NetWmStateRequest._NET_WM_STATE_ADD, _NET_WM_STATE_ABOVE, IntPtr.Zero); + } else { + int[] atoms = new int[8]; + atoms[0] = _NET_WM_STATE_ABOVE.ToInt32(); + XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1); + } + } + } else { + lock (XlibLock) { + if (hwnd.Mapped) + SendNetWMMessage(hwnd.WholeWindow, _NET_WM_STATE, (IntPtr) NetWmStateRequest._NET_WM_STATE_REMOVE, _NET_WM_STATE_ABOVE, IntPtr.Zero); + else + XDeleteProperty(DisplayHandle, hwnd.whole_window, _NET_WM_STATE); + } + } + return true; + } + + internal override bool SetOwner(IntPtr handle, IntPtr handle_owner) + { + Hwnd hwnd; + Hwnd hwnd_owner; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (handle_owner != IntPtr.Zero) { + hwnd_owner = Hwnd.ObjectFromHandle(handle_owner); + lock (XlibLock) { + int[] atoms; + + atoms = new int[8]; + + atoms[0] = _NET_WM_WINDOW_TYPE_NORMAL.ToInt32(); + XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_TYPE, (IntPtr)Atom.XA_ATOM, 32, PropertyMode.Replace, atoms, 1); + + if (hwnd_owner != null) { + XSetTransientForHint(DisplayHandle, hwnd.whole_window, hwnd_owner.whole_window); + } else { + XSetTransientForHint(DisplayHandle, hwnd.whole_window, RootWindow); + } + } + } else { + lock (XlibLock) { + XDeleteProperty(DisplayHandle, hwnd.whole_window, (IntPtr)Atom.XA_WM_TRANSIENT_FOR); + } + } + return true; + } + + internal override bool SetVisible (IntPtr handle, bool visible, bool activate) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + hwnd.visible = visible; + + lock (XlibLock) { + if (visible) { + MapWindow(hwnd, WindowType.Both); + + if (Widget.FromHandle(handle) is Form) { + FormWindowState s; + + s = ((Form)Widget.FromHandle(handle)).WindowState; + + switch(s) { + case FormWindowState.Minimized: SetWindowState(handle, FormWindowState.Minimized); break; + case FormWindowState.Maximized: SetWindowState(handle, FormWindowState.Maximized); break; + } + } + + SendMessage(handle, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + } + else { + UnmapWindow(hwnd, WindowType.Both); + } + } + return true; + } + + internal override void SetWindowMinMax(IntPtr handle, Rectangle maximized, Size min, Size max) + { + Widget ctrl = Widget.FromHandle (handle); + SetWindowMinMax (handle, maximized, min, max, ctrl != null ? ctrl.GetCreateParams () : null); + } + + internal void SetWindowMinMax (IntPtr handle, Rectangle maximized, Size min, Size max, CreateParams cp) + { + Hwnd hwnd; + XSizeHints hints; + IntPtr dummy; + + hwnd = Hwnd.ObjectFromHandle(handle); + if (hwnd == null) { + return; + } + + min.Width = Math.Max (min.Width, SystemInformation.MinimumWindowSize.Width); + min.Height = Math.Max (min.Height, SystemInformation.MinimumWindowSize.Height); + + hints = new XSizeHints(); + + XGetWMNormalHints(DisplayHandle, hwnd.whole_window, ref hints, out dummy); + if ((min != Size.Empty) && (min.Width > 0) && (min.Height > 0)) { + if (cp != null) + min = TranslateWindowSizeToXWindowSize (cp, min); + hints.flags = (IntPtr)((int)hints.flags | (int)XSizeHintsFlags.PMinSize); + hints.min_width = min.Width; + hints.min_height = min.Height; + } + + if ((max != Size.Empty) && (max.Width > 0) && (max.Height > 0)) { + if (cp != null) + max = TranslateWindowSizeToXWindowSize (cp, max); + hints.flags = (IntPtr)((int)hints.flags | (int)XSizeHintsFlags.PMaxSize); + hints.max_width = max.Width; + hints.max_height = max.Height; + } + + if (hints.flags != IntPtr.Zero) { + // The Metacity team has decided that they won't care about this when clicking the maximize icon, + // they will maximize the window to fill the screen/parent no matter what. + // http://bugzilla.ximian.com/show_bug.cgi?id=80021 + XSetWMNormalHints(DisplayHandle, hwnd.whole_window, ref hints); + } + + if ((maximized != Rectangle.Empty) && (maximized.Width > 0) && (maximized.Height > 0)) { + if (cp != null) + maximized.Size = TranslateWindowSizeToXWindowSize (cp); + hints.flags = (IntPtr)XSizeHintsFlags.PPosition; + hints.x = maximized.X; + hints.y = maximized.Y; + hints.width = maximized.Width; + hints.height = maximized.Height; + + // Metacity does not seem to follow this constraint for maximized (zoomed) windows + XSetZoomHints(DisplayHandle, hwnd.whole_window, ref hints); + } + } + + + internal override void SetWindowPos(IntPtr handle, int x, int y, int width, int height) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd == null) { + return; + } + + // Win32 automatically changes negative width/height to 0. + if (width < 0) + width = 0; + if (height < 0) + height = 0; + + // X requires a sanity check for width & height; otherwise it dies + if (hwnd.zero_sized && width > 0 && height > 0) { + if (hwnd.visible) { + MapWindow(hwnd, WindowType.Whole); + } + hwnd.zero_sized = false; + } + + if ((width < 1) || (height < 1)) { + hwnd.zero_sized = true; + UnmapWindow(hwnd, WindowType.Whole); + } + + // Save a server roundtrip (and prevent a feedback loop) + if ((hwnd.x == x) && (hwnd.y == y) && + (hwnd.width == width) && (hwnd.height == height)) { + return; + } + + if (!hwnd.zero_sized) { + //Hack? + hwnd.x = x; + hwnd.y = y; + hwnd.width = width; + hwnd.height = height; + SendMessage(hwnd.client_window, Msg.WM_WINDOWPOSCHANGED, IntPtr.Zero, IntPtr.Zero); + + if (hwnd.fixed_size) { + SetWindowMinMax(handle, Rectangle.Empty, new Size(width, height), new Size(width, height)); + } + + lock (XlibLock) { + Widget ctrl = Widget.FromHandle (handle); + Size TranslatedSize = TranslateWindowSizeToXWindowSize (ctrl.GetCreateParams (), new Size (width, height)); + MoveResizeWindow (DisplayHandle, hwnd.whole_window, x, y, TranslatedSize.Width, TranslatedSize.Height); + PerformNCCalc(hwnd); + } + } + + // Update our position/size immediately, so + // that future calls to SetWindowPos aren't + // kept from calling XMoveResizeWindow (by the + // "Save a server roundtrip" block above). + hwnd.x = x; + hwnd.y = y; + hwnd.width = width; + hwnd.height = height; + hwnd.ClientRect = Rectangle.Empty; + } + + internal override void SetWindowState(IntPtr handle, FormWindowState state) + { + FormWindowState current_state; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + current_state = GetWindowState(handle); + + if (current_state == state) { + return; + } + + switch(state) { + case FormWindowState.Normal: { + lock (XlibLock) { + if (current_state == FormWindowState.Minimized) { + MapWindow(hwnd, WindowType.Both); + } else if (current_state == FormWindowState.Maximized) { + SendNetWMMessage(hwnd.whole_window, _NET_WM_STATE, (IntPtr)2 /* toggle */, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT); + } + } + Activate(handle); + return; + } + + case FormWindowState.Minimized: { + lock (XlibLock) { + if (current_state == FormWindowState.Maximized) { + SendNetWMMessage(hwnd.whole_window, _NET_WM_STATE, (IntPtr)2 /* toggle */, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT); + } + XIconifyWindow(DisplayHandle, hwnd.whole_window, ScreenNo); + } + return; + } + + case FormWindowState.Maximized: { + lock (XlibLock) { + if (current_state == FormWindowState.Minimized) { + MapWindow(hwnd, WindowType.Both); + } + + SendNetWMMessage(hwnd.whole_window, _NET_WM_STATE, (IntPtr)1 /* Add */, _NET_WM_STATE_MAXIMIZED_HORZ, _NET_WM_STATE_MAXIMIZED_VERT); + } + Activate(handle); + return; + } + } + } + + internal override void SetWindowStyle(IntPtr handle, CreateParams cp) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + SetHwndStyles(hwnd, cp); + SetWMStyles(hwnd, cp); + } + + internal override double GetWindowTransparency(IntPtr handle) + { + return 1.0; + } + + internal override void SetWindowTransparency(IntPtr handle, double transparency, Color key) + { + Hwnd hwnd; + IntPtr opacity; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (hwnd == null) { + return; + } + + hwnd.opacity = (uint)(0xffffffff * transparency); + opacity = (IntPtr)hwnd.opacity; + + if (transparency >= 1.0) { + XDeleteProperty (DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_OPACITY); + } else { + XChangeProperty (DisplayHandle, hwnd.whole_window, _NET_WM_WINDOW_OPACITY, (IntPtr)Atom.XA_CARDINAL, 32, PropertyMode.Replace, ref opacity, 1); + } + } + + internal override bool SetZOrder(IntPtr handle, IntPtr after_handle, bool top, bool bottom) + { + Hwnd hwnd = Hwnd.ObjectFromHandle(handle); + + if (!hwnd.mapped) { + return false; + } + + if (top) { + lock (XlibLock) { + XRaiseWindow(DisplayHandle, hwnd.whole_window); + } + return true; + } else if (!bottom) { + Hwnd after_hwnd = null; + + if (after_handle != IntPtr.Zero) { + after_hwnd = Hwnd.ObjectFromHandle(after_handle); + } + + XWindowChanges values = new XWindowChanges(); + + if (after_hwnd == null) { + // Work around metacity 'issues' + int[] atoms; + + atoms = new int[2]; + atoms[0] = unixtime(); + XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_USER_TIME, (IntPtr)Atom.XA_CARDINAL, 32, PropertyMode.Replace, atoms, 1); + + XRaiseWindow(DisplayHandle, hwnd.whole_window); + SendNetWMMessage(hwnd.whole_window, _NET_ACTIVE_WINDOW, (IntPtr)1, IntPtr.Zero, IntPtr.Zero); + return true; + //throw new ArgumentNullException("after_handle", "Need sibling to adjust z-order"); + } + + values.sibling = after_hwnd.whole_window; + values.stack_mode = StackMode.Below; + + lock (XlibLock) { + XConfigureWindow(DisplayHandle, hwnd.whole_window, ChangeWindowFlags.CWStackMode | ChangeWindowFlags.CWSibling, ref values); + } + } else { + // Bottom + lock (XlibLock) { + XLowerWindow(DisplayHandle, hwnd.whole_window); + } + return true; + } + return false; + } + + internal override void ShowCursor(bool show) + { + ; // FIXME - X11 doesn't 'hide' the cursor. we could create an empty cursor + } + + internal override object StartLoop(Thread thread) + { + XEventQueue q = ThreadQueue(thread); + return q; + } + + internal override TransparencySupport SupportsTransparency() + { + // We need to check if the x compositing manager is running + return TransparencySupport.Set; + } + + internal override bool SystrayAdd(IntPtr handle, string tip, Icon icon, out ToolTip tt) + { + GetSystrayManagerWindow(); + + if (SystrayMgrWindow != IntPtr.Zero) { + XSizeHints size_hints; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + DriverDebug("Adding Systray Whole:{0:X}, Client:{1:X}", hwnd.whole_window.ToInt32(), hwnd.client_window.ToInt32()); + + // Oh boy. + if (hwnd.client_window != hwnd.whole_window) { + Keyboard.DestroyICForWindow (hwnd.client_window); + XDestroyWindow(DisplayHandle, hwnd.client_window); + hwnd.client_window = hwnd.whole_window; + } + + /* by virtue of the way the tests are ordered when determining if it's PAINT + or NCPAINT, client_window == whole_window will always be PAINT. So, if we're + waiting on an nc_expose, drop it and remove the hwnd from the list (unless + there's a pending expose). */ + if (hwnd.nc_expose_pending) { + hwnd.nc_expose_pending = false; + if (!hwnd.expose_pending) + hwnd.Queue.Paint.Remove (hwnd); + } + + // We are going to be directly mapped by the system tray, so mark as mapped + // so we can later properly unmap it. + hwnd.mapped = true; + + size_hints = new XSizeHints(); + + size_hints.flags = (IntPtr)(XSizeHintsFlags.PMinSize | XSizeHintsFlags.PMaxSize | XSizeHintsFlags.PBaseSize); + + size_hints.min_width = 24; + size_hints.min_height = 24; + size_hints.max_width = 24; + size_hints.max_height = 24; + size_hints.base_width = 24; + size_hints.base_height = 24; + + XSetWMNormalHints(DisplayHandle, hwnd.whole_window, ref size_hints); + + int[] atoms = new int[2]; + atoms [0] = 1; // Version 1 + atoms [1] = 1; // we want to be mapped + + // This line cost me 3 days... + XChangeProperty(DisplayHandle, hwnd.whole_window, _XEMBED_INFO, _XEMBED_INFO, 32, PropertyMode.Replace, atoms, 2); + + // Need to pick some reasonable defaults + tt = new ToolTip(); + tt.AutomaticDelay = 350; + tt.InitialDelay = 250; + tt.ReshowDelay = 250; + tt.ShowAlways = true; + + if ((tip != null) && (tip != string.Empty)) { + tt.SetToolTip(Widget.FromHandle(handle), tip); + tt.Active = true; + } else { + tt.Active = false; + } + + SendNetClientMessage(SystrayMgrWindow, _NET_SYSTEM_TRAY_OPCODE, IntPtr.Zero, (IntPtr)SystrayRequest.SYSTEM_TRAY_REQUEST_DOCK, hwnd.whole_window); + + return true; + } + tt = null; + return false; + } + + internal override bool SystrayChange(IntPtr handle, string tip, Icon icon, ref ToolTip tt) + { + Widget Widget; + + Widget = Widget.FromHandle(handle); + if (Widget != null && tt != null) { + tt.SetToolTip(Widget, tip); + tt.Active = true; + SendMessage(handle, Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero); + return true; + } else { + return false; + } + } + + internal override void SystrayRemove(IntPtr handle, ref ToolTip tt) + { + + SetVisible (handle, false, false); + + // The caller can now re-dock it later... + if (tt != null) { + tt.Dispose(); + tt = null; + } + // Close any balloon window *we* fired. + ThemeEngine.Current.HideBalloonWindow (handle); + } + + internal override void SystrayBalloon(IntPtr handle, int timeout, string title, string text, ToolTipIcon icon) + { + ThemeEngine.Current.ShowBalloonWindow (handle, timeout, title, text, icon); + SendMessage(handle, Msg.WM_USER, IntPtr.Zero, (IntPtr) Msg.NIN_BALLOONSHOW); + } + + internal override bool Text(IntPtr handle, string text) +{ + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + lock (XlibLock) { + XChangeProperty(DisplayHandle, hwnd.whole_window, _NET_WM_NAME, UTF8_STRING, 8, + PropertyMode.Replace, text, Encoding.UTF8.GetByteCount (text)); + + // XXX this has problems with UTF8. + // we need to either use the actual + // text if it's latin-1, or convert it + // to compound text if it's in a + // different charset. + XStoreName(DisplayHandle, Hwnd.ObjectFromHandle(handle).whole_window, text); + } + return true; + } + + internal override bool TranslateMessage(ref MSG msg) + { + return Keyboard.TranslateMessage (ref msg); + } + + internal override void UpdateWindow(IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle(handle); + + if (!hwnd.visible || !hwnd.expose_pending || !hwnd.Mapped) { + return; + } + + SendMessage(handle, Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero); + hwnd.Queue.Paint.Remove(hwnd); + } + + internal override void CreateOffscreenDrawable (IntPtr handle, + int width, int height, + out object offscreen_drawable) + { + IntPtr root_out; + int x_out, y_out, width_out, height_out, border_width_out, depth_out; + + XGetGeometry (DisplayHandle, handle, + out root_out, + out x_out, out y_out, + out width_out, out height_out, + out border_width_out, out depth_out); + + IntPtr pixmap = XCreatePixmap (DisplayHandle, handle, width, height, depth_out); + + offscreen_drawable = pixmap; + + } + + internal override void DestroyOffscreenDrawable (object offscreen_drawable) + { + XFreePixmap (DisplayHandle, (IntPtr)offscreen_drawable); + } + + internal override Graphics GetOffscreenGraphics (object offscreen_drawable) + { + return Graphics.FromHwnd ((IntPtr) offscreen_drawable); + } + + internal override void BlitFromOffscreen (IntPtr dest_handle, + Graphics dest_dc, + object offscreen_drawable, + Graphics offscreen_dc, + Rectangle r) + { + XGCValues gc_values; + IntPtr gc; + + gc_values = new XGCValues(); + + gc = XCreateGC (DisplayHandle, dest_handle, IntPtr.Zero, ref gc_values); + + XCopyArea (DisplayHandle, (IntPtr)offscreen_drawable, dest_handle, + gc, r.X, r.Y, r.Width, r.Height, r.X, r.Y); + + XFreeGC (DisplayHandle, gc); + } + + #endregion // Public Static Methods + + #region Events + internal override event EventHandler Idle; + #endregion // Events + + +#if TRACE && false + +#region Xcursor imports + [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadCursor")] + internal extern static IntPtr XcursorLibraryLoadCursor (IntPtr display, [MarshalAs (UnmanagedType.LPStr)] string name); + + [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadImages")] + internal extern static IntPtr XcursorLibraryLoadImages ([MarshalAs (UnmanagedType.LPStr)] string file, IntPtr theme, int size); + + [DllImport ("libXcursor", EntryPoint = "XcursorImagesDestroy")] + internal extern static void XcursorImagesDestroy (IntPtr images); + + [DllImport ("libXcursor", EntryPoint = "XcursorGetDefaultSize")] + internal extern static int XcursorGetDefaultSize (IntPtr display); + + [DllImport ("libXcursor", EntryPoint = "XcursorImageLoadCursor")] + internal extern static IntPtr XcursorImageLoadCursor (IntPtr display, IntPtr image); + + [DllImport ("libXcursor", EntryPoint = "XcursorGetTheme")] + internal extern static IntPtr XcursorGetTheme (IntPtr display); +#endregion +#region X11 Imports + [DllImport ("libX11", EntryPoint="XOpenDisplay")] + internal extern static IntPtr XOpenDisplay(IntPtr display); + [DllImport ("libX11", EntryPoint="XCloseDisplay")] + internal extern static int XCloseDisplay(IntPtr display); + [DllImport ("libX11", EntryPoint="XSynchronize")] + internal extern static IntPtr XSynchronize(IntPtr display, bool onoff); + + [DllImport ("libX11", EntryPoint="XCreateWindow")] + internal extern static IntPtr _XCreateWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, int depth, int xclass, IntPtr visual, UIntPtr valuemask, ref XSetWindowAttributes attributes); + internal static IntPtr XCreateWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, int depth, int xclass, IntPtr visual, UIntPtr valuemask, ref XSetWindowAttributes attributes) + { + DebugHelper.TraceWriteLine ("XCreateWindow"); + return _XCreateWindow(display, parent, x, y, width, height, + border_width, depth, xclass, visual, valuemask, ref attributes); + } + [DllImport ("libX11", EntryPoint="XCreateSimpleWindow")] + internal extern static IntPtr _XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background); + internal static IntPtr XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background) + { + DebugHelper.TraceWriteLine ("XCreateSimpleWindow"); + return _XCreateSimpleWindow(display, parent, x, y, width, height, border_width, border, background); + } + [DllImport ("libX11", EntryPoint="XMapWindow")] + internal extern static int _XMapWindow(IntPtr display, IntPtr window); + internal static int XMapWindow(IntPtr display, IntPtr window) + { + DebugHelper.TraceWriteLine ("XMapWindow"); + return _XMapWindow(display, window); + } + [DllImport ("libX11", EntryPoint="XMapRaised")] + internal extern static int _XMapRaised(IntPtr display, IntPtr window); + internal static int XMapRaised(IntPtr display, IntPtr window) + { + DebugHelper.TraceWriteLine ("XMapRaised"); + return _XMapRaised(display, window); + } + [DllImport ("libX11", EntryPoint="XUnmapWindow")] + internal extern static int _XUnmapWindow(IntPtr display, IntPtr window); + internal static int XUnmapWindow(IntPtr display, IntPtr window) + { + DebugHelper.TraceWriteLine ("XUnmapWindow"); + return _XUnmapWindow(display, window); + } + [DllImport ("libX11", EntryPoint="XMapSubwindows")] + internal extern static int _XMapSubindows(IntPtr display, IntPtr window); + internal static int XMapSubindows(IntPtr display, IntPtr window) + { + DebugHelper.TraceWriteLine ("XMapSubindows"); + return _XMapSubindows(display, window); + } + [DllImport ("libX11", EntryPoint="XUnmapSubwindows")] + internal extern static int _XUnmapSubwindows(IntPtr display, IntPtr window); + internal static int XUnmapSubwindows(IntPtr display, IntPtr window) + { + DebugHelper.TraceWriteLine ("XUnmapSubwindows"); + return _XUnmapSubwindows(display, window); + } + [DllImport ("libX11", EntryPoint="XRootWindow")] + internal extern static IntPtr _XRootWindow(IntPtr display, int screen_number); + internal static IntPtr XRootWindow(IntPtr display, int screen_number) + { + DebugHelper.TraceWriteLine ("XRootWindow"); + return _XRootWindow(display, screen_number); + } + [DllImport ("libX11", EntryPoint="XNextEvent")] + internal extern static IntPtr _XNextEvent(IntPtr display, ref XEvent xevent); + internal static IntPtr XNextEvent(IntPtr display, ref XEvent xevent) + { + DebugHelper.TraceWriteLine ("XNextEvent"); + return _XNextEvent(display, ref xevent); + } + [DllImport ("libX11", EntryPoint="XConnectionNumber")] + internal extern static int _XConnectionNumber (IntPtr display); + internal static int XConnectionNumber (IntPtr display) + { + DebugHelper.TraceWriteLine ("XConnectionNumber"); + return _XConnectionNumber (display); + } + [DllImport ("libX11", EntryPoint="XPending")] + internal extern static int _XPending (IntPtr display); + internal static int XPending (IntPtr display) + { + DebugHelper.TraceWriteLine ("XPending"); + DebugHelper.DumpCallers (3); + return _XPending (display); + } + [DllImport ("libX11", EntryPoint="XSelectInput")] + internal extern static IntPtr _XSelectInput(IntPtr display, IntPtr window, IntPtr mask); + internal static IntPtr XSelectInput(IntPtr display, IntPtr window, IntPtr mask) + { + DebugHelper.TraceWriteLine ("XSelectInput"); + return _XSelectInput(display, window, mask); + } + + [DllImport ("libX11", EntryPoint="XDestroyWindow")] + internal extern static int _XDestroyWindow(IntPtr display, IntPtr window); + internal static int XDestroyWindow(IntPtr display, IntPtr window) + { + DebugHelper.TraceWriteLine ("XDestroyWindow 0x{0:x}", window.ToInt32()); + return _XDestroyWindow(display, window); + } + + [DllImport ("libX11", EntryPoint="XReparentWindow")] + internal extern static int _XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y); + internal static int XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y) + { + DebugHelper.TraceWriteLine ("XReparentWindow"); + return _XReparentWindow(display, window, parent, x, y); + } + + [DllImport ("libX11", EntryPoint="XMoveResizeWindow")] + extern static int _XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height); + static int XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height) { + DebugHelper.TraceWriteLine ("XMoveResizeWindow"); + return _XMoveResizeWindow(display, window, x, y, width, height); + } + + internal static int MoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height) + { + int ret = XMoveResizeWindow (display, window, x, y, width, height); + Keyboard.MoveCurrentCaretPos (); + return ret; + } + + [DllImport ("libX11", EntryPoint="XResizeWindow")] + internal extern static int _XResizeWindow(IntPtr display, IntPtr window, int width, int height); + internal static int XResizeWindow(IntPtr display, IntPtr window, int width, int height) + { + DebugHelper.TraceWriteLine ("XResizeWindow"); + return _XResizeWindow(display, window, width, height); + } + + [DllImport ("libX11", EntryPoint="XGetWindowAttributes")] + internal extern static int _XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes); + internal static int XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes) + { + DebugHelper.TraceWriteLine ("XGetWindowAttributes"); + return _XGetWindowAttributes(display, window, ref attributes); + } + + [DllImport ("libX11", EntryPoint="XFlush")] + internal extern static int _XFlush(IntPtr display); + internal static int XFlush(IntPtr display) + { + DebugHelper.TraceWriteLine ("XFlush"); + return _XFlush(display); + } + + [DllImport ("libX11", EntryPoint="XSetWMName")] + internal extern static int _XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop); + internal static int XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop) + { + DebugHelper.TraceWriteLine ("XSetWMName"); + return _XSetWMName(display, window, ref text_prop); + } + + [DllImport ("libX11", EntryPoint="XStoreName")] + internal extern static int _XStoreName(IntPtr display, IntPtr window, string window_name); + internal static int XStoreName(IntPtr display, IntPtr window, string window_name) + { + DebugHelper.TraceWriteLine ("XStoreName"); + return _XStoreName(display, window, window_name); + } + + [DllImport ("libX11", EntryPoint="XFetchName")] + internal extern static int _XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name); + internal static int XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name) + { + DebugHelper.TraceWriteLine ("XFetchName"); + return _XFetchName(display, window, ref window_name); + } + + [DllImport ("libX11", EntryPoint="XSendEvent")] + internal extern static int _XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event); + internal static int XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event) + { + DebugHelper.TraceWriteLine ("XSendEvent"); + return _XSendEvent(display, window, propagate, event_mask, ref send_event); + } + + [DllImport ("libX11", EntryPoint="XQueryTree")] + internal extern static int _XQueryTree(IntPtr display, IntPtr window, out IntPtr root_return, out IntPtr parent_return, out IntPtr children_return, out int nchildren_return); + internal static int XQueryTree(IntPtr display, IntPtr window, out IntPtr root_return, out IntPtr parent_return, out IntPtr children_return, out int nchildren_return) + { + DebugHelper.TraceWriteLine ("XQueryTree"); + return _XQueryTree(display, window, out root_return, out parent_return, out children_return, out nchildren_return); + } + + [DllImport ("libX11", EntryPoint="XFree")] + internal extern static int _XFree(IntPtr data); + internal static int XFree(IntPtr data) + { + DebugHelper.TraceWriteLine ("XFree"); + return _XFree(data); + } + + [DllImport ("libX11", EntryPoint="XRaiseWindow")] + internal extern static int _XRaiseWindow(IntPtr display, IntPtr window); + internal static int XRaiseWindow(IntPtr display, IntPtr window) + { + DebugHelper.TraceWriteLine ("XRaiseWindow"); + return _XRaiseWindow(display, window); + } + + [DllImport ("libX11", EntryPoint="XLowerWindow")] + internal extern static uint _XLowerWindow(IntPtr display, IntPtr window); + internal static uint XLowerWindow(IntPtr display, IntPtr window) + { + DebugHelper.TraceWriteLine ("XLowerWindow"); + return _XLowerWindow(display, window); + } + + [DllImport ("libX11", EntryPoint="XConfigureWindow")] + internal extern static uint _XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values); + internal static uint XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values) + { + DebugHelper.TraceWriteLine ("XConfigureWindow"); + return _XConfigureWindow(display, window, value_mask, ref values); + } + + [DllImport ("libX11", EntryPoint="XInternAtom")] + internal extern static IntPtr _XInternAtom(IntPtr display, string atom_name, bool only_if_exists); + internal static IntPtr XInternAtom(IntPtr display, string atom_name, bool only_if_exists) + { + DebugHelper.TraceWriteLine ("XInternAtom"); + return _XInternAtom(display, atom_name, only_if_exists); + } + + [DllImport ("libX11", EntryPoint="XInternAtoms")] + internal extern static int _XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms); + internal static int XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms) + { + DebugHelper.TraceWriteLine ("XInternAtoms"); + return _XInternAtoms(display, atom_names, atom_count, only_if_exists, atoms); + } + + [DllImport ("libX11", EntryPoint="XSetWMProtocols")] + internal extern static int _XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count); + internal static int XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count) + { + DebugHelper.TraceWriteLine ("XSetWMProtocols"); + return _XSetWMProtocols(display, window, protocols, count); + } + + [DllImport ("libX11", EntryPoint="XGrabPointer")] + internal extern static int _XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp); + internal static int XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp) + { + DebugHelper.TraceWriteLine ("XGrabPointer"); + return _XGrabPointer(display, window, owner_events, event_mask, pointer_mode, keyboard_mode, confine_to, cursor, timestamp); + } + + [DllImport ("libX11", EntryPoint="XUngrabPointer")] + internal extern static int _XUngrabPointer(IntPtr display, IntPtr timestamp); + internal static int XUngrabPointer(IntPtr display, IntPtr timestamp) + { + DebugHelper.TraceWriteLine ("XUngrabPointer"); + return _XUngrabPointer(display, timestamp); + } + + [DllImport ("libX11", EntryPoint="XQueryPointer")] + internal extern static bool _XQueryPointer(IntPtr display, IntPtr window, out IntPtr root, out IntPtr child, out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons); + internal static bool XQueryPointer(IntPtr display, IntPtr window, out IntPtr root, out IntPtr child, out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons) + { + DebugHelper.TraceWriteLine ("XQueryPointer"); + return _XQueryPointer(display, window, out root, out child, out root_x, out root_y, out win_x, out win_y, out keys_buttons); + } + + [DllImport ("libX11", EntryPoint="XTranslateCoordinates")] + internal extern static bool _XTranslateCoordinates (IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return); + internal static bool XTranslateCoordinates (IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return) + { + DebugHelper.TraceWriteLine ("XTranslateCoordinates"); + return _XTranslateCoordinates (display, src_w, dest_w, src_x, src_y, out intdest_x_return, out dest_y_return, out child_return); + } + + [DllImport ("libX11", EntryPoint="XGetGeometry")] + internal extern static bool _XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y, out int width, out int height, out int border_width, out int depth); + internal static bool XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y, out int width, out int height, out int border_width, out int depth) + { + DebugHelper.TraceWriteLine ("XGetGeometry"); + return _XGetGeometry(display, window, out root, out x, out y, out width, out height, out border_width, out depth); + } + + [DllImport ("libX11", EntryPoint="XGetGeometry")] + internal extern static bool _XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, out int width, out int height, IntPtr border_width, IntPtr depth); + internal static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, out int width, out int height, IntPtr border_width, IntPtr depth) + { + DebugHelper.TraceWriteLine ("XGetGeometry"); + return _XGetGeometry(display, window, root, out x, out y, out width, out height, border_width, depth); + } + + [DllImport ("libX11", EntryPoint="XGetGeometry")] + internal extern static bool _XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, IntPtr width, IntPtr height, IntPtr border_width, IntPtr depth); + internal static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, IntPtr width, IntPtr height, IntPtr border_width, IntPtr depth) + { + DebugHelper.TraceWriteLine ("XGetGeometry"); + return _XGetGeometry(display, window, root, out x, out y, width, height, border_width, depth); + } + + [DllImport ("libX11", EntryPoint="XGetGeometry")] + internal extern static bool _XGetGeometry(IntPtr display, IntPtr window, IntPtr root, IntPtr x, IntPtr y, out int width, out int height, IntPtr border_width, IntPtr depth); + internal static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, IntPtr x, IntPtr y, out int width, out int height, IntPtr border_width, IntPtr depth) + { + DebugHelper.TraceWriteLine ("XGetGeometry"); + return _XGetGeometry(display, window, root, x, y, out width, out height, border_width, depth); + } + + [DllImport ("libX11", EntryPoint="XWarpPointer")] + internal extern static uint _XWarpPointer(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, uint src_width, uint src_height, int dest_x, int dest_y); + internal static uint XWarpPointer(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, uint src_width, uint src_height, int dest_x, int dest_y) + { + DebugHelper.TraceWriteLine ("XWarpPointer"); + return _XWarpPointer(display, src_w, dest_w, src_x, src_y, src_width, src_height, dest_x, dest_y); + } + + [DllImport ("libX11", EntryPoint="XClearWindow")] + internal extern static int _XClearWindow(IntPtr display, IntPtr window); + internal static int XClearWindow(IntPtr display, IntPtr window) + { + DebugHelper.TraceWriteLine ("XClearWindow"); + return _XClearWindow(display, window); + } + + [DllImport ("libX11", EntryPoint="XClearArea")] + internal extern static int _XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures); + internal static int XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures) + { + DebugHelper.TraceWriteLine ("XClearArea"); + return _XClearArea(display, window, x, y, width, height, exposures); + } + + // Colormaps + [DllImport ("libX11", EntryPoint="XDefaultScreenOfDisplay")] + internal extern static IntPtr _XDefaultScreenOfDisplay(IntPtr display); + internal static IntPtr XDefaultScreenOfDisplay(IntPtr display) + { + DebugHelper.TraceWriteLine ("XDefaultScreenOfDisplay"); + return _XDefaultScreenOfDisplay(display); + } + + [DllImport ("libX11", EntryPoint="XScreenNumberOfScreen")] + internal extern static int _XScreenNumberOfScreen(IntPtr display, IntPtr Screen); + internal static int XDefaultScreenOfDisplay(IntPtr display, IntPtr Screen) + { + DebugHelper.TraceWriteLine ("XDefaultScreenOfDisplay"); + return _XScreenNumberOfScreen(display, Screen); + } + + [DllImport ("libX11", EntryPoint="XDefaultVisual")] + internal extern static IntPtr _XDefaultVisual(IntPtr display, int screen_number); + internal static IntPtr XDefaultScreenOfDisplay(IntPtr display, int screen_number) + { + DebugHelper.TraceWriteLine ("XDefaultScreenOfDisplay"); + return _XDefaultVisual(display, screen_number); + } + + [DllImport ("libX11", EntryPoint="XDefaultDepth")] + internal extern static uint _XDefaultDepth(IntPtr display, int screen_number); + internal static uint XDefaultDepth(IntPtr display, int screen_number) + { + DebugHelper.TraceWriteLine ("XDefaultDepth"); + return _XDefaultDepth(display, screen_number); + } + + [DllImport ("libX11", EntryPoint="XDefaultScreen")] + internal extern static int _XDefaultScreen(IntPtr display); + internal static int XDefaultScreen(IntPtr display) + { + DebugHelper.TraceWriteLine ("XDefaultScreen"); + return _XDefaultScreen(display); + } + + [DllImport ("libX11", EntryPoint="XDefaultColormap")] + internal extern static IntPtr _XDefaultColormap(IntPtr display, int screen_number); + internal static IntPtr XDefaultColormap(IntPtr display, int screen_number) + { + DebugHelper.TraceWriteLine ("XDefaultColormap"); + return _XDefaultColormap(display, screen_number); + } + + [DllImport ("libX11", EntryPoint="XLookupColor")] + internal extern static int _XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color); + internal static int XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color) + { + DebugHelper.TraceWriteLine ("XLookupColor"); + return _XLookupColor(display, Colormap, Coloranem, ref exact_def_color, ref screen_def_color); + } + + [DllImport ("libX11", EntryPoint="XAllocColor")] + internal extern static int _XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def); + internal static int XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def) + { + DebugHelper.TraceWriteLine ("XAllocColor"); + return _XAllocColor(display, Colormap, ref colorcell_def); + } + + [DllImport ("libX11", EntryPoint="XSetTransientForHint")] + internal extern static int _XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window); + internal static int XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window) + { + DebugHelper.TraceWriteLine ("XSetTransientForHint"); + return _XSetTransientForHint(display, window, prop_window); + } + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements); + internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements) + { + DebugHelper.TraceWriteLine ("XChangeProperty"); + return _XChangeProperty(display, window, property, type, format, mode, ref data, nelements); + } + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements); + internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements) + { + DebugHelper.TraceWriteLine ("XChangeProperty"); + return _XChangeProperty(display, window, property, type, format, mode, ref value, nelements); + } + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements); + internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements) + { + DebugHelper.TraceWriteLine ("XChangeProperty"); + return _XChangeProperty(display, window, property, type, format, mode, ref value, nelements); + } + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements); + internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements) + { + DebugHelper.TraceWriteLine ("XChangeProperty"); + return _XChangeProperty(display, window, property, type, format, mode, data, nelements); + } + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements); + internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements) + { + DebugHelper.TraceWriteLine ("XChangeProperty"); + return _XChangeProperty(display, window, property, type, format, mode, data, nelements); + } + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements); + internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements) + { + DebugHelper.TraceWriteLine ("XChangeProperty"); + return _XChangeProperty(display, window, property, type, format, mode, data, nelements); + } + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements); + internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements) + { + DebugHelper.TraceWriteLine ("XChangeProperty"); + return _XChangeProperty(display, window, property, type, format, mode, atoms, nelements); + } + + [DllImport ("libX11", EntryPoint="XChangeProperty", CharSet=CharSet.Ansi)] + internal extern static int _XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length); + internal static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length) + { + DebugHelper.TraceWriteLine ("XChangeProperty"); + return _XChangeProperty(display, window, property, type, format, mode, text, text_length); + } + + [DllImport ("libX11", EntryPoint="XDeleteProperty")] + internal extern static int _XDeleteProperty(IntPtr display, IntPtr window, IntPtr property); + internal static int XDeleteProperty(IntPtr display, IntPtr window, IntPtr property) + { + DebugHelper.TraceWriteLine ("XDeleteProperty"); + return _XDeleteProperty(display, window, property); + } + + // Drawing + [DllImport ("libX11", EntryPoint="XCreateGC")] + internal extern static IntPtr _XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values); + internal static IntPtr XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values) + { + DebugHelper.TraceWriteLine ("XCreateGC"); + return _XCreateGC(display, window, valuemask, ref values); + } + + [DllImport ("libX11", EntryPoint="XFreeGC")] + internal extern static int _XFreeGC(IntPtr display, IntPtr gc); + internal static int XFreeGC(IntPtr display, IntPtr gc) + { + DebugHelper.TraceWriteLine ("XFreeGC"); + return _XFreeGC(display, gc); + } + + [DllImport ("libX11", EntryPoint="XSetFunction")] + internal extern static int _XSetFunction(IntPtr display, IntPtr gc, GXFunction function); + internal static int XSetFunction(IntPtr display, IntPtr gc, GXFunction function) + { + DebugHelper.TraceWriteLine ("XSetFunction"); + return _XSetFunction(display, gc, function); + } + + [DllImport ("libX11", EntryPoint="XSetLineAttributes")] + internal extern static int _XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style); + internal static int XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style) + { + DebugHelper.TraceWriteLine ("XSetLineAttributes"); + return _XSetLineAttributes(display, gc, line_width, line_style, cap_style, join_style); + } + + [DllImport ("libX11", EntryPoint="XDrawLine")] + internal extern static int _XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2); + internal static int XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2) + { + DebugHelper.TraceWriteLine ("XDrawLine"); + return _XDrawLine(display, drawable, gc, x1, y1, x2, y2); + } + + [DllImport ("libX11", EntryPoint="XDrawRectangle")] + internal extern static int _XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height); + internal static int XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height) + { + DebugHelper.TraceWriteLine ("XDrawRectangle"); + return _XDrawRectangle(display, drawable, gc, x1, y1, width, height); + } + + [DllImport ("libX11", EntryPoint="XFillRectangle")] + internal extern static int _XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height); + internal static int XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height) + { + DebugHelper.TraceWriteLine ("XFillRectangle"); + return _XFillRectangle(display, drawable, gc, x1, y1, width, height); + } + + [DllImport ("libX11", EntryPoint="XSetWindowBackground")] + internal extern static int _XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background); + internal static int XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background) + { + DebugHelper.TraceWriteLine ("XSetWindowBackground"); + return _XSetWindowBackground(display, window, background); + } + + [DllImport ("libX11", EntryPoint="XCopyArea")] + internal extern static int _XCopyArea(IntPtr display, IntPtr src, IntPtr dest, IntPtr gc, int src_x, int src_y, int width, int height, int dest_x, int dest_y); + internal static int XCopyArea(IntPtr display, IntPtr src, IntPtr dest, IntPtr gc, int src_x, int src_y, int width, int height, int dest_x, int dest_y) + { + DebugHelper.TraceWriteLine ("XCopyArea"); + return _XCopyArea(display, src, dest, gc, src_x, src_y, width, height, dest_x, dest_y); + } + + [DllImport ("libX11", EntryPoint="XGetWindowProperty")] + internal extern static int _XGetWindowProperty(IntPtr display, IntPtr window, IntPtr atom, IntPtr long_offset, IntPtr long_length, bool delete, IntPtr req_type, out IntPtr actual_type, out int actual_format, out IntPtr nitems, out IntPtr bytes_after, ref IntPtr prop); + internal static int XGetWindowProperty(IntPtr display, IntPtr window, IntPtr atom, IntPtr long_offset, IntPtr long_length, bool delete, IntPtr req_type, out IntPtr actual_type, out int actual_format, out IntPtr nitems, out IntPtr bytes_after, ref IntPtr prop) + { + DebugHelper.TraceWriteLine ("XGetWindowProperty"); + return _XGetWindowProperty(display, window, atom, long_offset, long_length, delete, req_type, out actual_type, out actual_format, out nitems, out bytes_after, ref prop); + } + + [DllImport ("libX11", EntryPoint="XSetInputFocus")] + internal extern static int _XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time); + internal static int XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time) + { + DebugHelper.TraceWriteLine ("XSetInputFocus"); + return _XSetInputFocus(display, window, revert_to, time); + } + + [DllImport ("libX11", EntryPoint="XIconifyWindow")] + internal extern static int _XIconifyWindow(IntPtr display, IntPtr window, int screen_number); + internal static int XIconifyWindow(IntPtr display, IntPtr window, int screen_number) + { + DebugHelper.TraceWriteLine ("XIconifyWindow"); + return _XIconifyWindow(display, window, screen_number); + } + + [DllImport ("libX11", EntryPoint="XDefineCursor")] + internal extern static int _XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor); + internal static int XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor) + { + DebugHelper.TraceWriteLine ("XDefineCursor"); + return _XDefineCursor(display, window, cursor); + } + + [DllImport ("libX11", EntryPoint="XUndefineCursor")] + internal extern static int _XUndefineCursor(IntPtr display, IntPtr window); + internal static int XUndefineCursor(IntPtr display, IntPtr window) + { + DebugHelper.TraceWriteLine ("XUndefineCursor"); + return _XUndefineCursor(display, window); + } + + [DllImport ("libX11", EntryPoint="XFreeCursor")] + internal extern static int _XFreeCursor(IntPtr display, IntPtr cursor); + internal static int XFreeCursor(IntPtr display, IntPtr cursor) + { + DebugHelper.TraceWriteLine ("XFreeCursor"); + return _XFreeCursor(display, cursor); + } + + [DllImport ("libX11", EntryPoint="XCreateFontCursor")] + internal extern static IntPtr _XCreateFontCursor(IntPtr display, CursorFontShape shape); + internal static IntPtr XCreateFontCursor(IntPtr display, CursorFontShape shape) + { + DebugHelper.TraceWriteLine ("XCreateFontCursor"); + return _XCreateFontCursor(display, shape); + } + + [DllImport ("libX11", EntryPoint="XCreatePixmapCursor")] + internal extern static IntPtr _XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot); + internal static IntPtr XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot) + { + DebugHelper.TraceWriteLine ("XCreatePixmapCursor"); + return _XCreatePixmapCursor(display, source, mask, ref foreground_color, ref background_color, x_hot, y_hot); + } + + [DllImport ("libX11", EntryPoint="XCreatePixmapFromBitmapData")] + internal extern static IntPtr _XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth); + internal static IntPtr XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth) + { + DebugHelper.TraceWriteLine ("XCreatePixmapFromBitmapData"); + return _XCreatePixmapFromBitmapData(display, drawable, data, width, height, fg, bg, depth); + } + + [DllImport ("libX11", EntryPoint="XCreatePixmap")] + internal extern static IntPtr _XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth); + internal static IntPtr XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth) + { + DebugHelper.TraceWriteLine ("XCreatePixmap"); + return _XCreatePixmap(display, d, width, height, depth); + } + + [DllImport ("libX11", EntryPoint="XFreePixmap")] + internal extern static IntPtr _XFreePixmap(IntPtr display, IntPtr pixmap); + internal static IntPtr XFreePixmap(IntPtr display, IntPtr pixmap) + { + DebugHelper.TraceWriteLine ("XFreePixmap"); + return _XFreePixmap(display, pixmap); + } + + [DllImport ("libX11", EntryPoint="XQueryBestCursor")] + internal extern static int _XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height); + internal static int XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height) + { + DebugHelper.TraceWriteLine ("XQueryBestCursor"); + return _XQueryBestCursor(display, drawable, width, height, out best_width, out best_height); + } + + [DllImport ("libX11", EntryPoint="XQueryExtension")] + internal extern static int _XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error); + internal static int XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error) + { + DebugHelper.TraceWriteLine ("XQueryExtension"); + return _XQueryExtension(display, extension_name, ref major, ref first_event, ref first_error); + } + + [DllImport ("libX11", EntryPoint="XWhitePixel")] + internal extern static IntPtr _XWhitePixel(IntPtr display, int screen_no); + internal static IntPtr XWhitePixel(IntPtr display, int screen_no) + { + DebugHelper.TraceWriteLine ("XWhitePixel"); + return _XWhitePixel(display, screen_no); + } + + [DllImport ("libX11", EntryPoint="XBlackPixel")] + internal extern static IntPtr _XBlackPixel(IntPtr display, int screen_no); + internal static IntPtr XBlackPixel(IntPtr display, int screen_no) + { + DebugHelper.TraceWriteLine ("XBlackPixel"); + return _XBlackPixel(display, screen_no); + } + + [DllImport ("libX11", EntryPoint="XGrabServer")] + internal extern static void _XGrabServer(IntPtr display); + internal static void XGrabServer(IntPtr display) + { + DebugHelper.TraceWriteLine ("XGrabServer"); + _XGrabServer(display); + } + + [DllImport ("libX11", EntryPoint="XUngrabServer")] + internal extern static void _XUngrabServer(IntPtr display); + internal static void XUngrabServer(IntPtr display) + { + DebugHelper.TraceWriteLine ("XUngrabServer"); + _XUngrabServer(display); + } + + [DllImport ("libX11", EntryPoint="XGetWMNormalHints")] + internal extern static void _XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return); + internal static void XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return) + { + DebugHelper.TraceWriteLine ("XGetWMNormalHints"); + _XGetWMNormalHints(display, window, ref hints, out supplied_return); + } + + [DllImport ("libX11", EntryPoint="XSetWMNormalHints")] + internal extern static void _XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints); + internal static void XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints) + { + DebugHelper.TraceWriteLine ("XSetWMNormalHints"); + _XSetWMNormalHints(display, window, ref hints); + } + + [DllImport ("libX11", EntryPoint="XSetZoomHints")] + internal extern static void _XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints); + internal static void XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints) + { + DebugHelper.TraceWriteLine ("XSetZoomHints"); + _XSetZoomHints(display, window, ref hints); + } + + [DllImport ("libX11", EntryPoint="XSetWMHints")] + internal extern static void _XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints); + internal static void XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints) + { + DebugHelper.TraceWriteLine ("XSetWMHints"); + _XSetWMHints(display, window, ref wmhints); + } + + [DllImport ("libX11", EntryPoint="XGetIconSizes")] + internal extern static int _XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count); + internal static int XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count) + { + DebugHelper.TraceWriteLine ("XGetIconSizes"); + return _XGetIconSizes(display, window, out size_list, out count); + } + + [DllImport ("libX11", EntryPoint="XSetErrorHandler")] + internal extern static IntPtr _XSetErrorHandler(XErrorHandler error_handler); + internal static IntPtr XSetErrorHandler(XErrorHandler error_handler) + { + DebugHelper.TraceWriteLine ("XSetErrorHandler"); + return _XSetErrorHandler(error_handler); + } + + [DllImport ("libX11", EntryPoint="XGetErrorText")] + internal extern static IntPtr _XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length); + internal static IntPtr XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length) + { + DebugHelper.TraceWriteLine ("XGetErrorText"); + return _XGetErrorText(display, code, buffer, length); + } + + [DllImport ("libX11", EntryPoint="XInitThreads")] + internal extern static int _XInitThreads(); + internal static int XInitThreads() + { + DebugHelper.TraceWriteLine ("XInitThreads"); + return _XInitThreads(); + } + + [DllImport ("libX11", EntryPoint="XConvertSelection")] + internal extern static int _XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time); + internal static int XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time) + { + DebugHelper.TraceWriteLine ("XConvertSelection"); + return _XConvertSelection(display, selection, target, property, requestor, time); + } + + [DllImport ("libX11", EntryPoint="XGetSelectionOwner")] + internal extern static IntPtr _XGetSelectionOwner(IntPtr display, IntPtr selection); + internal static IntPtr XGetSelectionOwner(IntPtr display, IntPtr selection) + { + DebugHelper.TraceWriteLine ("XGetSelectionOwner"); + return _XGetSelectionOwner(display, selection); + } + + [DllImport ("libX11", EntryPoint="XSetSelectionOwner")] + internal extern static int _XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time); + internal static int XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time) + { + DebugHelper.TraceWriteLine ("XSetSelectionOwner"); + return _XSetSelectionOwner(display, selection, owner, time); + } + + [DllImport ("libX11", EntryPoint="XSetPlaneMask")] + internal extern static int _XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask); + internal static int XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask) + { + DebugHelper.TraceWriteLine ("XSetPlaneMask"); + return _XSetPlaneMask(display, gc, mask); + } + + [DllImport ("libX11", EntryPoint="XSetForeground")] + internal extern static int _XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground); + internal static int XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground) + { + DebugHelper.TraceWriteLine ("XSetForeground"); + return _XSetForeground(display, gc, foreground); + } + + [DllImport ("libX11", EntryPoint="XSetBackground")] + internal extern static int _XSetBackground(IntPtr display, IntPtr gc, UIntPtr background); + internal static int XSetBackground(IntPtr display, IntPtr gc, UIntPtr background) + { + DebugHelper.TraceWriteLine ("XSetBackground"); + return _XSetBackground(display, gc, background); + } + + [DllImport ("libX11", EntryPoint="XBell")] + internal extern static int _XBell(IntPtr display, int percent); + internal static int XBell(IntPtr display, int percent) + { + DebugHelper.TraceWriteLine ("XBell"); + return _XBell(display, percent); + } + + [DllImport ("libX11", EntryPoint="XChangeActivePointerGrab")] + internal extern static int _XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time); + internal static int XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time) + { + DebugHelper.TraceWriteLine ("XChangeActivePointerGrab"); + return _XChangeActivePointerGrab (display, event_mask, cursor, time); + } + + [DllImport ("libX11", EntryPoint="XFilterEvent")] + internal extern static bool _XFilterEvent(ref XEvent xevent, IntPtr window); + internal static bool XFilterEvent(ref XEvent xevent, IntPtr window) + { + DebugHelper.TraceWriteLine ("XFilterEvent"); + return _XFilterEvent(ref xevent, window); + } + + [DllImport ("libX11", EntryPoint="XkbSetDetectableAutoRepeat")] + internal extern static void _XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported); + internal static void XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported) + { + DebugHelper.TraceWriteLine ("XkbSetDetectableAutoRepeat"); + _XkbSetDetectableAutoRepeat (display, detectable, supported); + } + + [DllImport ("libX11", EntryPoint="XPeekEvent")] + internal extern static void _XPeekEvent (IntPtr display, ref XEvent xevent); + internal static void XPeekEvent (IntPtr display, ref XEvent xevent) + { + DebugHelper.TraceWriteLine ("XPeekEvent"); + _XPeekEvent (display, ref xevent); + } + + [DllImport ("libX11", EntryPoint="XIfEvent")] + internal extern static void _XIfEvent (IntPtr display, ref XEvent xevent, Delegate event_predicate, IntPtr arg); + internal static void XIfEvent (IntPtr display, ref XEvent xevent, Delegate event_predicate, IntPtr arg) + { + DebugHelper.TraceWriteLine ("XIfEvent"); + _XIfEvent (display, ref xevent, event_predicate, arg); + } +#endregion + +#region Xinerama imports + [DllImport ("libXinerama", EntryPoint="XineramaQueryScreens")] + extern static IntPtr _XineramaQueryScreens (IntPtr display, out int number); + internal static IntPtr XineramaQueryScreens (IntPtr display, out int number) + { + DebugHelper.TraceWriteLine ("XineramaQueryScreens"); + return _XineramaQueryScreens (display, out number); + } + + [DllImport ("libXinerama", EntryPoint="XineramaIsActive")] + extern static bool _XineramaIsActive (IntPtr display); + static bool XineramaNotInstalled; + + internal static bool XineramaIsActive (IntPtr display) + { + DebugHelper.TraceWriteLine ("XineramaIsActive"); + + if (XineramaNotInstalled) + return false; + try { + return _XineramaIsActive (display); + } catch (DllNotFoundException) { + // Xinerama isn't installed + XineramaNotInstalled = true; + return false; + } + } +#endregion + +#else //no TRACE defined + +#region Xcursor imports + [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadCursor")] + internal extern static IntPtr XcursorLibraryLoadCursor (IntPtr display, [MarshalAs (UnmanagedType.LPStr)] string name); + + [DllImport ("libXcursor", EntryPoint = "XcursorLibraryLoadImages")] + internal extern static IntPtr XcursorLibraryLoadImages ([MarshalAs (UnmanagedType.LPStr)] string file, IntPtr theme, int size); + + [DllImport ("libXcursor", EntryPoint = "XcursorImagesDestroy")] + internal extern static void XcursorImagesDestroy (IntPtr images); + + [DllImport ("libXcursor", EntryPoint = "XcursorGetDefaultSize")] + internal extern static int XcursorGetDefaultSize (IntPtr display); + + [DllImport ("libXcursor", EntryPoint = "XcursorImageLoadCursor")] + internal extern static IntPtr XcursorImageLoadCursor (IntPtr display, IntPtr image); + + [DllImport ("libXcursor", EntryPoint = "XcursorGetTheme")] + internal extern static IntPtr XcursorGetTheme (IntPtr display); +#endregion + #region X11 Imports + [DllImport ("libX11", EntryPoint="XOpenDisplay")] + internal extern static IntPtr XOpenDisplay(IntPtr display); + [DllImport ("libX11", EntryPoint="XCloseDisplay")] + internal extern static int XCloseDisplay(IntPtr display); + [DllImport ("libX11", EntryPoint="XSynchronize")] + internal extern static IntPtr XSynchronize(IntPtr display, bool onoff); + + [DllImport ("libX11", EntryPoint="XCreateWindow")] + internal extern static IntPtr XCreateWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, int depth, int xclass, IntPtr visual, UIntPtr valuemask, ref XSetWindowAttributes attributes); + + [DllImport ("libX11", EntryPoint="XCreateSimpleWindow")] + internal extern static IntPtr XCreateSimpleWindow(IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, UIntPtr border, UIntPtr background); + + [DllImport ("libX11", EntryPoint="XMapWindow")] + internal extern static int XMapWindow(IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XMapRaised")] + internal extern static int XMapRaised(IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XUnmapWindow")] + internal extern static int XUnmapWindow(IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XMapSubwindows")] + internal extern static int XMapSubindows(IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XUnmapSubwindows")] + internal extern static int XUnmapSubwindows(IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XRootWindow")] + internal extern static IntPtr XRootWindow(IntPtr display, int screen_number); + + [DllImport ("libX11", EntryPoint="XNextEvent")] + internal extern static IntPtr XNextEvent(IntPtr display, ref XEvent xevent); + + [DllImport ("libX11", EntryPoint="XConnectionNumber")] + internal extern static int XConnectionNumber (IntPtr display); + + [DllImport ("libX11", EntryPoint="XPending")] + internal extern static int XPending (IntPtr display); + + [DllImport ("libX11", EntryPoint="XSelectInput")] + internal extern static IntPtr XSelectInput(IntPtr display, IntPtr window, IntPtr mask); + + [DllImport ("libX11", EntryPoint="XDestroyWindow")] + internal extern static int XDestroyWindow(IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XReparentWindow")] + internal extern static int XReparentWindow(IntPtr display, IntPtr window, IntPtr parent, int x, int y); + + [DllImport ("libX11", EntryPoint="XMoveResizeWindow")] + extern static int XMoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height); + internal static int MoveResizeWindow(IntPtr display, IntPtr window, int x, int y, int width, int height) + { + int ret = XMoveResizeWindow (display, window, x, y, width, height); + Keyboard.MoveCurrentCaretPos (); + return ret; + } + + [DllImport ("libX11", EntryPoint="XResizeWindow")] + internal extern static int XResizeWindow(IntPtr display, IntPtr window, int width, int height); + + [DllImport ("libX11", EntryPoint="XGetWindowAttributes")] + internal extern static int XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes); + + [DllImport ("libX11", EntryPoint="XFlush")] + internal extern static int XFlush(IntPtr display); + + [DllImport ("libX11", EntryPoint="XSetWMName")] + internal extern static int XSetWMName(IntPtr display, IntPtr window, ref XTextProperty text_prop); + + [DllImport ("libX11", EntryPoint="XStoreName")] + internal extern static int XStoreName(IntPtr display, IntPtr window, string window_name); + + [DllImport ("libX11", EntryPoint="XFetchName")] + internal extern static int XFetchName(IntPtr display, IntPtr window, ref IntPtr window_name); + + [DllImport ("libX11", EntryPoint="XSendEvent")] + internal extern static int XSendEvent(IntPtr display, IntPtr window, bool propagate, IntPtr event_mask, ref XEvent send_event); + + [DllImport ("libX11", EntryPoint="XQueryTree")] + internal extern static int XQueryTree(IntPtr display, IntPtr window, out IntPtr root_return, out IntPtr parent_return, out IntPtr children_return, out int nchildren_return); + + [DllImport ("libX11", EntryPoint="XFree")] + internal extern static int XFree(IntPtr data); + + [DllImport ("libX11", EntryPoint="XRaiseWindow")] + internal extern static int XRaiseWindow(IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XLowerWindow")] + internal extern static uint XLowerWindow(IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XConfigureWindow")] + internal extern static uint XConfigureWindow(IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values); + + [DllImport ("libX11", EntryPoint="XInternAtom")] + internal extern static IntPtr XInternAtom(IntPtr display, string atom_name, bool only_if_exists); + + [DllImport ("libX11", EntryPoint="XInternAtoms")] + internal extern static int XInternAtoms(IntPtr display, string[] atom_names, int atom_count, bool only_if_exists, IntPtr[] atoms); + + [DllImport ("libX11", EntryPoint="XSetWMProtocols")] + internal extern static int XSetWMProtocols(IntPtr display, IntPtr window, IntPtr[] protocols, int count); + + [DllImport ("libX11", EntryPoint="XGrabPointer")] + internal extern static int XGrabPointer(IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, IntPtr cursor, IntPtr timestamp); + + [DllImport ("libX11", EntryPoint="XUngrabPointer")] + internal extern static int XUngrabPointer(IntPtr display, IntPtr timestamp); + + [DllImport ("libX11", EntryPoint="XQueryPointer")] + internal extern static bool XQueryPointer(IntPtr display, IntPtr window, out IntPtr root, out IntPtr child, out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons); + + [DllImport ("libX11", EntryPoint="XTranslateCoordinates")] + internal extern static bool XTranslateCoordinates (IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return); + + [DllImport ("libX11", EntryPoint="XGetGeometry")] + internal extern static bool XGetGeometry(IntPtr display, IntPtr window, out IntPtr root, out int x, out int y, out int width, out int height, out int border_width, out int depth); + + [DllImport ("libX11", EntryPoint="XGetGeometry")] + internal extern static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, out int width, out int height, IntPtr border_width, IntPtr depth); + + [DllImport ("libX11", EntryPoint="XGetGeometry")] + internal extern static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, out int x, out int y, IntPtr width, IntPtr height, IntPtr border_width, IntPtr depth); + + [DllImport ("libX11", EntryPoint="XGetGeometry")] + internal extern static bool XGetGeometry(IntPtr display, IntPtr window, IntPtr root, IntPtr x, IntPtr y, out int width, out int height, IntPtr border_width, IntPtr depth); + + [DllImport ("libX11", EntryPoint="XWarpPointer")] + internal extern static uint XWarpPointer(IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, uint src_width, uint src_height, int dest_x, int dest_y); + + [DllImport ("libX11", EntryPoint="XClearWindow")] + internal extern static int XClearWindow(IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XClearArea")] + internal extern static int XClearArea(IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures); + + // Colormaps + [DllImport ("libX11", EntryPoint="XDefaultScreenOfDisplay")] + internal extern static IntPtr XDefaultScreenOfDisplay(IntPtr display); + + [DllImport ("libX11", EntryPoint="XScreenNumberOfScreen")] + internal extern static int XScreenNumberOfScreen(IntPtr display, IntPtr Screen); + + [DllImport ("libX11", EntryPoint="XDefaultVisual")] + internal extern static IntPtr XDefaultVisual(IntPtr display, int screen_number); + + [DllImport ("libX11", EntryPoint="XDefaultDepth")] + internal extern static uint XDefaultDepth(IntPtr display, int screen_number); + + [DllImport ("libX11", EntryPoint="XDefaultScreen")] + internal extern static int XDefaultScreen(IntPtr display); + + [DllImport ("libX11", EntryPoint="XDefaultColormap")] + internal extern static IntPtr XDefaultColormap(IntPtr display, int screen_number); + + [DllImport ("libX11", EntryPoint="XLookupColor")] + internal extern static int XLookupColor(IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color); + + [DllImport ("libX11", EntryPoint="XAllocColor")] + internal extern static int XAllocColor(IntPtr display, IntPtr Colormap, ref XColor colorcell_def); + + [DllImport ("libX11", EntryPoint="XSetTransientForHint")] + internal extern static int XSetTransientForHint(IntPtr display, IntPtr window, IntPtr prop_window); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref MotifWmHints data, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref uint value, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, ref IntPtr value, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, uint[] data, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, int[] data, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr[] data, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, IntPtr atoms, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty", CharSet=CharSet.Ansi)] + internal extern static int XChangeProperty(IntPtr display, IntPtr window, IntPtr property, IntPtr type, int format, PropertyMode mode, string text, int text_length); + + [DllImport ("libX11", EntryPoint="XDeleteProperty")] + internal extern static int XDeleteProperty(IntPtr display, IntPtr window, IntPtr property); + + // Drawing + [DllImport ("libX11", EntryPoint="XCreateGC")] + internal extern static IntPtr XCreateGC(IntPtr display, IntPtr window, IntPtr valuemask, ref XGCValues values); + + [DllImport ("libX11", EntryPoint="XFreeGC")] + internal extern static int XFreeGC(IntPtr display, IntPtr gc); + + [DllImport ("libX11", EntryPoint="XSetFunction")] + internal extern static int XSetFunction(IntPtr display, IntPtr gc, GXFunction function); + + [DllImport ("libX11", EntryPoint="XSetLineAttributes")] + internal extern static int XSetLineAttributes(IntPtr display, IntPtr gc, int line_width, GCLineStyle line_style, GCCapStyle cap_style, GCJoinStyle join_style); + + [DllImport ("libX11", EntryPoint="XDrawLine")] + internal extern static int XDrawLine(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2); + + [DllImport ("libX11", EntryPoint="XDrawRectangle")] + internal extern static int XDrawRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height); + + [DllImport ("libX11", EntryPoint="XFillRectangle")] + internal extern static int XFillRectangle(IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height); + + [DllImport ("libX11", EntryPoint="XSetWindowBackground")] + internal extern static int XSetWindowBackground(IntPtr display, IntPtr window, IntPtr background); + + [DllImport ("libX11", EntryPoint="XCopyArea")] + internal extern static int XCopyArea(IntPtr display, IntPtr src, IntPtr dest, IntPtr gc, int src_x, int src_y, int width, int height, int dest_x, int dest_y); + + [DllImport ("libX11", EntryPoint="XGetWindowProperty")] + internal extern static int XGetWindowProperty(IntPtr display, IntPtr window, IntPtr atom, IntPtr long_offset, IntPtr long_length, bool delete, IntPtr req_type, out IntPtr actual_type, out int actual_format, out IntPtr nitems, out IntPtr bytes_after, ref IntPtr prop); + + [DllImport ("libX11", EntryPoint="XSetInputFocus")] + internal extern static int XSetInputFocus(IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time); + + [DllImport ("libX11", EntryPoint="XIconifyWindow")] + internal extern static int XIconifyWindow(IntPtr display, IntPtr window, int screen_number); + + [DllImport ("libX11", EntryPoint="XDefineCursor")] + internal extern static int XDefineCursor(IntPtr display, IntPtr window, IntPtr cursor); + + [DllImport ("libX11", EntryPoint="XUndefineCursor")] + internal extern static int XUndefineCursor(IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XFreeCursor")] + internal extern static int XFreeCursor(IntPtr display, IntPtr cursor); + + [DllImport ("libX11", EntryPoint="XCreateFontCursor")] + internal extern static IntPtr XCreateFontCursor(IntPtr display, CursorFontShape shape); + + [DllImport ("libX11", EntryPoint="XCreatePixmapCursor")] + internal extern static IntPtr XCreatePixmapCursor(IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot); + + [DllImport ("libX11", EntryPoint="XCreatePixmapFromBitmapData")] + internal extern static IntPtr XCreatePixmapFromBitmapData(IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth); + + [DllImport ("libX11", EntryPoint="XCreatePixmap")] + internal extern static IntPtr XCreatePixmap(IntPtr display, IntPtr d, int width, int height, int depth); + + [DllImport ("libX11", EntryPoint="XFreePixmap")] + internal extern static IntPtr XFreePixmap(IntPtr display, IntPtr pixmap); + + [DllImport ("libX11", EntryPoint="XQueryBestCursor")] + internal extern static int XQueryBestCursor(IntPtr display, IntPtr drawable, int width, int height, out int best_width, out int best_height); + + [DllImport ("libX11", EntryPoint="XQueryExtension")] + internal extern static int XQueryExtension(IntPtr display, string extension_name, ref int major, ref int first_event, ref int first_error); + + [DllImport ("libX11", EntryPoint="XWhitePixel")] + internal extern static IntPtr XWhitePixel(IntPtr display, int screen_no); + + [DllImport ("libX11", EntryPoint="XBlackPixel")] + internal extern static IntPtr XBlackPixel(IntPtr display, int screen_no); + + [DllImport ("libX11", EntryPoint="XGrabServer")] + internal extern static void XGrabServer(IntPtr display); + + [DllImport ("libX11", EntryPoint="XUngrabServer")] + internal extern static void XUngrabServer(IntPtr display); + + [DllImport ("libX11", EntryPoint="XGetWMNormalHints")] + internal extern static void XGetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints, out IntPtr supplied_return); + + [DllImport ("libX11", EntryPoint="XSetWMNormalHints")] + internal extern static void XSetWMNormalHints(IntPtr display, IntPtr window, ref XSizeHints hints); + + [DllImport ("libX11", EntryPoint="XSetZoomHints")] + internal extern static void XSetZoomHints(IntPtr display, IntPtr window, ref XSizeHints hints); + + [DllImport ("libX11", EntryPoint="XSetWMHints")] + internal extern static void XSetWMHints(IntPtr display, IntPtr window, ref XWMHints wmhints); + + [DllImport ("libX11", EntryPoint="XGetIconSizes")] + internal extern static int XGetIconSizes(IntPtr display, IntPtr window, out IntPtr size_list, out int count); + + [DllImport ("libX11", EntryPoint="XSetErrorHandler")] + internal extern static IntPtr XSetErrorHandler(XErrorHandler error_handler); + + [DllImport ("libX11", EntryPoint="XGetErrorText")] + internal extern static IntPtr XGetErrorText(IntPtr display, byte code, StringBuilder buffer, int length); + + [DllImport ("libX11", EntryPoint="XInitThreads")] + internal extern static int XInitThreads(); + + [DllImport ("libX11", EntryPoint="XConvertSelection")] + internal extern static int XConvertSelection(IntPtr display, IntPtr selection, IntPtr target, IntPtr property, IntPtr requestor, IntPtr time); + + [DllImport ("libX11", EntryPoint="XGetSelectionOwner")] + internal extern static IntPtr XGetSelectionOwner(IntPtr display, IntPtr selection); + + [DllImport ("libX11", EntryPoint="XSetSelectionOwner")] + internal extern static int XSetSelectionOwner(IntPtr display, IntPtr selection, IntPtr owner, IntPtr time); + + [DllImport ("libX11", EntryPoint="XSetPlaneMask")] + internal extern static int XSetPlaneMask(IntPtr display, IntPtr gc, IntPtr mask); + + [DllImport ("libX11", EntryPoint="XSetForeground")] + internal extern static int XSetForeground(IntPtr display, IntPtr gc, UIntPtr foreground); + + [DllImport ("libX11", EntryPoint="XSetBackground")] + internal extern static int XSetBackground(IntPtr display, IntPtr gc, UIntPtr background); + + [DllImport ("libX11", EntryPoint="XBell")] + internal extern static int XBell(IntPtr display, int percent); + + [DllImport ("libX11", EntryPoint="XChangeActivePointerGrab")] + internal extern static int XChangeActivePointerGrab (IntPtr display, EventMask event_mask, IntPtr cursor, IntPtr time); + + [DllImport ("libX11", EntryPoint="XFilterEvent")] + internal extern static bool XFilterEvent(ref XEvent xevent, IntPtr window); + + [DllImport ("libX11", EntryPoint="XkbSetDetectableAutoRepeat")] + internal extern static void XkbSetDetectableAutoRepeat (IntPtr display, bool detectable, IntPtr supported); + + [DllImport ("libX11", EntryPoint="XPeekEvent")] + internal extern static void XPeekEvent (IntPtr display, ref XEvent xevent); + + [DllImport ("libX11", EntryPoint="XIfEvent")] + internal extern static void XIfEvent (IntPtr display, ref XEvent xevent, Delegate event_predicate, IntPtr arg); + + [DllImport ("libX11", EntryPoint="XGetInputFocus")] + internal extern static void XGetInputFocus (IntPtr display, out IntPtr focus, out IntPtr revert_to); + #endregion +#region Gtk/Gdk imports + [DllImport("libgdk-x11-2.0")] + internal extern static IntPtr gdk_atom_intern (string atomName, bool onlyIfExists); + + [DllImport("libgtk-x11-2.0")] + internal extern static IntPtr gtk_clipboard_get (IntPtr atom); + + [DllImport("libgtk-x11-2.0")] + internal extern static void gtk_clipboard_store (IntPtr clipboard); + + [DllImport("libgtk-x11-2.0")] + internal extern static void gtk_clipboard_set_text (IntPtr clipboard, string text, int len); +#endregion + + +#region Xinerama imports + [DllImport ("libXinerama")] + internal extern static IntPtr XineramaQueryScreens (IntPtr display, out int number); + + [DllImport ("libXinerama", EntryPoint = "XineramaIsActive")] + extern static bool _XineramaIsActive (IntPtr display); + static bool XineramaNotInstalled; + + internal static bool XineramaIsActive (IntPtr display) + { + if (XineramaNotInstalled) + return false; + try { + return _XineramaIsActive (display); + } catch (DllNotFoundException) { + // Xinerama isn't installed + XineramaNotInstalled = true; + return false; + } + } +#endregion + +#endif + } +} diff --git a/source/ShiftUI/Internal/XplatUIX11GTK.cs b/source/ShiftUI/Internal/XplatUIX11GTK.cs new file mode 100644 index 0000000..03ea185 --- /dev/null +++ b/source/ShiftUI/Internal/XplatUIX11GTK.cs @@ -0,0 +1,4634 @@ +// 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) 2004-2006 Novell, Inc. +// +// Authors: +// Peter Bartok [email protected] +// Alexander Olk [email protected] +// +// + +// NOTE: +// This driver understands the following environment variables: (Set the var to enable feature) +// +// MONO_XEXCEPTIONS = throw an exception when a X11 error is encountered; +// by default a message is displayed but execution continues +// +// MONO_XSYNC = perform all X11 commands synchronous; this is slower but +// helps in debugging errors +// + +// NOT COMPLETE - WORK IN PROGRESS + +// One feature of the driver is, that PaintEventstart returns a graphics context created from a offscreen drawable (pixmap) + +// define to log Window handles and relationships to stdout +#undef DriverDebug + +// Extra detailed debug +#undef DriverDebugExtra + +using System; +using System.ComponentModel; +using System.Collections; +using System.Diagnostics; +using System.Drawing; +using System.Drawing.Drawing2D; +using System.Drawing.Imaging; +using System.IO; +using System.Net; +using System.Net.Sockets; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; + +// Only do the poll when building with mono for now +#if __MonoCS__ +using Mono.Unix.Native; +#endif + +/// X11 Version +namespace ShiftUI { + internal class XplatUIX11GTK : XplatUIDriver { + + internal enum GdkWindowClass { + GDK_INPUT_OUTPUT, + GDK_INPUT_ONLY + } + + internal enum GdkWindowType { + GDK_WINDOW_ROOT, + GDK_WINDOW_TOPLEVEL, + GDK_WINDOW_CHILD, + GDK_WINDOW_DIALOG, + GDK_WINDOW_TEMP, + GDK_WINDOW_FOREIGN + } + + internal enum GdkWindowHints { + GDK_HINT_POS = 1 << 0, + GDK_HINT_MIN_SIZE = 1 << 1, + GDK_HINT_MAX_SIZE = 1 << 2, + GDK_HINT_BASE_SIZE = 1 << 3, + GDK_HINT_ASPECT = 1 << 4, + GDK_HINT_RESIZE_INC = 1 << 5, + GDK_HINT_WIN_GRAVITY = 1 << 6, + GDK_HINT_USER_POS = 1 << 7, + GDK_HINT_USER_SIZE = 1 << 8 + } + + internal enum GdkGravity { + GDK_GRAVITY_NORTH_WEST = 1, + GDK_GRAVITY_NORTH, + GDK_GRAVITY_NORTH_EAST, + GDK_GRAVITY_WEST, + GDK_GRAVITY_CENTER, + GDK_GRAVITY_EAST, + GDK_GRAVITY_SOUTH_WEST, + GDK_GRAVITY_SOUTH, + GDK_GRAVITY_SOUTH_EAST, + GDK_GRAVITY_STATIC + } + + internal enum GdkWindowEdge { + GDK_WINDOW_EDGE_NORTH_WEST, + GDK_WINDOW_EDGE_NORTH, + GDK_WINDOW_EDGE_NORTH_EAST, + GDK_WINDOW_EDGE_WEST, + GDK_WINDOW_EDGE_EAST, + GDK_WINDOW_EDGE_SOUTH_WEST, + GDK_WINDOW_EDGE_SOUTH, + GDK_WINDOW_EDGE_SOUTH_EAST + } + + internal enum GdkWindowTypeHint { + GDK_WINDOW_TYPE_HINT_NORMAL, + GDK_WINDOW_TYPE_HINT_DIALOG, + GDK_WINDOW_TYPE_HINT_MENU, + GDK_WINDOW_TYPE_HINT_TOOLBAR, + GDK_WINDOW_TYPE_HINT_SPLASHSCREEN, + GDK_WINDOW_TYPE_HINT_UTILITY, + GDK_WINDOW_TYPE_HINT_DOCK, + GDK_WINDOW_TYPE_HINT_DESKTOP + } + + internal enum GdkWindowAttributesType { + GDK_WA_TITLE = 1 << 1, + GDK_WA_X = 1 << 2, + GDK_WA_Y = 1 << 3, + GDK_WA_CURSOR = 1 << 4, + GDK_WA_COLORMAP = 1 << 5, + GDK_WA_VISUAL = 1 << 6, + GDK_WA_WMCLASS = 1 << 7, + GDK_WA_NOREDIR = 1 << 8 + } + + internal enum GdkEventMask { + GDK_EXPOSURE_MASK = 1 << 1, + GDK_POINTER_MOTION_MASK = 1 << 2, + GDK_POINTER_MOTION_HINT_MASK = 1 << 3, + GDK_BUTTON_MOTION_MASK = 1 << 4, + GDK_BUTTON1_MOTION_MASK = 1 << 5, + GDK_BUTTON2_MOTION_MASK = 1 << 6, + GDK_BUTTON3_MOTION_MASK = 1 << 7, + GDK_BUTTON_PRESS_MASK = 1 << 8, + GDK_BUTTON_RELEASE_MASK = 1 << 9, + GDK_KEY_PRESS_MASK = 1 << 10, + GDK_KEY_RELEASE_MASK = 1 << 11, + GDK_ENTER_NOTIFY_MASK = 1 << 12, + GDK_LEAVE_NOTIFY_MASK = 1 << 13, + GDK_FOCUS_CHANGE_MASK = 1 << 14, + GDK_STRUCTURE_MASK = 1 << 15, + GDK_PROPERTY_CHANGE_MASK = 1 << 16, + GDK_VISIBILITY_NOTIFY_MASK = 1 << 17, + GDK_PROXIMITY_IN_MASK = 1 << 18, + GDK_PROXIMITY_OUT_MASK = 1 << 19, + GDK_SUBSTRUCTURE_MASK = 1 << 20, + GDK_SCROLL_MASK = 1 << 21, + GDK_ALL_EVENTS_MASK = 0x3FFFFE + } + + internal enum GdkEventType { + GDK_NOTHING = -1, + GDK_DELETE = 0, + GDK_DESTROY = 1, + GDK_EXPOSE = 2, + GDK_MOTION_NOTIFY = 3, + GDK_BUTTON_PRESS = 4, + GDK_2BUTTON_PRESS = 5, + GDK_3BUTTON_PRESS = 6, + GDK_BUTTON_RELEASE = 7, + GDK_KEY_PRESS = 8, + GDK_KEY_RELEASE = 9, + GDK_ENTER_NOTIFY = 10, + GDK_LEAVE_NOTIFY = 11, + GDK_FOCUS_CHANGE = 12, + GDK_CONFIGURE = 13, + GDK_MAP = 14, + GDK_UNMAP = 15, + GDK_PROPERTY_NOTIFY = 16, + GDK_SELECTION_CLEAR = 17, + GDK_SELECTION_REQUEST = 18, + GDK_SELECTION_NOTIFY = 19, + GDK_PROXIMITY_IN = 20, + GDK_PROXIMITY_OUT = 21, + GDK_DRAG_ENTER = 22, + GDK_DRAG_LEAVE = 23, + GDK_DRAG_MOTION = 24, + GDK_DRAG_STATUS = 25, + GDK_DROP_START = 26, + GDK_DROP_FINISHED = 27, + GDK_CLIENT_EVENT = 28, + GDK_VISIBILITY_NOTIFY = 29, + GDK_NO_EXPOSE = 30, + GDK_SCROLL = 31, + GDK_WINDOW_STATE = 32, + GDK_SETTING = 33, + GDK_OWNER_CHANGE = 34, + GDK_GRAB_BROKEN = 35 + } + + internal enum GdkWMDecoration { + GDK_DECOR_ALL = 1 << 0, + GDK_DECOR_BORDER = 1 << 1, + GDK_DECOR_RESIZEH = 1 << 2, + GDK_DECOR_TITLE = 1 << 3, + GDK_DECOR_MENU = 1 << 4, + GDK_DECOR_MINIMIZE = 1 << 5, + GDK_DECOR_MAXIMIZE = 1 << 6 + } + + internal enum GdkWMFunction { + GDK_FUNC_ALL = 1 << 0, + GDK_FUNC_RESIZE = 1 << 1, + GDK_FUNC_MOVE = 1 << 2, + GDK_FUNC_MINIMIZE = 1 << 3, + GDK_FUNC_MAXIMIZE = 1 << 4, + GDK_FUNC_CLOSE = 1 << 5 + } + + internal enum GdkCursorType { + GDK_X_CURSOR = 0, + GDK_ARROW = 2, + GDK_BASED_ARROW_DOWN = 4, + GDK_BASED_ARROW_UP = 6, + GDK_BOAT = 8, + GDK_BOGOSITY = 10, + GDK_BOTTOM_LEFT_CORNER = 12, + GDK_BOTTOM_RIGHT_CORNER = 14, + GDK_BOTTOM_SIDE = 16, + GDK_BOTTOM_TEE = 18, + GDK_BOX_SPIRAL = 20, + GDK_CENTER_PTR = 22, + GDK_CIRCLE = 24, + GDK_CLOCK = 26, + GDK_COFFEE_MUG = 28, + GDK_CROSS = 30, + GDK_CROSS_REVERSE = 32, + GDK_CROSSHAIR = 34, + GDK_DIAMOND_CROSS = 36, + GDK_DOT = 38, + GDK_DOTBOX = 40, + GDK_DOUBLE_ARROW = 42, + GDK_DRAFT_LARGE = 44, + GDK_DRAFT_SMALL = 46, + GDK_DRAPED_BOX = 48, + GDK_EXCHANGE = 50, + GDK_FLEUR = 52, + GDK_GOBBLER = 54, + GDK_GUMBY = 56, + GDK_HAND1 = 58, + GDK_HAND2 = 60, + GDK_HEART = 62, + GDK_ICON = 64, + GDK_IRON_CROSS = 66, + GDK_LEFT_PTR = 68, + GDK_LEFT_SIDE = 70, + GDK_LEFT_TEE = 72, + GDK_LEFTBUTTON = 74, + GDK_LL_ANGLE = 76, + GDK_LR_ANGLE = 78, + GDK_MAN = 80, + GDK_MIDDLEBUTTON = 82, + GDK_MOUSE = 84, + GDK_PENCIL = 86, + GDK_PIRATE = 88, + GDK_PLUS = 90, + GDK_QUESTION_ARROW = 92, + GDK_RIGHT_PTR = 94, + GDK_RIGHT_SIDE = 96, + GDK_RIGHT_TEE = 98, + GDK_RIGHTBUTTON = 100, + GDK_RTL_LOGO = 102, + GDK_SAILBOAT = 104, + GDK_SB_DOWN_ARROW = 106, + GDK_SB_H_DOUBLE_ARROW = 108, + GDK_SB_LEFT_ARROW = 110, + GDK_SB_RIGHT_ARROW = 112, + GDK_SB_UP_ARROW = 114, + GDK_SB_V_DOUBLE_ARROW = 116, + GDK_SHUTTLE = 118, + GDK_SIZING = 120, + GDK_SPIDER = 122, + GDK_SPRAYCAN = 124, + GDK_STAR = 126, + GDK_TARGET = 128, + GDK_TCROSS = 130, + GDK_TOP_LEFT_ARROW = 132, + GDK_TOP_LEFT_CORNER = 134, + GDK_TOP_RIGHT_CORNER = 136, + GDK_TOP_SIDE = 138, + GDK_TOP_TEE = 140, + GDK_TREK = 142, + GDK_UL_ANGLE = 144, + GDK_UMBRELLA = 146, + GDK_UR_ANGLE = 148, + GDK_WATCH = 150, + GDK_XTERM = 152, + GDK_LAST_CURSOR, + GDK_CURSOR_IS_PIXMAP = -1 + } + + internal enum GdkPropMode { + GDK_PROP_MODE_REPLACE, + GDK_PROP_MODE_PREPEND, + GDK_PROP_MODE_APPEND + } + + [StructLayout (LayoutKind.Sequential)] + internal struct GdkGeometry { + internal int min_width; + internal int min_height; + internal int max_width; + internal int max_height; + internal int base_width; + internal int base_height; + internal int width_inc; + internal int height_inc; + internal double min_aspect; + internal double max_aspect; + internal GdkGravity win_gravity; + } + + [StructLayout (LayoutKind.Sequential)] + internal struct GdkWindowAttr { + internal string title; + internal int event_mask; + internal int x, y; + internal int width; + internal int height; + internal GdkWindowClass wclass; + internal IntPtr visual; + internal IntPtr colormap; + internal GdkWindowType window_type; + internal IntPtr cursor; + internal string wmclass_name; + internal string wmclass_class; + internal bool override_redirect; + } + + #region Local Variables + // General + static volatile XplatUIX11GTK Instance; + private static int RefCount; + private static object XlibLock; // Our locking object + + // General X11 + private static IntPtr DisplayHandle; // X11 handle to display + private static IntPtr GdkDisplayHandle; // gdk handle to display + private static int ScreenNo; // Screen number used + private static IntPtr GdkScreen; + private static IntPtr DefaultColormap; // Colormap for screen + private static IntPtr GdkDefaultColormap; // Gdk Colormap for screen + private static IntPtr CustomVisual; // Visual for window creation + private static IntPtr GdkCustomVisual; + private static IntPtr CustomColormap; // Colormap for window creation + private static IntPtr GdkCustomColormap; + private static int VisualBestDepth; + private static IntPtr RootWindow; // Handle of the root window for the screen/display + private static IntPtr GdkRootWindow; // Gdk handle of the root window for the screen/display + private static IntPtr FosterParent; // Container to hold child windows until their parent exists + private static IntPtr GdkFosterParent; // Container to hold child windows until their parent exists + private static XErrorHandler ErrorHandler; // Error handler delegate + private static bool ErrorExceptions; // Throw exceptions on X errors + private static bool PostQuitState; // True if we've got an pending exit + + // Clipboard + private static IntPtr ClipMagic = new IntPtr(27051977); + + // Communication + private static int PostAtom; // PostMessage atom + private static int AsyncAtom; // Support for async messages + + // Message Loop + private static XEventQueue MessageQueue; // Holds our queued up events + #if __MonoCS__ // + private static Pollfd[] pollfds; // For watching the X11 socket + #endif // + private static X11Keyboard Keyboard; // + private static X11Dnd Dnd; + private static Socket listen; // + private static Socket wake; // + private static Socket wake_receive; // + private static byte[] network_buffer; // + + + // Focus tracking + private static IntPtr ActiveWindow; // Handle of the active window + private static IntPtr FocusWindow; // Handle of the window with keyboard focus (if any) + + // Modality support + private static Stack ModalWindows; // Stack of our modal windows + + // Systray + private static IntPtr SystrayMgrWindow; // Handle of the Systray Manager window + + // Cursors + private static IntPtr LastCursorWindow; // The last window we set the cursor on + private static IntPtr LastCursorHandle; // The handle that was last set on LastCursorWindow + private static IntPtr OverrideCursorHandle; // The cursor that is set to override any other cursors + + // Caret + private static CaretStruct Caret; // + + // Support for Window Styles + private static int[] NetAtoms; // All atoms we know + + // mouse hover message generation + private static HoverStruct HoverState; // + + // double click message generation + private static ClickStruct ClickPending; // + + // Support for mouse grab + private static GrabStruct Grab; // + + // State + private static Point MousePosition; // Last position of mouse, in screen coords + internal static MouseButtons MouseState; // Last state of mouse buttons + + // Timers + private static ArrayList TimerList; // Holds SWF.Timers + + // 'Constants' + private static int DoubleClickInterval; // msec; max interval between clicks to count as double click + + const GdkEventMask GdkSelectInputMask = GdkEventMask.GDK_BUTTON_PRESS_MASK | + GdkEventMask.GDK_BUTTON_RELEASE_MASK | + GdkEventMask.GDK_KEY_PRESS_MASK | + GdkEventMask.GDK_KEY_RELEASE_MASK | + GdkEventMask.GDK_ENTER_NOTIFY_MASK | + GdkEventMask.GDK_LEAVE_NOTIFY_MASK | + GdkEventMask.GDK_EXPOSURE_MASK | + GdkEventMask.GDK_FOCUS_CHANGE_MASK | + GdkEventMask.GDK_POINTER_MOTION_MASK | + GdkEventMask.GDK_VISIBILITY_NOTIFY_MASK | + GdkEventMask.GDK_SUBSTRUCTURE_MASK | + GdkEventMask.GDK_STRUCTURE_MASK; + + static readonly object lockobj = new object (); + + static Hashtable backing_store = new Hashtable (5); + + #endregion // Local Variables + #region Constructors + private XplatUIX11GTK () + { + Console.WriteLine ("XplatUIX11GTK ctor..."); + // Handle singleton stuff first + RefCount = 0; + + // init gdk + gdk_init_check (IntPtr.Zero, IntPtr.Zero); + + // Now regular initialization + XlibLock = new object (); + MessageQueue = new XEventQueue (); + TimerList = new ArrayList (); + XInitThreads (); + + ErrorExceptions = false; + + // X11 Initialization + SetDisplay (gdk_x11_display_get_xdisplay (gdk_display_get_default ())); + X11DesktopColors.Initialize (); + + // Handle any upcoming errors; we re-set it here, X11DesktopColor stuff might have stolen it (gtk does) + ErrorHandler = new XErrorHandler (HandleError); + XSetErrorHandler (ErrorHandler); + } + #endregion // Constructors + + #region Singleton Specific Code + public static XplatUIX11GTK GetInstance () + { + lock (lockobj) { + if (Instance == null) { + Instance = new XplatUIX11GTK (); + } + RefCount++; + } + return Instance; + } + + public int Reference { + get { + return RefCount; + } + } + #endregion + + #region Internal Properties + internal static IntPtr Display { + get { + return DisplayHandle; + } + + set { + XplatUIX11GTK.GetInstance ().SetDisplay (value); + } + } + + internal static int Screen { + get { + return ScreenNo; + } + + set { + ScreenNo = value; + } + } + + internal static IntPtr RootWindowHandle { + get { + return RootWindow; + } + + set { + RootWindow = value; + } + } + + internal static IntPtr Visual { + get { + return CustomVisual; + } + + set { + CustomVisual = value; + } + } + + internal static IntPtr ColorMap { + get { + return CustomColormap; + } + + set { + CustomColormap = value; + } + } + #endregion + + #region XExceptionClass + internal class XException : ApplicationException { + IntPtr Display; + IntPtr ResourceID; + IntPtr Serial; + XRequest RequestCode; + byte ErrorCode; + byte MinorCode; + + public XException (IntPtr Display, IntPtr ResourceID, IntPtr Serial, byte ErrorCode, XRequest RequestCode, byte MinorCode) + { + this.Display = Display; + this.ResourceID = ResourceID; + this.Serial = Serial; + this.RequestCode = RequestCode; + this.ErrorCode = ErrorCode; + this.MinorCode = MinorCode; + } + + public override string Message { + get { + return GetMessage (Display, ResourceID, Serial, ErrorCode, RequestCode, MinorCode); + } + } + + public static string GetMessage (IntPtr Display, IntPtr ResourceID, IntPtr Serial, byte ErrorCode, XRequest RequestCode, byte MinorCode) + { + StringBuilder sb; + string x_error_text; + string error; + + sb = new StringBuilder (160); + XGetErrorText (Display, ErrorCode, sb, sb.Capacity); + x_error_text = sb.ToString (); + + error = String.Format ("\n Error: {0}\n Request: {1:D} ({2})\n Resource ID: 0x{3:x}\n Serial: {4}", x_error_text, RequestCode, RequestCode, ResourceID.ToInt32 (), Serial); + return error; + } + } + #endregion // XExceptionClass + + #region Internal Methods + // native X display handle + internal void SetDisplay (IntPtr display_handle) + { + if (display_handle != IntPtr.Zero) { + Hwnd hwnd; + + if ((GdkDisplayHandle != IntPtr.Zero) && (GdkFosterParent != IntPtr.Zero)) { + hwnd = Hwnd.ObjectFromHandle (gdk_x11_drawable_get_xid (GdkFosterParent)); + gdk_window_destroy (GdkFosterParent); + hwnd.Dispose (); + } + + if (GdkDisplayHandle != IntPtr.Zero) { + gdk_display_close (GdkDisplayHandle); + } + + DisplayHandle = display_handle; + GdkDisplayHandle = gdk_x11_lookup_xdisplay (display_handle); + + // We need to tell System.Drawing our DisplayHandle. FromHdcInternal has + // been hacked to do this for us. + Graphics.FromHdcInternal (DisplayHandle); + + // Debugging support + if (Environment.GetEnvironmentVariable ("MONO_XSYNC") != null) { + XSynchronize (DisplayHandle, true); + } + + if (Environment.GetEnvironmentVariable ("MONO_XEXCEPTIONS") != null) { + ErrorExceptions = true; + } + + // Generic X11 setup + GdkScreen = gdk_screen_get_default (); + // or gdk_x11_get_default_screen + ScreenNo = gdk_screen_get_number (GdkScreen); + GdkRootWindow = gdk_get_default_root_window (); + RootWindow = gdk_x11_drawable_get_xid (GdkRootWindow); + GdkDefaultColormap = gdk_colormap_get_system (); + DefaultColormap = gdk_x11_colormap_get_xcolormap (GdkDefaultColormap); + + VisualBestDepth = gdk_visual_get_best_depth (); + //Console.WriteLine (VisualBestDepth); + + // Create the foster parent + FosterParent = XCreateSimpleWindow (DisplayHandle, RootWindow, 0, 0, 1, 1, 4, 0, 0); + GdkFosterParent = gdk_window_foreign_new (FosterParent); + + if (GdkFosterParent == IntPtr.Zero) { + Console.WriteLine ("XplatUIX11GTK Constructor failed to create FosterParent"); + } + + hwnd = new Hwnd (); + + hwnd.WholeWindow = FosterParent; + hwnd.ClientWindow = FosterParent; + + // For sleeping on the X11 socket + listen = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); + IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 0); + listen.Bind (ep); + listen.Listen (1); + + // To wake up when a timer is ready + network_buffer = new byte [10]; + + wake = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); + wake.Connect (listen.LocalEndPoint); + wake_receive = listen.Accept (); + + #if __MonoCS__ + pollfds = new Pollfd [2]; + pollfds [0] = new Pollfd (); + pollfds [0].fd = XConnectionNumber (DisplayHandle); + pollfds [0].events = PollEvents.POLLIN; + + pollfds [1] = new Pollfd (); + pollfds [1].fd = wake_receive.Handle.ToInt32 (); + pollfds [1].events = PollEvents.POLLIN; + #endif + + Keyboard = new X11Keyboard (DisplayHandle); + Dnd = new X11Dnd (DisplayHandle); + + PostQuitState = false; + + DoubleClickInterval = 500; + + HoverState.Interval = 500; + HoverState.Timer = new Timer (); + HoverState.Timer.Enabled = false; + HoverState.Timer.Interval = HoverState.Interval; + HoverState.Timer.Tick += new EventHandler (MouseHover); + HoverState.X = -1; + HoverState.Y = -1; + + ActiveWindow = IntPtr.Zero; + FocusWindow = IntPtr.Zero; + ModalWindows = new Stack (3); + + MouseState = MouseButtons.None; + MousePosition = new Point (0, 0); + + Caret.Timer = new Timer (); + Caret.Timer.Interval = 500; // FIXME - where should this number come from? + Caret.Timer.Tick += new EventHandler (CaretCallback); + + SetupAtoms (); + + // Grab atom changes off the root window to catch certain WM events + gdk_window_set_events (GdkRootWindow, (int)GdkEventMask.GDK_PROPERTY_CHANGE_MASK); + + // Handle any upcoming errors + ErrorHandler = new XErrorHandler (HandleError); + XSetErrorHandler (ErrorHandler); + } else { + throw new ArgumentNullException ("Display", "Could not open display (X-Server required. Check your DISPLAY environment variable)"); + } + } + #endregion // Internal Methods + + #region Private Methods + private static void SetupAtoms () + { + NetAtoms = new int [(int)NA.LAST_NET_ATOM]; + + NetAtoms [(int)NA.WM_PROTOCOLS] = XInternAtom (DisplayHandle, "WM_PROTOCOLS", false); + NetAtoms [(int)NA.WM_DELETE_WINDOW] = XInternAtom (DisplayHandle, "WM_DELETE_WINDOW", false); + NetAtoms [(int)NA.WM_TAKE_FOCUS] = XInternAtom (DisplayHandle, "WM_TAKE_FOCUS", false); + + NetAtoms [(int)NA._NET_SUPPORTED] = XInternAtom (DisplayHandle, "_NET_SUPPORTED", false); + NetAtoms [(int)NA._NET_CLIENT_LIST] = XInternAtom (DisplayHandle, "_NET_CLIENT_LIST", false); + NetAtoms [(int)NA._NET_NUMBER_OF_DESKTOPS] = XInternAtom (DisplayHandle, "_NET_NUMBER_OF_DESKTOPS", false); + NetAtoms [(int)NA._NET_DESKTOP_GEOMETRY] = XInternAtom (DisplayHandle, "_NET_DESKTOP_GEOMETRY", false); + NetAtoms [(int)NA._NET_DESKTOP_VIEWPORT] = XInternAtom (DisplayHandle, "_NET_DESKTOP_VIEWPORT", false); + NetAtoms [(int)NA._NET_CURRENT_DESKTOP] = XInternAtom (DisplayHandle, "_NET_CURRENT_DESKTOP", false); + NetAtoms [(int)NA._NET_DESKTOP_NAMES] = XInternAtom (DisplayHandle, "_NET_DESKTOP_NAMES", false); + NetAtoms [(int)NA._NET_ACTIVE_WINDOW] = XInternAtom (DisplayHandle, "_NET_ACTIVE_WINDOW", false); + NetAtoms [(int)NA._NET_WORKAREA] = XInternAtom (DisplayHandle, "_NET_WORKAREA", false); + NetAtoms [(int)NA._NET_SUPPORTING_WM_CHECK] = XInternAtom (DisplayHandle, "_NET_SUPPORTING_WM_CHECK", false); + NetAtoms [(int)NA._NET_VIRTUAL_ROOTS] = XInternAtom (DisplayHandle, "_NET_VIRTUAL_ROOTS", false); + NetAtoms [(int)NA._NET_DESKTOP_LAYOUT] = XInternAtom (DisplayHandle, "_NET_DESKTOP_LAYOUT", false); + NetAtoms [(int)NA._NET_SHOWING_DESKTOP] = XInternAtom (DisplayHandle, "_NET_SHOWING_DESKTOP", false); + + NetAtoms [(int)NA._NET_CLOSE_WINDOW] = XInternAtom (DisplayHandle, "_NET_CLOSE_WINDOW", false); + NetAtoms [(int)NA._NET_MOVERESIZE_WINDOW] = XInternAtom (DisplayHandle, "_NET_MOVERESIZE_WINDOW", false); + NetAtoms [(int)NA._NET_WM_MOVERESIZE] = XInternAtom (DisplayHandle, "_NET_WM_MOVERESIZE", false); + NetAtoms [(int)NA._NET_RESTACK_WINDOW] = XInternAtom (DisplayHandle, "_NET_RESTACK_WINDOW", false); + NetAtoms [(int)NA._NET_REQUEST_FRAME_EXTENTS] = XInternAtom (DisplayHandle, "_NET_REQUEST_FRAME_EXTENTS", false); + + NetAtoms [(int)NA._NET_WM_NAME] = XInternAtom (DisplayHandle, "_NET_WM_NAME", false); + NetAtoms [(int)NA._NET_WM_VISIBLE_NAME] = XInternAtom (DisplayHandle, "_NET_WM_VISIBLE_NAME", false); + NetAtoms [(int)NA._NET_WM_ICON_NAME] = XInternAtom (DisplayHandle, "_NET_WM_ICON_NAME", false); + NetAtoms [(int)NA._NET_WM_VISIBLE_ICON_NAME] = XInternAtom (DisplayHandle, "_NET_WM_VISIBLE_ICON_NAME", false); + NetAtoms [(int)NA._NET_WM_DESKTOP] = XInternAtom (DisplayHandle, "_NET_WM_DESKTOP", false); + NetAtoms [(int)NA._NET_WM_WINDOW_TYPE] = XInternAtom (DisplayHandle, "_NET_WM_WINDOW_TYPE", false); + NetAtoms [(int)NA._NET_WM_STATE] = XInternAtom (DisplayHandle, "_NET_WM_STATE", false); + NetAtoms [(int)NA._NET_WM_ALLOWED_ACTIONS] = XInternAtom (DisplayHandle, "_NET_WM_ALLOWED_ACTIONS", false); + NetAtoms [(int)NA._NET_WM_STRUT] = XInternAtom (DisplayHandle, "_NET_WM_STRUT", false); + NetAtoms [(int)NA._NET_WM_STRUT_PARTIAL] = XInternAtom (DisplayHandle, "_NET_WM_STRUT_PARTIAL", false); + NetAtoms [(int)NA._NET_WM_ICON_GEOMETRY] = XInternAtom (DisplayHandle, "_NET_WM_ICON_GEOMETRY", false); + NetAtoms [(int)NA._NET_WM_ICON] = XInternAtom (DisplayHandle, "_NET_WM_ICON", false); + NetAtoms [(int)NA._NET_WM_PID] = XInternAtom (DisplayHandle, "_NET_WM_PID", false); + NetAtoms [(int)NA._NET_WM_HANDLED_ICONS] = XInternAtom (DisplayHandle, "_NET_WM_HANDLED_ICONS", false); + NetAtoms [(int)NA._NET_WM_USER_TIME] = XInternAtom (DisplayHandle, "_NET_WM_USER_TIME", false); + NetAtoms [(int)NA._NET_FRAME_EXTENTS] = XInternAtom (DisplayHandle, "_NET_FRAME_EXTENTS", false); + + NetAtoms [(int)NA._NET_WM_PING] = XInternAtom (DisplayHandle, "_NET_WM_PING", false); + NetAtoms [(int)NA._NET_WM_SYNC_REQUEST] = XInternAtom (DisplayHandle, "_NET_WM_SYNC_REQUEST", false); + + NetAtoms [(int)NA._NET_SYSTEM_TRAY_S] = XInternAtom (DisplayHandle, "_NET_SYSTEM_TRAY_S" + ScreenNo.ToString (), false); + NetAtoms [(int)NA._NET_SYSTEM_TRAY_OPCODE] = XInternAtom (DisplayHandle, "_NET_SYSTEM_TRAY_OPCODE", false); + NetAtoms [(int)NA._NET_SYSTEM_TRAY_ORIENTATION] = XInternAtom (DisplayHandle, "_NET_SYSTEM_TRAY_ORIENTATION", false); + + NetAtoms [(int)NA._NET_WM_STATE_MAXIMIZED_HORZ] = XInternAtom (DisplayHandle, "_NET_WM_STATE_MAXIMIZED_HORZ", false); + NetAtoms [(int)NA._NET_WM_STATE_MAXIMIZED_VERT] = XInternAtom (DisplayHandle, "_NET_WM_STATE_MAXIMIZED_VERT", false); + NetAtoms [(int)NA._NET_WM_STATE_HIDDEN] = XInternAtom (DisplayHandle, "_NET_WM_STATE_HIDDEN", false); + + NetAtoms [(int)NA._XEMBED] = XInternAtom (DisplayHandle, "_XEMBED", false); + NetAtoms [(int)NA._XEMBED_INFO] = XInternAtom (DisplayHandle, "_XEMBED_INFO", false); + + NetAtoms [(int)NA._MOTIF_WM_HINTS] = XInternAtom (DisplayHandle, "_MOTIF_WM_HINTS", false); + + NetAtoms [(int)NA._NET_WM_STATE_NO_TASKBAR] = XInternAtom (DisplayHandle, "_NET_WM_STATE_NO_TASKBAR", false); + NetAtoms [(int)NA._NET_WM_STATE_ABOVE] = XInternAtom (DisplayHandle, "_NET_WM_STATE_ABOVE", false); + NetAtoms [(int)NA._NET_WM_STATE_MODAL] = XInternAtom (DisplayHandle, "_NET_WM_STATE_MODAL", false); + NetAtoms [(int)NA._NET_WM_CONTEXT_HELP] = XInternAtom (DisplayHandle, "_NET_WM_CONTEXT_HELP", false); + NetAtoms [(int)NA._NET_WM_WINDOW_OPACITY] = XInternAtom (DisplayHandle, "_NET_WM_WINDOW_OPACITY", false); + + // Clipboard support + NetAtoms [(int)NA.CLIPBOARD] = XInternAtom (DisplayHandle, "CLIPBOARD", false); + NetAtoms [(int)NA.DIB] = (int)Atom.XA_PIXMAP; + NetAtoms [(int)NA.OEMTEXT] = XInternAtom (DisplayHandle, "COMPOUND_TEXT", false); + NetAtoms [(int)NA.UNICODETEXT] = XInternAtom (DisplayHandle, "UTF8_STRING", false); + NetAtoms [(int)NA.TARGETS] = XInternAtom (DisplayHandle, "TARGETS", false); + + // Special Atoms + AsyncAtom = XInternAtom (DisplayHandle, "_SWF_AsyncAtom", false); + PostAtom = XInternAtom (DisplayHandle, "_SWF_PostMessageAtom", false); + HoverState.Atom = XInternAtom (DisplayHandle, "_SWF_HoverAtom", false); + } + + private void GetSystrayManagerWindow () + { + gdk_x11_grab_server (); + SystrayMgrWindow = XGetSelectionOwner (DisplayHandle, NetAtoms [(int)NA._NET_SYSTEM_TRAY_S]); + gdk_x11_ungrab_server (); + gdk_display_flush (GdkDisplayHandle); + } + + private void SendNetWMMessage (IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) + { + XEvent xev; + + xev = new XEvent (); + xev.ClientMessageEvent.type = XEventName.ClientMessage; + xev.ClientMessageEvent.send_event = true; + xev.ClientMessageEvent.window = window; + xev.ClientMessageEvent.message_type = message_type; + xev.ClientMessageEvent.format = 32; + xev.ClientMessageEvent.ptr1 = l0; + xev.ClientMessageEvent.ptr2 = l1; + xev.ClientMessageEvent.ptr3 = l2; + XSendEvent (DisplayHandle, RootWindow, false, EventMask.SubstructureRedirectMask | EventMask.SubstructureNotifyMask, ref xev); + } + + private void SendNetClientMessage (IntPtr window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2) + { + XEvent xev; + + xev = new XEvent (); + xev.ClientMessageEvent.type = XEventName.ClientMessage; + xev.ClientMessageEvent.send_event = true; + xev.ClientMessageEvent.window = window; + xev.ClientMessageEvent.message_type = message_type; + xev.ClientMessageEvent.format = 32; + xev.ClientMessageEvent.ptr1 = l0; + xev.ClientMessageEvent.ptr2 = l1; + xev.ClientMessageEvent.ptr3 = l2; + XSendEvent (DisplayHandle, window, false, EventMask.NoEventMask, ref xev); + } + + private void DeriveStyles (IntPtr handle, int Style, int ExStyle, out FormBorderStyle border_style, out TitleStyle title_style, out int caption_height, out int tool_caption_height) + { + + // Only MDI windows get caption_heights + caption_height = 0; + tool_caption_height = 19; + + if ((Style & (int) WindowStyles.WS_CHILD) != 0) { + if ((Style & (int) WindowStyles.WS_BORDER) == 0) { + border_style = FormBorderStyle.None; + } else if ((ExStyle & (int) WindowStyles.WS_EX_CLIENTEDGE) != 0) { + border_style = FormBorderStyle.Fixed3D; + } else { + border_style = FormBorderStyle.FixedSingle; + } + title_style = TitleStyle.None; + } else { + bool is_mdi = false; + + if ((ExStyle & (int) WindowStyles.WS_EX_MDICHILD) != 0) { + caption_height = 26; + is_mdi = true; + } + + title_style = TitleStyle.None; + if ((Style & (int)WindowStyles.WS_CAPTION) != 0) { + if ((ExStyle & (int)WindowStyles.WS_EX_TOOLWINDOW) != 0) { + title_style = TitleStyle.Tool; + } else { + title_style = TitleStyle.Normal; + } + } + + if (!is_mdi) { + border_style = FormBorderStyle.None; + + if ((Style & (int)WindowStyles.WS_THICKFRAME) != 0) { + if ((ExStyle & (int)WindowStyles.WS_EX_TOOLWINDOW) != 0) { + border_style = FormBorderStyle.SizableToolWindow; + } else { + border_style = FormBorderStyle.Sizable; + } + } else { + if ((ExStyle & (int)WindowStyles.WS_EX_CLIENTEDGE) != 0) { + border_style = FormBorderStyle.Fixed3D; + } else if ((ExStyle & (int)WindowStyles.WS_EX_DLGMODALFRAME) != 0) { + border_style = FormBorderStyle.FixedDialog; + } else if ((ExStyle & (int)WindowStyles.WS_EX_TOOLWINDOW) != 0) { + border_style = FormBorderStyle.FixedToolWindow; + } else if ((Style & (int)WindowStyles.WS_BORDER) != 0) { + border_style = FormBorderStyle.Sizable; + } else { + border_style = FormBorderStyle.None; + } + } + } else { + if ((Style & (int) WindowStyles.WS_OVERLAPPEDWINDOW) != 0 || + (ExStyle & (int) WindowStyles.WS_EX_TOOLWINDOW) != 0) { + border_style = (FormBorderStyle) 0xFFFF; + } else { + border_style = FormBorderStyle.None; + } + } + } + } + + private void SetHwndStyles (Hwnd hwnd, CreateParams cp) + { + DeriveStyles (hwnd.Handle, cp.Style, cp.ExStyle, out hwnd.border_style, out hwnd.title_style, out hwnd.caption_height, out hwnd.tool_caption_height); + } + + private void SetWMStyles (Hwnd hwnd, CreateParams cp) + { + GdkWMDecoration decorations = GdkWMDecoration.GDK_DECOR_ALL; + + if ((cp.Style & (int)WindowStyles.WS_CAPTION) != 0) { + decorations |= GdkWMDecoration.GDK_DECOR_TITLE | GdkWMDecoration.GDK_DECOR_MENU; + } + + if ((cp.Style & ((int)WindowStyles.WS_THICKFRAME)) != 0) { + decorations |= GdkWMDecoration.GDK_DECOR_BORDER | GdkWMDecoration.GDK_DECOR_RESIZEH; + } + if ((cp.Style & ((int)WindowStyles.WS_MINIMIZEBOX)) != 0) { + decorations |= GdkWMDecoration.GDK_DECOR_MINIMIZE; + } + + if ((cp.Style & ((int)WindowStyles.WS_MAXIMIZEBOX)) != 0) { + decorations |= GdkWMDecoration.GDK_DECOR_MAXIMIZE; + } + + // is this needed ? most window managers do not even honour any MotifFunctions... +// if ((cp.Style & ((int)WindowStyles.WS_SYSMENU)) != 0) { +// functions |= MotifFunctions.Close; +// } + + if ((cp.ExStyle & ((int)WindowStyles.WS_EX_DLGMODALFRAME)) != 0) { + decorations |= GdkWMDecoration.GDK_DECOR_BORDER; + } + + if ((cp.Style & ((int)WindowStyles.WS_DLGFRAME)) != 0) { + decorations |= GdkWMDecoration.GDK_DECOR_BORDER; + } + + if ((cp.Style & ((int)WindowStyles.WS_BORDER)) != 0) { + decorations |= GdkWMDecoration.GDK_DECOR_BORDER; + } + + if ((cp.ExStyle & ((int)WindowStyles.WS_EX_TOOLWINDOW)) != 0) { + decorations = 0; + } + + gdk_window_set_decorations (gdk_window_foreign_new (hwnd.whole_window), (int)decorations); + } + + private void SetIcon (Hwnd hwnd, Icon icon) + { + Bitmap bitmap; + int size; + uint[] data; + int index; + + bitmap = icon.ToBitmap (); + index = 0; + size = bitmap.Width * bitmap.Height + 2; + data = new uint [size]; + + data [index++] = (uint)bitmap.Width; + data [index++] = (uint)bitmap.Height; + + for (int y = 0; y < bitmap.Height; y++) { + for (int x = 0; x < bitmap.Width; x++) { + data [index++] = (uint)bitmap.GetPixel (x, y).ToArgb (); + } + } + XChangeProperty (DisplayHandle, hwnd.whole_window, NetAtoms [(int)NA._NET_WM_ICON], Atom.XA_CARDINAL, 32, PropertyMode.Replace, data, size); + } + + private IntPtr ImageToPixmap (Image image) + { + return IntPtr.Zero; + } + + private void WakeupMain () + { + wake.Send (new byte [] { 0xFF }); + } + + private void TranslatePropertyToClipboard (int property) + { + Atom actual_atom; + int actual_format; + int nitems; + int bytes_after; + IntPtr prop = IntPtr.Zero; + + Clipboard.Item = null; + + XGetWindowProperty (DisplayHandle, FosterParent, property, 0, 0x7fffffff, true, Atom.AnyPropertyType, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + + if (nitems > 0) { + if (property == (int)Atom.XA_STRING) { + Clipboard.Item = Marshal.PtrToStringAnsi (prop); + } else if (property == (int)Atom.XA_BITMAP) { + // FIXME - convert bitmap to image + } else if (property == (int)Atom.XA_PIXMAP) { + // FIXME - convert pixmap to image + } else if (property == NetAtoms [(int)NA.OEMTEXT]) { + Clipboard.Item = Marshal.PtrToStringAnsi (prop); + } else if (property == NetAtoms [(int)NA.UNICODETEXT]) { + Clipboard.Item = Marshal.PtrToStringAnsi (prop); + } + + XFree (prop); + } + } + + private void AddExpose (XEvent xevent) + { + Hwnd hwnd; + + hwnd = Hwnd.GetObjectFromWindow (xevent.AnyEvent.window); + + // Don't waste time + if (hwnd == null) { + return; + } + + if (xevent.AnyEvent.window == hwnd.client_window) { + hwnd.AddInvalidArea (xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height); + if (!hwnd.expose_pending) { + MessageQueue.Enqueue (xevent); + hwnd.expose_pending = true; + } + } else { + if (!hwnd.nc_expose_pending) { + MessageQueue.Enqueue (xevent); + hwnd.nc_expose_pending = true; + } + } + } + + private void InvalidateWholeWindow (IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + InvalidateWholeWindow (handle, new Rectangle (0, 0, hwnd.Width, hwnd.Height)); + } + + private void InvalidateWholeWindow (IntPtr handle, Rectangle rectangle) + { + Hwnd hwnd; + XEvent xevent; + + hwnd = Hwnd.ObjectFromHandle (handle); + + + xevent = new XEvent (); + xevent.type = XEventName.Expose; + xevent.ExposeEvent.display = DisplayHandle; + xevent.ExposeEvent.window = hwnd.whole_window; + + xevent.ExposeEvent.x = rectangle.X; + xevent.ExposeEvent.y = rectangle.Y; + xevent.ExposeEvent.width = rectangle.Width; + xevent.ExposeEvent.height = rectangle.Height; + + AddExpose (xevent); + } + + private void WholeToScreen (IntPtr handle, ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + lock (XlibLock) { + gdk_window_get_origin (gdk_window_lookup (hwnd.whole_window), out dest_x_return, out dest_y_return); + } + + x = dest_x_return; + y = dest_y_return; + } + + private void AddConfigureNotify (XEvent xevent) + { + Hwnd hwnd; + + hwnd = Hwnd.GetObjectFromWindow (xevent.ConfigureEvent.window); + + // Don't waste time + if (hwnd == null) { + return; + } + + if (xevent.ConfigureEvent.window == hwnd.whole_window) { + if (!hwnd.reparented) { + hwnd.x = xevent.ConfigureEvent.x; + hwnd.y = xevent.ConfigureEvent.y; + } else { + int dummy_int; + + gdk_window_get_geometry (gdk_window_lookup (hwnd.whole_window), out hwnd.x, out hwnd.y, out dummy_int, out dummy_int, out dummy_int); + } + + hwnd.width = xevent.ConfigureEvent.width; + hwnd.height = xevent.ConfigureEvent.height; + + if (!hwnd.configure_pending) { + MessageQueue.Enqueue (xevent); + hwnd.configure_pending = true; + } + } + // We drop configure events for Client windows + } + + private void ShowCaret () + { + if ((Caret.gc == IntPtr.Zero) || Caret.On) { + return; + } + Caret.On = true; + + // gdk_gc_set_foreground + // gdk_draw_line + lock (XlibLock) { + XDrawLine (DisplayHandle, Caret.Window, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height); + } + } + + private void HideCaret () + { + if ((Caret.gc == IntPtr.Zero) || !Caret.On) { + return; + } + Caret.On = false; + + // gdk_gc_set_foreground + // gdk_draw_text_wc + lock (XlibLock) { + XDrawLine (DisplayHandle, Caret.Window, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height); + } + } + + private int NextTimeout (DateTime now) + { + int timeout = Int32.MaxValue; + lock (TimerList) { + foreach (Timer timer in TimerList) { + int next = (int) (timer.Expires - now).TotalMilliseconds; + if (next < 0) { + return 0; // Have a timer that has already expired + } + + if (next < timeout) { + timeout = next; + } + } + } + if (timeout < Timer.Minimum) { + timeout = Timer.Minimum; + } + + return timeout; + } + + private void CheckTimers (DateTime now) + { + lock (TimerList) { + int count; + + count = TimerList.Count; + + if (count == 0) { + return; + } + + for (int i = 0; i < TimerList.Count; i++) { + Timer timer; + + timer = (Timer) TimerList [i]; + + if (timer.Enabled && timer.Expires <= now) { + timer.Update (now); + timer.FireTick (); + } + } + } + } + + private void UpdateMessageQueue () + { + DateTime now; + int pending; + + now = DateTime.Now; + + lock (XlibLock) { + pending = XPending (DisplayHandle); + } + + if (pending == 0) { + if (Idle != null) { + Idle (this, EventArgs.Empty); + } + + lock (XlibLock) { + pending = XPending (DisplayHandle); + } + } + + if (pending == 0) { + int timeout; + + timeout = NextTimeout (now); + if (timeout > 0) { + #if __MonoCS__ + Syscall.poll (pollfds, (uint) pollfds.Length, timeout); + // Clean out buffer, so we're not busy-looping on the same data + if (pollfds[1].revents != 0) { + wake_receive.Receive(network_buffer, 0, 1, SocketFlags.None); + } + #endif + lock (XlibLock) { + pending = XPending (DisplayHandle); + } + } + } + + CheckTimers (now); + + if (pending == 0) { + lock (XlibLock) { + pending = XPending (DisplayHandle); + } + } + + while (pending > 0) { + XEvent xevent = new XEvent (); + + lock (XlibLock) { + XNextEvent (DisplayHandle, ref xevent); + } +//Console.WriteLine("Got x event {0}", xevent); + switch (xevent.type) { + case XEventName.Expose: + AddExpose (xevent); + break; + + case XEventName.SelectionClear: { + // Should we do something? + break; + } + + case XEventName.SelectionRequest: { + if (Dnd.HandleSelectionRequestEvent (ref xevent)) + break; + XEvent sel_event; + + sel_event = new XEvent (); + sel_event.SelectionEvent.type = XEventName.SelectionNotify; + sel_event.SelectionEvent.send_event = true; + sel_event.SelectionEvent.display = DisplayHandle; + sel_event.SelectionEvent.selection = xevent.SelectionRequestEvent.selection; + sel_event.SelectionEvent.target = xevent.SelectionRequestEvent.target; + sel_event.SelectionEvent.requestor = xevent.SelectionRequestEvent.requestor; + sel_event.SelectionEvent.time = xevent.SelectionRequestEvent.time; + sel_event.SelectionEvent.property = 0; + + // Seems that some apps support asking for supported types + if (xevent.SelectionEvent.target == NetAtoms [(int)NA.TARGETS]) { + uint[] atoms; + int atom_count; + + atoms = new uint [5]; + atom_count = 0; + + if (Clipboard.Item is String) { + atoms [atom_count++] = (uint)Atom.XA_STRING; + atoms [atom_count++] = (uint)NetAtoms [(int)NA.OEMTEXT]; + atoms [atom_count++] = (uint)NetAtoms [(int)NA.UNICODETEXT]; + } else if (Clipboard.Item is Image) { + atoms [atom_count++] = (uint)Atom.XA_PIXMAP; + atoms [atom_count++] = (uint)Atom.XA_BITMAP; + } else { + // FIXME - handle other types + } + + XChangeProperty (DisplayHandle, xevent.SelectionEvent.requestor, xevent.SelectionRequestEvent.property, xevent.SelectionRequestEvent.target, 32, PropertyMode.Replace, atoms, atom_count); + } else if (Clipboard.Item is string) { + IntPtr buffer; + int buflen; + + buflen = 0; + + if (xevent.SelectionRequestEvent.target == (int)Atom.XA_STRING) { + Byte[] bytes; + + bytes = new ASCIIEncoding ().GetBytes ((string)Clipboard.Item); + buffer = Marshal.AllocHGlobal (bytes.Length); + buflen = bytes.Length; + + for (int i = 0; i < buflen; i++) { + Marshal.WriteByte (buffer, i, bytes [i]); + } + } else if (xevent.SelectionRequestEvent.target == NetAtoms [(int)NA.OEMTEXT]) { + // FIXME - this should encode into ISO2022 + buffer = Marshal.StringToHGlobalAnsi ((string)Clipboard.Item); + while (Marshal.ReadByte (buffer, buflen) != 0) { + buflen++; + } + } else if (xevent.SelectionRequestEvent.target == NetAtoms [(int)NA.UNICODETEXT]) { + buffer = Marshal.StringToHGlobalAnsi ((string)Clipboard.Item); + while (Marshal.ReadByte (buffer, buflen) != 0) { + buflen++; + } + } else { + buffer = IntPtr.Zero; + } + + if (buffer != IntPtr.Zero) { + XChangeProperty (DisplayHandle, xevent.SelectionRequestEvent.requestor, xevent.SelectionRequestEvent.property, xevent.SelectionRequestEvent.target, 8, PropertyMode.Replace, buffer, buflen); + sel_event.SelectionEvent.property = xevent.SelectionRequestEvent.property; + Marshal.FreeHGlobal (buffer); + } + } else if (Clipboard.Item is Image) { + if (xevent.SelectionEvent.target == (int)Atom.XA_PIXMAP) { + // FIXME - convert image and store as property + } else if (xevent.SelectionEvent.target == (int)Atom.XA_PIXMAP) { + // FIXME - convert image and store as property + } + } + + XSendEvent (DisplayHandle, xevent.SelectionRequestEvent.requestor, false, EventMask.NoEventMask, ref sel_event); + break; + } + + case XEventName.SelectionNotify: { + if (Clipboard.Enumerating) { + Clipboard.Enumerating = false; + if (xevent.SelectionEvent.property != 0) { + XDeleteProperty (DisplayHandle, FosterParent, xevent.SelectionEvent.property); + if (!Clipboard.Formats.Contains (xevent.SelectionEvent.property)) { + Clipboard.Formats.Add (xevent.SelectionEvent.property); + #if DriverDebugExtra + Console.WriteLine("Got supported clipboard atom format: {0}", xevent.SelectionEvent.property); + #endif + } + } + } else if (Clipboard.Retrieving) { + Clipboard.Retrieving = false; + if (xevent.SelectionEvent.property != 0) { + TranslatePropertyToClipboard (xevent.SelectionEvent.property); + } else { + Clipboard.Item = null; + } + } else { + Dnd.HandleSelectionNotifyEvent (ref xevent); + } + break; + } + + case XEventName.KeyPress: + case XEventName.KeyRelease: + case XEventName.ButtonPress: + case XEventName.ButtonRelease: + case XEventName.MotionNotify: + case XEventName.EnterNotify: + case XEventName.LeaveNotify: + case XEventName.CreateNotify: + case XEventName.DestroyNotify: + case XEventName.FocusIn: + case XEventName.FocusOut: + case XEventName.ClientMessage: + case XEventName.ReparentNotify: + MessageQueue.Enqueue (xevent); + break; + + case XEventName.ConfigureNotify: + AddConfigureNotify (xevent); + break; + + case XEventName.PropertyNotify: + if (xevent.PropertyEvent.atom == NetAtoms [(int)NA._NET_ACTIVE_WINDOW]) { + Atom actual_atom; + int actual_format; + int nitems; + int bytes_after; + IntPtr prop = IntPtr.Zero; + IntPtr prev_active;; + + prev_active = ActiveWindow; + XGetWindowProperty (DisplayHandle, RootWindow, NetAtoms [(int)NA._NET_ACTIVE_WINDOW], 0, 1, false, Atom.XA_WINDOW, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + if ((nitems > 0) && (prop != IntPtr.Zero)) { + ActiveWindow = Hwnd.GetHandleFromWindow ((IntPtr)Marshal.ReadInt32 (prop)); + XFree (prop); + + if (prev_active != ActiveWindow) { + if (prev_active != IntPtr.Zero) { + PostMessage (prev_active, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_INACTIVE, IntPtr.Zero); + } + if (ActiveWindow != IntPtr.Zero) { + PostMessage (ActiveWindow, Msg.WM_ACTIVATE, (IntPtr)WindowActiveFlags.WA_ACTIVE, IntPtr.Zero); + } + } + if (ModalWindows.Count == 0) { + break; + } else { + // Modality handling, if we are modal and the new active window is one + // of ours but not the modal one, switch back to the modal window + + if (NativeWindow.FromHandle (ActiveWindow) != null) { + if (ActiveWindow != (IntPtr)ModalWindows.Peek ()) { + Activate ((IntPtr)ModalWindows.Peek ()); + } + } + break; + } + } + } + break; + + } + + lock (XlibLock) { + pending = XPending (DisplayHandle); + } + } + } + + private IntPtr GetMousewParam (int Delta) + { + int result = 0; + + if ((MouseState & MouseButtons.Left) != 0) { + result |= (int)MsgButtons.MK_LBUTTON; + } + + if ((MouseState & MouseButtons.Middle) != 0) { + result |= (int)MsgButtons.MK_MBUTTON; + } + + if ((MouseState & MouseButtons.Right) != 0) { + result |= (int)MsgButtons.MK_RBUTTON; + } + + Keys mods = ModifierKeys; + if ((mods & Keys.Control) != 0) { + result |= (int)MsgButtons.MK_CONTROL; + } + + if ((mods & Keys.Shift) != 0) { + result |= (int)MsgButtons.MK_SHIFT; + } + + result |= Delta << 16; + + return (IntPtr)result; + } + private IntPtr XGetParent (IntPtr handle) + { + return gdk_x11_drawable_get_xid (gdk_window_get_parent (gdk_window_lookup (handle))); + } + + private int HandleError (IntPtr display, ref XErrorEvent error_event) + { + if (ErrorExceptions) { + throw new XException (error_event.display, error_event.resourceid, error_event.serial, error_event.error_code, error_event.request_code, error_event.minor_code); + } else { + Console.WriteLine ("X11 Error encountered: {0}{1}\n", XException.GetMessage (error_event.display, error_event.resourceid, error_event.serial, error_event.error_code, error_event.request_code, error_event.minor_code), Environment.StackTrace); + } + return 0; + } + + private void DestroyChildWindow (ShiftUI.Widget c) + { + Hwnd hwnd; + int i; + ShiftUI.Widget[] Widgets; + + if (c != null) { + Widgets = c.Widgets.GetAllWidgets (); + + for (i = 0; i < Widgets.Length; i++) { + if (Widgets [i].IsHandleCreated) { + hwnd = Hwnd.ObjectFromHandle (Widgets [i].Handle); + SendMessage (Widgets [i].Handle, Msg.WM_DESTROY, IntPtr.Zero, IntPtr.Zero); + hwnd.Dispose (); + } + DestroyChildWindow (Widgets [i]); + } + } + } + + #endregion // Private Methods + + #region Callbacks + private void MouseHover (object sender, EventArgs e) + { + if ((HoverState.X == MousePosition.X) && (HoverState.Y == MousePosition.Y)) { + XEvent xevent; + + HoverState.Timer.Enabled = false; + + if (HoverState.Window != IntPtr.Zero) { + xevent = new XEvent (); + + xevent.type = XEventName.ClientMessage; + xevent.ClientMessageEvent.display = DisplayHandle; + xevent.ClientMessageEvent.window = (IntPtr)HoverState.Window; + xevent.ClientMessageEvent.message_type = (IntPtr)HoverState.Atom; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = (IntPtr) (HoverState.Y << 16 | HoverState.X); + + MessageQueue.EnqueueLocked (xevent); + + WakeupMain (); + } + } + } + + private void CaretCallback (object sender, EventArgs e) + { + if (Caret.Paused) { + return; + } + Caret.On = !Caret.On; + + XDrawLine (DisplayHandle, Caret.Hwnd, Caret.gc, Caret.X, Caret.Y, Caret.X, Caret.Y + Caret.Height); + } + #endregion // Callbacks + + #region Public Properties + + internal int Caption { + get { + return 25; + } + } + + internal override Size CursorSize { + get { + uint x; + uint y; + gdk_display_get_maximal_cursor_size (GdkDisplayHandle, out x, out y); + + return new Size ((int)x, (int)y); + } + } + + internal override bool DragFullWindows { + get { + return true; + } + } + + internal override Size DragSize { + get { + return new Size (4, 4); + } + } + + internal override Size FrameBorderSize { + get { + throw new NotImplementedException (); + } + } + + internal override Size IconSize { + get { + IntPtr list; + XIconSize size; + int count; + + if (XGetIconSizes (DisplayHandle, RootWindow, out list, out count) != 0) { + long current; + int largest; + + current = (long)list; + largest = 0; + + size = new XIconSize (); + + for (int i = 0; i < count; i++) { + size = (XIconSize)Marshal.PtrToStructure ((IntPtr)current, size.GetType ()); + current += Marshal.SizeOf (size); + + // Look for our preferred size + if (size.min_width == 32) { + XFree (list); + return new Size (32, 32); + } + + if (size.max_width == 32) { + XFree (list); + return new Size (32, 32); + } + + if (size.min_width < 32 && size.max_width > 32) { + int x; + + // check if we can fit one + x = size.min_width; + while (x < size.max_width) { + x += size.width_inc; + if (x == 32) { + XFree (list); + return new Size (32, 32); + } + } + } + + if (largest < size.max_width) { + largest = size.max_width; + } + } + + // We didn't find a match or we wouldn't be here + return new Size (largest, largest); + + } else { + return new Size (32, 32); + } + } + } + + internal override int KeyboardSpeed { + get { + // + // A lot harder: need to do: + // XkbQueryExtension(0x08051008, 0xbfffdf4c, 0xbfffdf50, 0xbfffdf54, 0xbfffdf58) = 1 + // XkbAllocKeyboard(0x08051008, 0xbfffdf4c, 0xbfffdf50, 0xbfffdf54, 0xbfffdf58) = 0x080517a8 + // XkbGetWidgets(0x08051008, 1, 0x080517a8, 0xbfffdf54, 0xbfffdf58) = 0 + // + // And from that we can tell the repetition rate + // + // Notice, the values must map to: + // [0, 31] which maps to 2.5 to 30 repetitions per second. + // + return 0; + } + } + + internal override int KeyboardDelay { + get { + // + // Return values must range from 0 to 4, 0 meaning 250ms, + // and 4 meaning 1000 ms. + // + return 1; // ie, 500 ms + } + } + + internal override Size MaxWindowTrackSize { + get { + return new Size (WorkingArea.Width, WorkingArea.Height); + } + } + + internal override Size MinimizedWindowSize { + get { + return new Size (1, 1); + } + } + + internal override Size MinimizedWindowSpacingSize { + get { + return new Size (1, 1); + } + } + + internal override Size MinimumWindowSize { + get { + return new Size (1, 1); + } + } + + internal override Size MinWindowTrackSize { + get { + return new Size (1, 1); + } + } + + internal override Keys ModifierKeys { + get { + return Keyboard.ModifierKeys; + } + } + + internal override Size SmallIconSize { + get { + IntPtr list; + XIconSize size; + int count; + + if (XGetIconSizes (DisplayHandle, RootWindow, out list, out count) != 0) { + long current; + int smallest; + + current = (long)list; + smallest = 0; + + size = new XIconSize (); + + for (int i = 0; i < count; i++) { + size = (XIconSize)Marshal.PtrToStructure ((IntPtr)current, size.GetType ()); + current += Marshal.SizeOf (size); + + // Look for our preferred size + if (size.min_width == 16) { + XFree (list); + return new Size (16, 16); + } + + if (size.max_width == 16) { + XFree (list); + return new Size (16, 16); + } + + if (size.min_width < 16 && size.max_width > 16) { + int x; + + // check if we can fit one + x = size.min_width; + while (x < size.max_width) { + x += size.width_inc; + if (x == 16) { + XFree (list); + return new Size (16, 16); + } + } + } + + if (smallest == 0 || smallest > size.min_width) { + smallest = size.min_width; + } + } + + // We didn't find a match or we wouldn't be here + return new Size (smallest, smallest); + + } else { + return new Size (16, 16); + } + } + } + + internal override int MouseButtonCount { + get { + return 3; + } + } + + internal override bool MouseButtonsSwapped { + get { + return false; // FIXME - how to detect? + } + } + + internal override bool MouseWheelPresent { + get { + return true; // FIXME - how to detect? + } + } + + internal override Rectangle VirtualScreen { + get { + return WorkingArea; + } + } + + internal override Rectangle WorkingArea { + get { + Atom actual_atom; + int actual_format; + int nitems; + int bytes_after; + IntPtr prop = IntPtr.Zero; + int width; + int height; + + XGetWindowProperty (DisplayHandle, RootWindow, NetAtoms [(int)NA._NET_DESKTOP_GEOMETRY], 0, 256, false, Atom.XA_CARDINAL, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + if ((nitems == 2) && (prop != IntPtr.Zero)) { + width = Marshal.ReadInt32 (prop, 0); + height = Marshal.ReadInt32 (prop, 4); + + XFree (prop); + return new Rectangle (0, 0, width, height); + } else { + XWindowAttributes attributes=new XWindowAttributes (); + + lock (XlibLock) { + XGetWindowAttributes (DisplayHandle, XRootWindow (DisplayHandle, ScreenNo), ref attributes); + } + + return new Rectangle (0, 0, attributes.width, attributes.height); + } + } + } + #endregion // Public properties + + #region Public Static Methods + internal override IntPtr InitializeDriver () + { + lock (this) { + if (GdkDisplayHandle == IntPtr.Zero) { + SetDisplay (gdk_x11_display_get_xdisplay (gdk_display_get_default ())); + } + } + return IntPtr.Zero; + } + + internal override void ShutdownDriver (IntPtr token) + { + lock (this) { + if (GdkDisplayHandle != IntPtr.Zero) { + gdk_display_close (GdkDisplayHandle); + DisplayHandle = IntPtr.Zero; + GdkDisplayHandle = IntPtr.Zero; + } + } + } + + internal override void EnableThemes () + { + ThemesEnabled = true; + } + + + internal override void Activate (IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd != null) lock (XlibLock) { + SendNetWMMessage (hwnd.whole_window, (IntPtr)NetAtoms [(int)NA._NET_ACTIVE_WINDOW], IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); + //XRaiseWindow(DisplayHandle, handle); + } + return; + } + + internal override void AudibleAlert (AlertType atype) + { + gdk_display_beep (gdk_x11_lookup_xdisplay (DisplayHandle)); + return; + } + + + internal override void CaretVisible (IntPtr handle, bool visible) + { + // Visible is cumulative; two hides require two shows before the caret is visible again + if (Caret.Hwnd == handle) { + if (visible) { + if (Caret.Visible < 1) { + Caret.Visible++; + Caret.On = false; + if (Caret.Visible == 1) { + ShowCaret (); + Caret.Timer.Start (); + } + } + } else { + Caret.Visible--; + if (Caret.Visible == 0) { + Caret.Timer.Stop (); + HideCaret (); + } + } + } + } + + internal bool CalculateWindowRect (IntPtr handle, ref Rectangle ClientRect, int Style, int ExStyle, Menu menu, out Rectangle WindowRect) + { + FormBorderStyle border_style; + TitleStyle title_style; + int caption_height; + int tool_caption_height; + + DeriveStyles (handle, Style, ExStyle, out border_style, out title_style, + out caption_height, out tool_caption_height); + + WindowRect = Hwnd.GetWindowRectangle (border_style, menu, title_style, + caption_height, tool_caption_height, + ClientRect); + + return true; + } + + internal override void ClientToScreen (IntPtr handle, ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + IntPtr child; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + lock (XlibLock) { + XTranslateCoordinates (DisplayHandle, hwnd.client_window, RootWindow, x, y, out dest_x_return, out dest_y_return, out child); + } + + x = dest_x_return; + y = dest_y_return; + } + + + internal override void CreateCaret (IntPtr handle, int width, int height) + { + XGCValues gc_values; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + if (Caret.Hwnd != IntPtr.Zero) { + DestroyCaret (Caret.Hwnd); + } + + Caret.Hwnd = handle; + Caret.Window = hwnd.client_window; + Caret.Width = width; + Caret.Height = height; + Caret.Visible = 0; + Caret.On = false; + + gc_values = new XGCValues (); + gc_values.line_width = width; + + Caret.gc = XCreateGC (DisplayHandle, Caret.Window, GCFunction.GCLineWidth, ref gc_values); + if (Caret.gc == IntPtr.Zero) { + Caret.Hwnd = IntPtr.Zero; + return; + } + + XSetFunction (DisplayHandle, Caret.gc, GXFunction.GXinvert); + } + + internal override IntPtr CreateWindow (CreateParams cp) + { + GdkWindowAttr gdk_window_attributes; + GdkWindowAttributesType attributes_mask = 0; + Hwnd hwnd; + int X; + int Y; + int Width; + int Height; + IntPtr GdkParentHandle; + IntPtr GdkWholeWindow; + IntPtr GdkClientWindow; + Rectangle ClientRect; + GdkWindowType gdk_window_type; + + + hwnd = new Hwnd (); + + gdk_window_attributes = new GdkWindowAttr (); + + X = cp.X; + Y = cp.Y; + Width = cp.Width; + Height = cp.Height; + + if (Width < 1) Width = 1; + if (Height < 1) Height = 1; + + gdk_window_type = GdkWindowType.GDK_WINDOW_CHILD; + + if (cp.Parent != IntPtr.Zero) { + GdkParentHandle = gdk_window_lookup (Hwnd.ObjectFromHandle (cp.Parent).client_window); + } else { + if ((cp.Style & (int)WindowStyles.WS_CHILD) != 0) { + // We need to use our foster parent window until this poor child gets it's parent assigned + GdkParentHandle = GdkFosterParent; + } else if ((cp.Style & (int)WindowStyles.WS_POPUP) != 0) { + GdkParentHandle = GdkRootWindow; + } else { + // Default position on screen, if window manager doesn't place us somewhere else + if (X < 1) X = 50; + if (Y < 1) Y = 50; + GdkParentHandle = GdkRootWindow; + } + } + +// ValueMask = SetWindowValuemask.BitGravity | SetWindowValuemask.WinGravity; + +// Attributes.bit_gravity = Gravity.NorthWestGravity; +// Attributes.win_gravity = Gravity.NorthWestGravity; + + // FIXME: does gdk need that ? + // Save what's under the toolwindow + if ((cp.ExStyle & (int)WindowStyles.WS_EX_TOOLWINDOW) != 0) { +// Attributes.save_under = true; +// ValueMask |= SetWindowValuemask.SaveUnder; + } + + // If we're a popup without caption we override the WM + if ((cp.Style & ((int)WindowStyles.WS_POPUP)) != 0) { + if ((cp.Style & (int)WindowStyles.WS_CAPTION) == 0) { + gdk_window_attributes.override_redirect = true; + attributes_mask |= GdkWindowAttributesType.GDK_WA_NOREDIR; + } + } + + hwnd.x = X; + hwnd.y = Y; + hwnd.width = Width; + hwnd.height = Height; + hwnd.parent = Hwnd.ObjectFromHandle (cp.Parent); + + if ((cp.Style & ((int)WindowStyles.WS_DISABLED)) != 0) { + hwnd.enabled = false; + } + + ClientRect = hwnd.ClientRect; + GdkClientWindow = IntPtr.Zero; + + gdk_window_attributes.x = X; + gdk_window_attributes.y = Y; + gdk_window_attributes.width = Width; + gdk_window_attributes.height = Height; + gdk_window_attributes.window_type = gdk_window_type; + + attributes_mask |= GdkWindowAttributesType.GDK_WA_X | GdkWindowAttributesType.GDK_WA_Y; + + gdk_window_attributes.wclass = GdkWindowClass.GDK_INPUT_OUTPUT; + + lock (XlibLock) { + GdkWholeWindow = gdk_window_new (GdkParentHandle, ref gdk_window_attributes, (int)attributes_mask); + + if (GdkWholeWindow != IntPtr.Zero) { + attributes_mask &= ~GdkWindowAttributesType.GDK_WA_NOREDIR; + + if (GdkCustomVisual != IntPtr.Zero && GdkCustomColormap != IntPtr.Zero) { + attributes_mask |= GdkWindowAttributesType.GDK_WA_COLORMAP | GdkWindowAttributesType.GDK_WA_VISUAL; + gdk_window_attributes.colormap = GdkCustomColormap; + gdk_window_attributes.visual = GdkCustomVisual; + } + + gdk_window_attributes.x = ClientRect.X; + gdk_window_attributes.y = ClientRect.Y; + gdk_window_attributes.width = ClientRect.Width; + gdk_window_attributes.height = ClientRect.Height; + + GdkClientWindow = gdk_window_new (GdkWholeWindow, ref gdk_window_attributes, (int)attributes_mask); + } + } + + if ((GdkWholeWindow == IntPtr.Zero) || (GdkClientWindow == IntPtr.Zero)) { + throw new Exception ("Could not create X11 Gdk windows"); + } + + hwnd.WholeWindow = gdk_x11_drawable_get_xid (GdkWholeWindow); + hwnd.ClientWindow = gdk_x11_drawable_get_xid (GdkClientWindow); + + #if DriverDebug + Console.WriteLine("Created window {0:X} / {1:X} parent {2:X}", ClientWindow.ToInt32(), WholeWindow.ToInt32(), hwnd.parent != null ? hwnd.parent.Handle.ToInt32() : 0); + #endif + + lock (XlibLock) { + gdk_window_set_events (GdkWholeWindow, (int)GdkSelectInputMask); + gdk_window_set_events (GdkClientWindow, (int)GdkSelectInputMask); + + if ((cp.Style & (int)WindowStyles.WS_VISIBLE) != 0) { + gdk_window_show (GdkWholeWindow); + gdk_window_show (GdkClientWindow); + hwnd.visible = true; + } + } + + SetWMStyles (hwnd, cp); + + if ((cp.Style & (int)WindowStyles.WS_MINIMIZE) != 0) { + SetWindowState (hwnd.Handle, FormWindowState.Minimized); + } else if ((cp.Style & (int)WindowStyles.WS_MAXIMIZE) != 0) { + SetWindowState (hwnd.Handle, FormWindowState.Maximized); + } + + // for now make all windows dnd enabled + Dnd.SetAllowDrop (hwnd, true); + + // Set caption/window title + Text (hwnd.Handle, cp.Caption); + + return hwnd.Handle; + } + + internal override IntPtr CreateWindow (IntPtr Parent, int X, int Y, int Width, int Height) + { + CreateParams create_params = new CreateParams (); + + create_params.Caption = ""; + create_params.X = X; + create_params.Y = Y; + create_params.Width = Width; + create_params.Height = Height; + + create_params.ClassName = XplatUI.DefaultClassName; + create_params.ClassStyle = 0; + create_params.ExStyle = 0; + create_params.Parent = IntPtr.Zero; + create_params.Param = 0; + + return CreateWindow (create_params); + } + + internal override IntPtr DefineCursor (Bitmap bitmap, Bitmap mask, Color cursor_pixel, Color mask_pixel, int xHotSpot, int yHotSpot) + { + IntPtr cursor; + Bitmap cursor_bitmap; + Bitmap cursor_mask; + Byte[] cursor_bits; + Byte[] mask_bits; + Color c_pixel; + Color m_pixel; + int width; + int height; + IntPtr cursor_pixmap; + IntPtr mask_pixmap; + XColor fg; + XColor bg; + bool and; + bool xor; + + Size cursor_size = CursorSize; + width = cursor_size.Width; + height = cursor_size.Height; + + // Win32 only allows creation cursors of a certain size + if ((bitmap.Width != width) || (bitmap.Width != height)) { + cursor_bitmap = new Bitmap (bitmap, new Size (width, height)); + cursor_mask = new Bitmap (mask, new Size (width, height)); + } else { + cursor_bitmap = bitmap; + cursor_mask = mask; + } + + width = cursor_bitmap.Width; + height = cursor_bitmap.Height; + + cursor_bits = new Byte [(width / 8) * height]; + mask_bits = new Byte [(width / 8) * height]; + + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + c_pixel = cursor_bitmap.GetPixel (x, y); + m_pixel = cursor_mask.GetPixel (x, y); + + and = c_pixel == cursor_pixel; + xor = m_pixel == mask_pixel; + + if (!and && !xor) { + // Black + // cursor_bits[y * width / 8 + x / 8] &= (byte)~((1 << (x % 8))); // The bit already is 0 + mask_bits [y * width / 8 + x / 8] |= (byte)(1 << (x % 8)); + } else if (and && !xor) { + // White + cursor_bits [y * width / 8 + x / 8] |= (byte)(1 << (x % 8)); + mask_bits [y * width / 8 + x / 8] |= (byte)(1 << (x % 8)); + #if notneeded + } else if (and && !xor) { + // Screen + } else if (and && xor) { + // Inverse Screen + + // X11 doesn't know the 'reverse screen' concept, so we'll treat them the same + // we want both to be 0 so nothing to be done + //cursor_bits[y * width / 8 + x / 8] &= (byte)~((1 << (x % 8))); + //mask_bits[y * width / 8 + x / 8] |= (byte)(01 << (x % 8)); + #endif + } + } + } + + cursor_pixmap = XCreatePixmapFromBitmapData (DisplayHandle, RootWindow, cursor_bits, width, height, (IntPtr)1, (IntPtr)0, 1); + mask_pixmap = XCreatePixmapFromBitmapData (DisplayHandle, RootWindow, mask_bits, width, height, (IntPtr)1, (IntPtr)0, 1); + fg = new XColor (); + bg = new XColor (); + + fg.pixel = XWhitePixel (DisplayHandle, ScreenNo); + fg.red = (ushort)65535; + fg.green = (ushort)65535; + fg.blue = (ushort)65535; + + bg.pixel = XBlackPixel (DisplayHandle, ScreenNo); + + cursor = XCreatePixmapCursor (DisplayHandle, cursor_pixmap, mask_pixmap, ref fg, ref bg, xHotSpot, yHotSpot); + + XFreePixmap (DisplayHandle, cursor_pixmap); + XFreePixmap (DisplayHandle, mask_pixmap); + + return cursor; + } + + internal override IntPtr DefineStdCursor (StdCursor id) + { + CursorFontShape shape; + IntPtr cursor; + + // FIXME - define missing shapes + + switch (id) { + case StdCursor.AppStarting: { + shape = CursorFontShape.XC_watch; + break; + } + + case StdCursor.Arrow: { + return IntPtr.Zero; + } + + case StdCursor.Cross: { + shape = CursorFontShape.XC_crosshair; + break; + } + + case StdCursor.Default: { + return IntPtr.Zero; + } + + case StdCursor.Hand: { + shape = CursorFontShape.XC_hand1; + break; + } + + case StdCursor.Help: { + shape = CursorFontShape.XC_question_arrow; + break; + } + + case StdCursor.HSplit: { + shape = CursorFontShape.XC_sb_v_double_arrow; + break; + } + + case StdCursor.IBeam: { + shape = CursorFontShape.XC_xterm; + break; + } + + case StdCursor.No: { + shape = CursorFontShape.XC_circle; + break; + } + + case StdCursor.NoMove2D: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.NoMoveHoriz: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.NoMoveVert: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanEast: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanNE: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanNorth: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanNW: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanSE: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanSouth: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanSW: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.PanWest: { + shape = CursorFontShape.XC_sizing; + break; + } + + case StdCursor.SizeAll: { + shape = CursorFontShape.XC_fleur; + break; + } + + case StdCursor.SizeNESW: { + shape = CursorFontShape.XC_top_right_corner; + break; + } + + case StdCursor.SizeNS: { + shape = CursorFontShape.XC_sb_v_double_arrow; + break; + } + + case StdCursor.SizeNWSE: { + shape = CursorFontShape.XC_top_left_corner; + break; + } + + case StdCursor.SizeWE: { + shape = CursorFontShape.XC_sb_h_double_arrow; + break; + } + + case StdCursor.UpArrow: { + shape = CursorFontShape.XC_center_ptr; + break; + } + + case StdCursor.VSplit: { + shape = CursorFontShape.XC_sb_h_double_arrow; + break; + } + + case StdCursor.WaitCursor: { + shape = CursorFontShape.XC_watch; + break; + } + + default: { + return IntPtr.Zero; + } + } + + lock (XlibLock) { + cursor = XCreateFontCursor (DisplayHandle, shape); + } + return cursor; + } + + internal override IntPtr DefWndProc (ref Message msg) + { + return IntPtr.Zero; + } + + internal override void DestroyCaret (IntPtr handle) + { + if (Caret.Hwnd == handle) { + if (Caret.Visible == 1) { + Caret.Timer.Stop (); + HideCaret (); + } + if (Caret.gc != IntPtr.Zero) { + XFreeGC (DisplayHandle, Caret.gc); + Caret.gc = IntPtr.Zero; + } + Caret.Hwnd = IntPtr.Zero; + Caret.Visible = 0; + Caret.On = false; + } + } + + internal override void DestroyCursor (IntPtr cursor) + { + lock (XlibLock) { + XFreeCursor (DisplayHandle, cursor); + } + } + + internal override void DestroyWindow (IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd == null) { + #if DriverDebug + Console.WriteLine("window {0:X} already destroyed", handle.ToInt32()); + #endif + return; + } + + #if DriverDebug + Console.WriteLine("Destroying window {0:X}", handle.ToInt32()); + #endif + + // Make sure if the caret is in the window, that we destroy the caret, too + if (Caret.Hwnd == hwnd.client_window) { + DestroyCaret (handle); + } + + // Mark our children as gone as well + DestroyChildWindow (ShiftUI.Widget.ShiftUI.WidgetNativeWindow.ShiftUI.WidgetFromHandle (handle)); + + // Send destroy message + SendMessage (handle, Msg.WM_DESTROY, IntPtr.Zero, IntPtr.Zero); + + lock (XlibLock) { + if (hwnd.client_window != IntPtr.Zero) { + gdk_window_destroy (gdk_window_lookup (hwnd.client_window)); + } + + if ((hwnd.whole_window != IntPtr.Zero) && (hwnd.whole_window != hwnd.client_window)) { + gdk_window_destroy (gdk_window_lookup (hwnd.whole_window)); + } + } + hwnd.Dispose (); + } + + internal override IntPtr DispatchMessage (ref MSG msg) + { + return NativeWindow.WndProc (msg.hwnd, msg.message, msg.wParam, msg.lParam); + } + + internal override void DrawReversibleRectangle (IntPtr handle, Rectangle rect, int line_width) + { + Hwnd hwnd; + XGCValues gc_values; + IntPtr gc; + + hwnd = Hwnd.ObjectFromHandle (handle); + + gc_values = new XGCValues (); + + gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors; + gc_values.line_width = line_width; + gc_values.foreground = XBlackPixel (DisplayHandle, ScreenNo); + + // This logic will give us true rubber bands: (libsx, SANE_XOR) + //mask = foreground ^ background; + //XSetForeground(DisplayHandle, gc, 0xffffffff); + //XSetBackground(DisplayHandle, gc, background); + //XSetFunction(DisplayHandle, gc, GXxor); + //XSetPlaneMask(DisplayHandle, gc, mask); + + + gc = XCreateGC (DisplayHandle, hwnd.client_window, GCFunction.GCSubwindowMode | GCFunction.GCLineWidth | GCFunction.GCForeground, ref gc_values); + uint foreground; + uint background; + + ShiftUI.Widget Widget; + Widget = ShiftUI.Widget.FromHandle (handle); + + XColor xcolor = new XColor (); + + xcolor.red = (ushort)(ShiftUI.Widget.ForeColor.R * 257); + xcolor.green = (ushort)(ShiftUI.Widget.ForeColor.G * 257); + xcolor.blue = (ushort)(ShiftUI.Widget.ForeColor.B * 257); + XAllocColor (DisplayHandle, DefaultColormap, ref xcolor); + foreground = (uint)xcolor.pixel.ToInt32 (); + + xcolor.red = (ushort)(ShiftUI.Widget.BackColor.R * 257); + xcolor.green = (ushort)(ShiftUI.Widget.BackColor.G * 257); + xcolor.blue = (ushort)(ShiftUI.Widget.BackColor.B * 257); + XAllocColor (DisplayHandle, DefaultColormap, ref xcolor); + background = (uint)xcolor.pixel.ToInt32 (); + + uint mask = foreground ^ background; + + XSetForeground (DisplayHandle, gc, 0xffffffff); + XSetBackground (DisplayHandle, gc, background); + XSetFunction (DisplayHandle, gc, GXFunction.GXxor); + XSetPlaneMask (DisplayHandle, gc, mask); + + if ((rect.Width > 0) && (rect.Height > 0)) { + XDrawRectangle (DisplayHandle, hwnd.client_window, gc, rect.Left, rect.Top, rect.Width, rect.Height); + } else { + if (rect.Width > 0) { + XDrawLine (DisplayHandle, hwnd.client_window, gc, rect.X, rect.Y, rect.Right, rect.Y); + } else { + XDrawLine (DisplayHandle, hwnd.client_window, gc, rect.X, rect.Y, rect.X, rect.Bottom); + } + } + XFreeGC (DisplayHandle, gc); + } + + internal override void DoEvents () + { + MSG msg = new MSG (); + + if (OverrideCursorHandle != IntPtr.Zero) { + OverrideCursorHandle = IntPtr.Zero; + } + + while (PeekMessage (ref msg, IntPtr.Zero, 0, 0, (uint)PeekMessageFlags.PM_REMOVE)) { + TranslateMessage (ref msg); + DispatchMessage (ref msg); + } + } + + internal override void EnableWindow (IntPtr handle, bool Enable) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + if (hwnd != null) { + hwnd.Enabled = Enable; + } + } + + internal override void EndLoop (Thread thread) + { + // This is where we one day will shut down the loop for the thread + } + + + internal override IntPtr GetActive () + { + Atom actual_atom; + int actual_format; + int nitems; + int bytes_after; + IntPtr prop = IntPtr.Zero; + IntPtr active = IntPtr.Zero; + + XGetWindowProperty (DisplayHandle, RootWindow, NetAtoms [(int)NA._NET_ACTIVE_WINDOW], 0, 1, false, Atom.XA_WINDOW, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + if ((nitems > 0) && (prop != IntPtr.Zero)) { + active = (IntPtr)Marshal.ReadInt32 (prop); + XFree (prop); + } + + if (active != IntPtr.Zero) { + Hwnd hwnd; + + hwnd = Hwnd.GetObjectFromWindow (active); + if (hwnd != null) { + active = hwnd.Handle; + } else { + active = IntPtr.Zero; + } + } + return active; + } + + internal override void GetCursorInfo (IntPtr cursor, out int width, out int height, out int hotspot_x, out int hotspot_y) + { + throw new NotImplementedException (); + } + + internal override void GetDisplaySize (out Size size) + { + XWindowAttributes attributes=new XWindowAttributes (); + + lock (XlibLock) { + // FIXME - use _NET_WM messages instead? + XGetWindowAttributes (DisplayHandle, XRootWindow (DisplayHandle, ScreenNo), ref attributes); + } + + size = new Size (attributes.width, attributes.height); + } + + internal override SizeF GetAutoScaleSize (Font font) + { + Graphics g; + float width; + string magic_string = "The quick brown fox jumped over the lazy dog."; + double magic_number = 44.549996948242189; + + g = Graphics.FromHwnd (FosterParent); + + width = (float) (g.MeasureString (magic_string, font).Width / magic_number); + return new SizeF (width, font.Height); + } + + internal override IntPtr GetParent (IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + if (hwnd != null && hwnd.parent != null) { + return hwnd.parent.Handle; + } + return IntPtr.Zero; + } + + internal override void GetCursorPos (IntPtr handle, out int x, out int y) + { + IntPtr use_handle; + IntPtr root; + IntPtr child; + int root_x; + int root_y; + int win_x; + int win_y; + int keys_buttons; + + if (handle != IntPtr.Zero) { + use_handle = Hwnd.ObjectFromHandle (handle).client_window; + } else { + use_handle = RootWindow; + } + + lock (XlibLock) { + XQueryPointer (DisplayHandle, use_handle, out root, out child, out root_x, out root_y, out win_x, out win_y, out keys_buttons); + } + + if (handle != IntPtr.Zero) { + x = win_x; + y = win_y; + } else { + x = root_x; + y = root_y; + } + } + + internal override bool GetFontMetrics (Graphics g, Font font, out int ascent, out int descent) + { + return GetFontMetrics (g.GetHdc (), font.ToHfont (), out ascent, out descent); + } + + internal override Point GetMenuOrigin (IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd != null) { + return hwnd.MenuOrigin; + } + return Point.Empty; + } + + internal bool GetMessage (ref MSG msg, IntPtr handle, int wFilterMin, int wFilterMax) + { + XEvent xevent; + bool client; + Hwnd hwnd; + + ProcessNextMessage: + + if (MessageQueue.Count > 0) { + xevent = (XEvent) MessageQueue.Dequeue (); + } else { + UpdateMessageQueue (); + + if (MessageQueue.Count > 0) { + xevent = (XEvent) MessageQueue.Dequeue (); + } else { + if (!PostQuitState) { + msg.hwnd = IntPtr.Zero; + msg.message = Msg.WM_ENTERIDLE; + return true; + } + + // We reset ourselves so GetMessage can be called again + PostQuitState = false; + + return false; + } + } + + // FIXME - handle filtering + + hwnd = Hwnd.GetObjectFromWindow (xevent.AnyEvent.window); + + // Handle messages for windows that are already or are about to be destroyed + if (hwnd == null) { + #if DriverDebug + Console.WriteLine("GetMessage(): Got message {0} for non-existent or already destroyed window {1:X}", xevent.type, xevent.AnyEvent.window.ToInt32()); + #endif + goto ProcessNextMessage; + } + + if (hwnd.client_window == xevent.AnyEvent.window) { + client = true; + //Console.WriteLine("Client message, sending to window {0:X}", msg.hwnd.ToInt32()); + } else { + client = false; + //Console.WriteLine("Non-Client message, sending to window {0:X}", msg.hwnd.ToInt32()); + } + + msg.hwnd = hwnd.Handle; + + // + // If you add a new event to this switch make sure to add it in + // UpdateMessage also unless it is not coming through the X event system. + // + switch (xevent.type) { + case XEventName.KeyPress: { + Keyboard.KeyEvent (FocusWindow, xevent, ref msg); + break; + } + + case XEventName.KeyRelease: { + Keyboard.KeyEvent (FocusWindow, xevent, ref msg); + break; + } + + case XEventName.ButtonPress: { + switch (xevent.ButtonEvent.button) { + case 1: { + MouseState |= MouseButtons.Left; + if (client) { + msg.message = Msg.WM_LBUTTONDOWN; + } else { + msg.message = Msg.WM_NCLBUTTONDOWN; + WholeToScreen (msg.hwnd, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + // TODO: For WM_NCLBUTTONDOWN wParam specifies a hit-test value not the virtual keys down + msg.wParam = GetMousewParam (0); + break; + } + + case 2: { + MouseState |= MouseButtons.Middle; + if (client) { + msg.message = Msg.WM_MBUTTONDOWN; + } else { + msg.message = Msg.WM_NCMBUTTONDOWN; + WholeToScreen (msg.hwnd, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + msg.wParam = GetMousewParam (0); + break; + } + + case 3: { + MouseState |= MouseButtons.Right; + if (client) { + msg.message = Msg.WM_RBUTTONDOWN; + } else { + msg.message = Msg.WM_NCRBUTTONDOWN; + WholeToScreen (msg.hwnd, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + msg.wParam = GetMousewParam (0); + break; + } + + case 4: { + msg.message = Msg.WM_MOUSEWHEEL; + msg.wParam = GetMousewParam (120); + break; + } + + case 5: { + msg.message = Msg.WM_MOUSEWHEEL; + msg.wParam = GetMousewParam (-120); + break; + } + + } + + msg.lParam = (IntPtr) (xevent.ButtonEvent.y << 16 | xevent.ButtonEvent.x); + MousePosition.X = xevent.ButtonEvent.x; + MousePosition.Y = xevent.ButtonEvent.y; + + if (!hwnd.Enabled) { + IntPtr dummy; + + msg.hwnd = hwnd.EnabledHwnd; + XTranslateCoordinates (DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle (msg.hwnd).ClientWindow, xevent.ButtonEvent.x, xevent.ButtonEvent.y, out xevent.ButtonEvent.x, out xevent.ButtonEvent.y, out dummy); + msg.lParam = (IntPtr)(MousePosition.Y << 16 | MousePosition.X); + } + + if (Grab.Hwnd != IntPtr.Zero) { + msg.hwnd = Grab.Hwnd; + } + + if (!ClickPending.Pending) { + ClickPending.Pending = true; + ClickPending.Hwnd = msg.hwnd; + ClickPending.Message = msg.message; + ClickPending.wParam = msg.wParam; + ClickPending.lParam = msg.lParam; + ClickPending.Time = (long)xevent.ButtonEvent.time; + } else { + if ((((long)xevent.ButtonEvent.time - ClickPending.Time) < DoubleClickInterval) && (msg.wParam == ClickPending.wParam) && (msg.lParam == ClickPending.lParam) && (msg.message == ClickPending.Message)) { + // Looks like a genuine double click, clicked twice on the same spot with the same keys + switch (xevent.ButtonEvent.button) { + case 1: { + msg.message = client ? Msg.WM_LBUTTONDBLCLK : Msg.WM_NCLBUTTONDBLCLK; + break; + } + + case 2: { + msg.message = client ? Msg.WM_MBUTTONDBLCLK : Msg.WM_NCMBUTTONDBLCLK; + break; + } + + case 3: { + msg.message = client ? Msg.WM_RBUTTONDBLCLK : Msg.WM_NCRBUTTONDBLCLK; + break; + } + } + } + ClickPending.Pending = false; + } + + break; + } + + case XEventName.ButtonRelease: { + Dnd.HandleButtonRelease (ref xevent); + switch (xevent.ButtonEvent.button) { + case 1: { + if (client) { + msg.message = Msg.WM_LBUTTONUP; + } else { + msg.message = Msg.WM_NCLBUTTONUP; + WholeToScreen (msg.hwnd, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + msg.wParam = GetMousewParam (0); + MouseState &= ~MouseButtons.Left; + break; + } + + case 2: { + if (client) { + msg.message = Msg.WM_MBUTTONUP; + } else { + msg.message = Msg.WM_NCMBUTTONUP; + WholeToScreen (msg.hwnd, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + msg.wParam = GetMousewParam (0); + MouseState &= ~MouseButtons.Middle; + break; + } + + case 3: { + if (client) { + msg.message = Msg.WM_RBUTTONUP; + } else { + msg.message = Msg.WM_NCRBUTTONUP; + WholeToScreen (msg.hwnd, ref xevent.ButtonEvent.x, ref xevent.ButtonEvent.y); + } + msg.wParam = GetMousewParam (0); + MouseState &= ~MouseButtons.Right; + break; + } + + case 4: { + goto ProcessNextMessage; + } + + case 5: { + goto ProcessNextMessage; + } + } + + if (!hwnd.Enabled) { + IntPtr dummy; + + msg.hwnd = hwnd.EnabledHwnd; + XTranslateCoordinates (DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle (msg.hwnd).ClientWindow, xevent.ButtonEvent.x, xevent.ButtonEvent.y, out xevent.ButtonEvent.x, out xevent.ButtonEvent.y, out dummy); + msg.lParam = (IntPtr)(MousePosition.Y << 16 | MousePosition.X); + } + + if (Grab.Hwnd != IntPtr.Zero) { + msg.hwnd = Grab.Hwnd; + } + + msg.lParam = (IntPtr) (xevent.ButtonEvent.y << 16 | xevent.ButtonEvent.x); + MousePosition.X = xevent.ButtonEvent.x; + MousePosition.Y = xevent.ButtonEvent.y; + break; + } + + case XEventName.MotionNotify: { + if (client) { + #if DriverDebugExtra + Console.WriteLine("GetMessage(): Window {0:X} MotionNotify x={1} y={2}", client ? hwnd.client_window.ToInt32() : hwnd.whole_window.ToInt32(), xevent.MotionEvent.x, xevent.MotionEvent.y); + #endif + + if (Dnd.HandleMotionNotify (ref xevent)) + goto ProcessNextMessage; + if (Grab.Hwnd != IntPtr.Zero) { + msg.hwnd = Grab.Hwnd; + } else { + NativeWindow.WndProc (msg.hwnd, Msg.WM_SETCURSOR, msg.hwnd, (IntPtr)HitTest.HTCLIENT); + } + + msg.message = Msg.WM_MOUSEMOVE; + msg.wParam = GetMousewParam (0); + msg.lParam = (IntPtr) (xevent.MotionEvent.y << 16 | xevent.MotionEvent.x & 0xFFFF); + + if (!hwnd.Enabled) { + IntPtr dummy; + + msg.hwnd = hwnd.EnabledHwnd; + XTranslateCoordinates (DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle (msg.hwnd).ClientWindow, xevent.MotionEvent.x, xevent.MotionEvent.y, out xevent.MotionEvent.x, out xevent.MotionEvent.y, out dummy); + msg.lParam = (IntPtr)(MousePosition.Y << 16 | MousePosition.X); + } + + HoverState.X = MousePosition.X = xevent.MotionEvent.x; + HoverState.Y = MousePosition.Y = xevent.MotionEvent.y; + + break; + } else { + #if DriverDebugExtra + Console.WriteLine("GetMessage(): non-client area {0:X} MotionNotify x={1} y={2}", client ? hwnd.client_window.ToInt32() : hwnd.whole_window.ToInt32(), xevent.MotionEvent.x, xevent.MotionEvent.y); + #endif + msg.message = Msg.WM_NCMOUSEMOVE; + msg.lParam = (IntPtr) (xevent.MotionEvent.y << 16 | xevent.MotionEvent.x & 0xFFFF); + + if (!hwnd.Enabled) { + IntPtr dummy; + + msg.hwnd = hwnd.EnabledHwnd; + XTranslateCoordinates (DisplayHandle, xevent.AnyEvent.window, Hwnd.ObjectFromHandle (msg.hwnd).ClientWindow, xevent.MotionEvent.x, xevent.MotionEvent.y, out xevent.MotionEvent.x, out xevent.MotionEvent.y, out dummy); + msg.lParam = (IntPtr)(MousePosition.Y << 16 | MousePosition.X); + } + + #if notyet + // Not sure we need this... + HitTest ht; + ht = NativeWindow.WndProc(hwnd.client_window, Msg.WM_NCHITTEST, IntPtr.Zero, msg.lParam); + #endif + + MousePosition.X = xevent.MotionEvent.x; + MousePosition.Y = xevent.MotionEvent.y; + } + + break; + } + + case XEventName.EnterNotify: { + if (!hwnd.Enabled) { + goto ProcessNextMessage; + } + if (xevent.CrossingEvent.mode != NotifyMode.NotifyNormal) { + goto ProcessNextMessage; + } + msg.message = Msg.WM_MOUSE_ENTER; + HoverState.Timer.Enabled = true; + HoverState.Window = xevent.CrossingEvent.window; + break; + } + + case XEventName.LeaveNotify: { + if (!hwnd.Enabled) { + goto ProcessNextMessage; + } + if (xevent.CrossingEvent.mode != NotifyMode.NotifyNormal) { + goto ProcessNextMessage; + } + msg.message = Msg.WM_MOUSELEAVE; + HoverState.Timer.Enabled = false; + HoverState.Window = IntPtr.Zero; + break; + } + + #if later + case XEventName.CreateNotify: { + if (client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { + msg.message = WM_CREATE; + // Set up CreateStruct + } else { + goto ProcessNextMessage; + } + break; + } + #endif + + + case XEventName.ReparentNotify: { + if (hwnd.parent == null) { // Toplevel + if (xevent.ReparentEvent.parent != IntPtr.Zero) { + // We need to adjust x/y + int dummy_int; + + hwnd.Reparented = true; + + gdk_window_get_geometry (gdk_window_lookup (hwnd.whole_window), out hwnd.x, out hwnd.y, out dummy_int, out dummy_int, out dummy_int); + msg.message = Msg.WM_WINDOWPOSCHANGED; + if (hwnd.opacity != 0xffffffff) { + uint opacity; + + opacity = hwnd.opacity; + XChangeProperty (DisplayHandle, XGetParent (hwnd.whole_window), NetAtoms [(int)NA._NET_WM_WINDOW_OPACITY], Atom.XA_CARDINAL, 32, PropertyMode.Replace, ref opacity, 1); + } + } else { + hwnd.Reparented = false; + goto ProcessNextMessage; + } + } + break; + } + + case XEventName.ConfigureNotify: { + if (!client && (xevent.ConfigureEvent.xevent == xevent.ConfigureEvent.window)) { // Ignore events for children (SubstructureNotify) and client areas + XplatUIWin32.NCCALCSIZE_PARAMS ncp; + IntPtr ptr; + Rectangle rect; + + #if DriverDebugExtra + Console.WriteLine("GetMessage(): Window {0:X} ConfigureNotify x={1} y={2} width={3} height={4}", hwnd.client_window.ToInt32(), xevent.ConfigureEvent.x, xevent.ConfigureEvent.y, xevent.ConfigureEvent.width, xevent.ConfigureEvent.height); + #endif + msg.message = Msg.WM_WINDOWPOSCHANGED; + hwnd.configure_pending = false; + + // We need to adjust our client window to track the resize of whole_window + rect = hwnd.DefaultClientRect; + + ncp = new XplatUIWin32.NCCALCSIZE_PARAMS (); + ptr = Marshal.AllocHGlobal (Marshal.SizeOf (ncp)); + + ncp.rgrc1.left = rect.Left; + ncp.rgrc1.top = rect.Top; + ncp.rgrc1.right = rect.Right; + ncp.rgrc1.bottom = rect.Bottom; + + Marshal.StructureToPtr (ncp, ptr, true); + NativeWindow.WndProc (hwnd.client_window, Msg.WM_NCCALCSIZE, (IntPtr)1, ptr); + ncp = (XplatUIWin32.NCCALCSIZE_PARAMS)Marshal.PtrToStructure (ptr, typeof(XplatUIWin32.NCCALCSIZE_PARAMS)); + Marshal.FreeHGlobal (ptr); + + // FIXME - debug this with Menus, need to set hwnd.ClientRect + + rect = new Rectangle (ncp.rgrc1.left, ncp.rgrc1.top, ncp.rgrc1.right - ncp.rgrc1.left, ncp.rgrc1.bottom - ncp.rgrc1.top); + //Console.WriteLine("CreateOffscreenbuffer..."); +// CreateOffscreenBuffer (ref hwnd.client_offscreen, rect.Width, rect.Height); + + XMoveResizeWindow (DisplayHandle, hwnd.client_window, rect.X, rect.Y, rect.Width, rect.Height); + } else { + goto ProcessNextMessage; + } + + msg.lParam = IntPtr.Zero; // FIXME - Generate LPWINDOWPOS structure and pass on + break; + } + + case XEventName.FocusIn: { + if (!hwnd.Enabled) { + goto ProcessNextMessage; + } + msg.message = Msg.WM_SETFOCUS; + msg.wParam = IntPtr.Zero; + break; + } + + case XEventName.FocusOut: { + if (!hwnd.Enabled) { + goto ProcessNextMessage; + } + msg.message = Msg.WM_KILLFOCUS; + msg.wParam = IntPtr.Zero; + break; + } + + case XEventName.Expose: { + if (PostQuitState) { + goto ProcessNextMessage; + } + + + if (client) { + if (!hwnd.expose_pending) { + goto ProcessNextMessage; + } + } else { + if (!hwnd.nc_expose_pending) { + goto ProcessNextMessage; + } + + switch (hwnd.border_style) { + case FormBorderStyle.Fixed3D: { + Graphics g; + + g = Graphics.FromHwnd (hwnd.whole_window); + ShiftUI.WidgetPaint.DrawBorder3D (g, new Rectangle (0, 0, hwnd.Width, hwnd.Height)); + g.Dispose (); + break; + } + + case FormBorderStyle.FixedSingle: { + Graphics g; + + g = Graphics.FromHwnd (hwnd.whole_window); + ShiftUI.WidgetPaint.DrawBorder (g, new Rectangle (0, 0, hwnd.Width, hwnd.Height), Color.Black, ButtonBorderStyle.Solid); + g.Dispose (); + break; + } + } + #if DriverDebugExtra + Console.WriteLine("GetMessage(): Window {0:X} Exposed non-client area {1},{2} {3}x{4}", hwnd.client_window.ToInt32(), xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height); + #endif + + Rectangle rect = new Rectangle (xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height); + Region region = new Region (rect); + IntPtr hrgn = region.GetHrgn (null); // Graphics object isn't needed + msg.message = Msg.WM_NCPAINT; + msg.wParam = hrgn; + hwnd.nc_expose_pending = false; + break; + } + #if DriverDebugExtra + Console.WriteLine("GetMessage(): Window {0:X} Exposed area {1},{2} {3}x{4}", hwnd.client_window.ToInt32(), xevent.ExposeEvent.x, xevent.ExposeEvent.y, xevent.ExposeEvent.width, xevent.ExposeEvent.height); + #endif + if (Caret.Visible == 1) { + Caret.Paused = true; + HideCaret (); + } + + if (Caret.Visible == 1) { + ShowCaret (); + Caret.Paused = false; + } + msg.message = Msg.WM_PAINT; + break; + } + + case XEventName.DestroyNotify: { + + // This is a bit tricky, we don't receive our own DestroyNotify, we only get those for our children + hwnd = Hwnd.ObjectFromHandle (xevent.DestroyWindowEvent.window); + + // We may get multiple for the same window, act only one the first (when Hwnd still knows about it) + if (hwnd.client_window == xevent.DestroyWindowEvent.window) { + msg.hwnd = hwnd.client_window; + msg.message = Msg.WM_DESTROY; + hwnd.Dispose (); + + #if DriverDebug + Console.WriteLine("Got DestroyNotify on Window {0:X}", msg.hwnd.ToInt32()); + #endif + } else { + goto ProcessNextMessage; + } + + break; + } + + case XEventName.ClientMessage: { + if (Dnd.HandleClientMessage (ref xevent)) { + goto ProcessNextMessage; + } + + if (xevent.ClientMessageEvent.message_type == (IntPtr)AsyncAtom) { + XplatUIDriverSupport.ExecuteClientMessage ((GCHandle)xevent.ClientMessageEvent.ptr1); + break; + } + + if (xevent.ClientMessageEvent.message_type == (IntPtr)HoverState.Atom) { + msg.message = Msg.WM_MOUSEHOVER; + msg.wParam = GetMousewParam (0); + msg.lParam = (IntPtr) (xevent.ClientMessageEvent.ptr1); + break; + } + + if (xevent.ClientMessageEvent.message_type == (IntPtr)PostAtom) { + msg.hwnd = xevent.ClientMessageEvent.ptr1; + msg.message = (Msg) xevent.ClientMessageEvent.ptr2.ToInt32 (); + msg.wParam = xevent.ClientMessageEvent.ptr3; + msg.lParam = xevent.ClientMessageEvent.ptr4; + break; + } + + #if dontcare + if (xevent.ClientMessageEvent.message_type == (IntPtr)NetAtoms[(int)NA._XEMBED]) { + Console.WriteLine("GOT EMBED MESSAGE {0:X}", xevent.ClientMessageEvent.ptr2.ToInt32()); + break; + } + #endif + + if (xevent.ClientMessageEvent.message_type == (IntPtr)NetAtoms [(int)NA.WM_PROTOCOLS]) { + if (xevent.ClientMessageEvent.ptr1 == (IntPtr)NetAtoms [(int)NA.WM_DELETE_WINDOW]) { + msg.message = Msg.WM_CLOSE; + Graphics.FromHdcInternal (IntPtr.Zero); + break; + } + + // We should not get this, but I'll leave the code in case we need it in the future + if (xevent.ClientMessageEvent.ptr1 == (IntPtr)NetAtoms [(int)NA.WM_TAKE_FOCUS]) { + goto ProcessNextMessage; + } + } + break; + } + + case XEventName.TimerNotify: { + xevent.TimerNotifyEvent.handler (this, EventArgs.Empty); + break; + } + + default: { + goto ProcessNextMessage; + } + } + + return true; + } + + internal override bool GetText (IntPtr handle, out string text) + { + IntPtr textptr; + + textptr = IntPtr.Zero; + + lock (XlibLock) { + // FIXME - use _NET properties + XFetchName (DisplayHandle, Hwnd.ObjectFromHandle (handle).whole_window, ref textptr); + } + if (textptr != IntPtr.Zero) { + text = Marshal.PtrToStringAnsi (textptr); + XFree (textptr); + return true; + } else { + text = ""; + return false; + } + } + + internal override void GetWindowPos (IntPtr handle, bool is_toplevel, out int x, out int y, out int width, out int height, out int client_width, out int client_height) + { + Hwnd hwnd; + Rectangle rect; + + hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd != null) { + x = hwnd.x; + y = hwnd.y; + width = hwnd.width; + height = hwnd.height; + + rect = Hwnd.GetClientRectangle (hwnd.border_style, hwnd.menu, hwnd.title_style, hwnd.caption_height, hwnd.tool_caption_height, width, height); + + client_width = rect.Width; + client_height = rect.Height; + + return; + } + + // Should we throw an exception or fail silently? + // throw new ArgumentException("Called with an invalid window handle", "handle"); + + x = 0; + y = 0; + width = 0; + height = 0; + client_width = 0; + client_height = 0; + } + + internal override FormWindowState GetWindowState (IntPtr handle) + { + Atom actual_atom; + int actual_format; + int nitems; + int bytes_after; + IntPtr prop = IntPtr.Zero; + IntPtr atom; + int maximized; + bool minimized; + XWindowAttributes attributes; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + maximized = 0; + minimized = false; + XGetWindowProperty (DisplayHandle, hwnd.whole_window, NetAtoms [(int)NA._NET_WM_STATE], 0, 256, false, Atom.XA_ATOM, out actual_atom, out actual_format, out nitems, out bytes_after, ref prop); + if ((nitems > 0) && (prop != IntPtr.Zero)) { + for (int i = 0; i < nitems; i++) { + atom = (IntPtr)Marshal.ReadInt32 (prop, i * 4); + if ((atom == (IntPtr)NetAtoms [(int)NA._NET_WM_STATE_MAXIMIZED_HORZ]) || (atom == (IntPtr)NetAtoms [(int)NA._NET_WM_STATE_MAXIMIZED_VERT])) { + maximized++; + } else if (atom == (IntPtr)NetAtoms [(int)NA._NET_WM_STATE_HIDDEN]) { + minimized = true; + } + } + XFree (prop); + } + + if (minimized) { + return FormWindowState.Minimized; + } else if (maximized == 2) { + return FormWindowState.Maximized; + } + + attributes = new XWindowAttributes (); + XGetWindowAttributes (DisplayHandle, handle, ref attributes); + if (attributes.map_state == MapState.IsUnmapped) { + throw new NotSupportedException ("Cannot retrieve the state of an unmapped window"); + } + + + return FormWindowState.Normal; + } + + internal override void GrabInfo (out IntPtr handle, out bool GrabConfined, out Rectangle GrabArea) + { + handle = Grab.Hwnd; + GrabConfined = Grab.Confined; + GrabArea = Grab.Area; + } + + internal override void GrabWindow (IntPtr handle, IntPtr confine_to_handle) + { + Hwnd hwnd; + IntPtr confine_to_window; + + confine_to_window = IntPtr.Zero; + + if (confine_to_handle != IntPtr.Zero) { + XWindowAttributes attributes = new XWindowAttributes (); + + hwnd = Hwnd.ObjectFromHandle (confine_to_handle); + + lock (XlibLock) { + XGetWindowAttributes (DisplayHandle, hwnd.client_window, ref attributes); + } + Grab.Area.X = attributes.x; + Grab.Area.Y = attributes.y; + Grab.Area.Width = attributes.width; + Grab.Area.Height = attributes.height; + Grab.Confined = true; + confine_to_window = hwnd.client_window; + } + + Grab.Hwnd = handle; + + hwnd = Hwnd.ObjectFromHandle (handle); + + lock (XlibLock) { + XGrabPointer (DisplayHandle, hwnd.client_window, false, + EventMask.ButtonPressMask | EventMask.ButtonMotionMask | + EventMask.ButtonReleaseMask | EventMask.PointerMotionMask, + GrabMode.GrabModeAsync, GrabMode.GrabModeAsync, confine_to_window, 0, 0); + } + } + + internal override void UngrabWindow (IntPtr hwnd) + { + lock (XlibLock) { + XUngrabPointer (DisplayHandle, 0); + XFlush (DisplayHandle); + } + Grab.Hwnd = IntPtr.Zero; + Grab.Confined = false; + } + + internal override void HandleException (Exception e) + { + StackTrace st = new StackTrace (e, true); + Console.WriteLine ("Exception '{0}'", e.Message + st.ToString ()); + Console.WriteLine ("{0}{1}", e.Message, st.ToString ()); + } + + internal override void Invalidate (IntPtr handle, Rectangle rc, bool clear) + { + Hwnd hwnd; + XEvent xevent; + + hwnd = Hwnd.ObjectFromHandle (handle); + + + xevent = new XEvent (); + xevent.type = XEventName.Expose; + xevent.ExposeEvent.display = DisplayHandle; + xevent.ExposeEvent.window = hwnd.client_window; + + if (clear) { + xevent.ExposeEvent.x = hwnd.X; + xevent.ExposeEvent.y = hwnd.Y; + xevent.ExposeEvent.width = hwnd.Width; + xevent.ExposeEvent.height = hwnd.Height; + } else { + xevent.ExposeEvent.x = rc.X; + xevent.ExposeEvent.y = rc.Y; + xevent.ExposeEvent.width = rc.Width; + xevent.ExposeEvent.height = rc.Height; + } + + AddExpose (xevent); + } + + internal override bool IsEnabled (IntPtr handle) + { + return Hwnd.ObjectFromHandle (handle).Enabled; + } + + internal override bool IsVisible (IntPtr handle) + { + return Hwnd.ObjectFromHandle (handle).visible; + } + + internal override void KillTimer (Timer timer) + { + lock (TimerList) { + TimerList.Remove (timer); + } + } + + internal override void MenuToScreen (IntPtr handle, ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + IntPtr child; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + lock (XlibLock) { + XTranslateCoordinates (DisplayHandle, hwnd.whole_window, RootWindow, x, y, out dest_x_return, out dest_y_return, out child); + } + + x = dest_x_return; + y = dest_y_return; + } + + internal override void OverrideCursor (IntPtr cursor) + { + OverrideCursorHandle = cursor; + } + + internal PaintEventArgs PaintEventStart (IntPtr handle, bool client) + { + PaintEventArgs paint_event; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + if (Caret.Visible == 1) { + Caret.Paused = true; + HideCaret (); + } + + if (client) { + // handle backing store + IntPtr gdk_window = gdk_window_lookup (hwnd.client_window); + IntPtr gdk_pixmap = NewPixmap (gdk_window, hwnd.ClientRect.Width, hwnd.ClientRect.Height); + + backing_store [gdk_window] = gdk_pixmap; + + hwnd.client_dc = Graphics.FromHwnd (gdk_x11_drawable_get_xid (gdk_pixmap)); + hwnd.client_dc.SetClip (hwnd.invalid); + paint_event = new PaintEventArgs (hwnd.client_dc, hwnd.invalid); + hwnd.expose_pending = false; + + return paint_event; + } else { + hwnd.client_dc = Graphics.FromHwnd (hwnd.whole_window); + paint_event = new PaintEventArgs (hwnd.client_dc, new Rectangle (0, 0, hwnd.width, hwnd.height)); + hwnd.nc_expose_pending = false; + + return paint_event; + } + } + + internal void PaintEventEnd (IntPtr handle, bool client) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + hwnd.client_dc.Flush (); + + if (client) { + // clients are already drawn to a backing store pixmap + IntPtr gdk_window = gdk_window_lookup (hwnd.client_window); + IntPtr gdk_pixmap = (IntPtr)backing_store [gdk_window]; + + BlitOffscreenPixmap (gdk_pixmap, gdk_window, hwnd.Invalid); + + g_object_unref (gdk_pixmap); + backing_store.Remove (gdk_pixmap); + + hwnd.ClearInvalidArea (); + } + + hwnd.client_dc.Dispose (); + hwnd.client_dc = null; + + if (Caret.Visible == 1) { + ShowCaret (); + Caret.Paused = false; + } + } + + internal bool PeekMessage (ref MSG msg, IntPtr hWnd, int wFilterMin, int wFilterMax, uint flags) + { + bool pending; + + // FIXME - imlement filtering + + if ((flags & (uint)PeekMessageFlags.PM_REMOVE) == 0) { + throw new NotImplementedException ("PeekMessage PM_NOREMOVE is not implemented yet"); // FIXME - Implement PM_NOREMOVE flag + } + + pending = false; + if (MessageQueue.Count > 0) { + pending = true; + } else { + // Only call UpdateMessageQueue if real events are pending + // otherwise we go to sleep on the socket + if (XPending (DisplayHandle) != 0) { + UpdateMessageQueue (); + pending = true; + } + } + + CheckTimers (DateTime.Now); + + if (!pending) { + return false; + } + return GetMessage (ref msg, hWnd, wFilterMin, wFilterMax); + } + + // FIXME - I think this should just enqueue directly + internal override bool PostMessage (IntPtr handle, Msg message, IntPtr wparam, IntPtr lparam) + { + XEvent xevent = new XEvent (); + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + xevent.type = XEventName.ClientMessage; + xevent.ClientMessageEvent.display = DisplayHandle; + + if (hwnd != null) { + xevent.ClientMessageEvent.window = hwnd.whole_window; + } else { + xevent.ClientMessageEvent.window = IntPtr.Zero; + } + + xevent.ClientMessageEvent.message_type = (IntPtr) PostAtom; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = handle; + xevent.ClientMessageEvent.ptr2 = (IntPtr) message; + xevent.ClientMessageEvent.ptr3 = wparam; + xevent.ClientMessageEvent.ptr4 = lparam; + + MessageQueue.Enqueue (xevent); + + return true; + } + + internal override void PostQuitMessage (int exitCode) + { + XFlush (DisplayHandle); + PostQuitState = true; + + // Remove our display handle from S.D + Graphics.FromHdcInternal (IntPtr.Zero); + } + + internal override void ScreenToClient (IntPtr handle, ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + IntPtr child; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + lock (XlibLock) { + XTranslateCoordinates (DisplayHandle, RootWindow, hwnd.client_window, x, y, out dest_x_return, out dest_y_return, out child); + } + + x = dest_x_return; + y = dest_y_return; + } + + internal override void ScreenToMenu (IntPtr handle, ref int x, ref int y) + { + int dest_x_return; + int dest_y_return; + IntPtr child; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + lock (XlibLock) { + XTranslateCoordinates (DisplayHandle, RootWindow, hwnd.whole_window, x, y, out dest_x_return, out dest_y_return, out child); + } + + x = dest_x_return; + y = dest_y_return; + } + + internal override void ScrollWindow (IntPtr handle, Rectangle area, int XAmount, int YAmount, bool with_children) + { + Hwnd hwnd; + IntPtr gc; + XGCValues gc_values; + + hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd.invalid != Rectangle.Empty) { + // BIG FAT WARNING. This only works with how we use this function right now + // where we basically still scroll the whole window, but work around areas + // that are covered by our children + + hwnd.invalid.X += XAmount; + hwnd.invalid.Y += YAmount; + + if (hwnd.invalid.X < 0) { + hwnd.invalid.Width += hwnd.invalid.X; + hwnd.invalid.X = 0; + } + + if (hwnd.invalid.Y < 0) { + hwnd.invalid.Height += hwnd.invalid.Y; + hwnd.invalid.Y = 0; + } + } + + gc_values = new XGCValues (); + + if (with_children) { + gc_values.subwindow_mode = GCSubwindowMode.IncludeInferiors; + } + + gc = XCreateGC (DisplayHandle, hwnd.client_window, 0, ref gc_values); + + XCopyArea (DisplayHandle, hwnd.client_window, hwnd.client_window, gc, area.X - XAmount, area.Y - YAmount, area.Width, area.Height, area.X, area.Y); + + // Generate an expose for the area exposed by the horizontal scroll + if (XAmount > 0) { + hwnd.AddInvalidArea (area.X, area.Y, XAmount, area.Height); + } else if (XAmount < 0) { + hwnd.AddInvalidArea (XAmount + area.X + area.Width, area.Y, -XAmount, area.Height); + } + + // Generate an expose for the area exposed by the vertical scroll + if (YAmount > 0) { + hwnd.AddInvalidArea (area.X, area.Y, area.Width, YAmount); + } else if (YAmount < 0) { + hwnd.AddInvalidArea (area.X, YAmount + area.Y + area.Height, area.Width, -YAmount); + } + XFreeGC (DisplayHandle, gc); + + UpdateWindow (handle); + } + + internal override void ScrollWindow (IntPtr handle, int XAmount, int YAmount, bool with_children) + { + Hwnd hwnd; + + hwnd = Hwnd.GetObjectFromWindow (handle); + + ScrollWindow (handle, hwnd.ClientRect, XAmount, YAmount, with_children); + } + + internal override void SendAsyncMethod (AsyncMethodData method) + { + XEvent xevent = new XEvent (); + + xevent.type = XEventName.ClientMessage; + xevent.ClientMessageEvent.display = DisplayHandle; + xevent.ClientMessageEvent.window = FosterParent; + xevent.ClientMessageEvent.message_type = (IntPtr)AsyncAtom; + xevent.ClientMessageEvent.format = 32; + xevent.ClientMessageEvent.ptr1 = (IntPtr) GCHandle.Alloc (method); + + MessageQueue.EnqueueLocked (xevent); + + WakeupMain (); + } + + internal override IntPtr SendMessage (IntPtr hwnd, Msg message, IntPtr wParam, IntPtr lParam) + { + return NativeWindow.WndProc (hwnd, message, wParam, lParam); + } + + internal override void SetAllowDrop (IntPtr handle, bool value) + { + // We allow drop on all windows + } + + internal override DragDropEffects StartDrag (IntPtr handle, object data, + DragDropEffects allowed_effects) + { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd == null) + throw new ArgumentException ("Attempt to begin drag from invalid window handle (" + handle.ToInt32 () + ")."); + + return Dnd.StartDrag (hwnd.client_window, data, allowed_effects); + } + + internal override void SetBorderStyle (IntPtr handle, FormBorderStyle border_style) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + hwnd.border_style = border_style; + + XMoveResizeWindow (DisplayHandle, hwnd.client_window, hwnd.ClientRect.X, hwnd.ClientRect.Y, hwnd.ClientRect.Width, hwnd.ClientRect.Height); + + InvalidateWholeWindow (handle); + } + + internal override void SetCaretPos (IntPtr handle, int x, int y) + { + if (Caret.Hwnd == handle) { + Caret.Timer.Stop (); + HideCaret (); + + Caret.X = x; + Caret.Y = y; + + if (Caret.Visible == 1) { + ShowCaret (); + Caret.Timer.Start (); + } + } + } + + internal override void SetCursor (IntPtr handle, IntPtr cursor) + { + Hwnd hwnd; + + if (OverrideCursorHandle == IntPtr.Zero) { + if ((LastCursorWindow == handle) && (LastCursorHandle == cursor)) { + return; + } + + LastCursorHandle = cursor; + LastCursorWindow = handle; + + hwnd = Hwnd.ObjectFromHandle (handle); + lock (XlibLock) { + if (cursor != IntPtr.Zero) { + XDefineCursor (DisplayHandle, hwnd.whole_window, cursor); + } else { + XUndefineCursor (DisplayHandle, hwnd.whole_window); + } + } + return; + } + + hwnd = Hwnd.ObjectFromHandle (handle); + lock (XlibLock) { + XDefineCursor (DisplayHandle, hwnd.whole_window, OverrideCursorHandle); + } + } + + internal override void SetCursorPos (IntPtr handle, int x, int y) + { + if (handle == IntPtr.Zero) { + lock (XlibLock) { + XWarpPointer (DisplayHandle, IntPtr.Zero, IntPtr.Zero, 0, 0, 0, 0, x, y); + } + return; + } else { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + lock (XlibLock) { + XWarpPointer (DisplayHandle, IntPtr.Zero, hwnd.client_window, 0, 0, 0, 0, x, y); + } + return; + } + } + + internal override void SetFocus (IntPtr handle) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + if (FocusWindow != IntPtr.Zero) { + PostMessage (FocusWindow, Msg.WM_KILLFOCUS, hwnd.client_window, IntPtr.Zero); + } + PostMessage (hwnd.client_window, Msg.WM_SETFOCUS, FocusWindow, IntPtr.Zero); + FocusWindow = hwnd.client_window; + + //XSetInputFocus(DisplayHandle, Hwnd.ObjectFromHandle(handle).client_window, RevertTo.None, IntPtr.Zero); + } + + internal override void SetIcon (IntPtr handle, Icon icon) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + if (hwnd != null) { + SetIcon (hwnd, icon); + } + } + + internal override void SetMenu (IntPtr handle, Menu menu) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + hwnd.menu = menu; + + // FIXME - do we need to trigger some resize? + } + + internal override void SetModal (IntPtr handle, bool Modal) + { + if (Modal) { + ModalWindows.Push (handle); + } else { + if (ModalWindows.Contains (handle)) { + ModalWindows.Pop (); + } + if (ModalWindows.Count > 0) { + Activate ((IntPtr)ModalWindows.Peek ()); + } + } + } + + internal override IntPtr SetParent (IntPtr handle, IntPtr parent) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + hwnd.parent = Hwnd.ObjectFromHandle (parent); + + lock (XlibLock) { + #if DriverDebug + Console.WriteLine("Parent for window {0:X} / {1:X} = {2:X} (Handle:{3:X})", hwnd.ClientWindow.ToInt32(), hwnd.WholeWindow.ToInt32(), hwnd.parent != null ? hwnd.parent.Handle.ToInt32() : 0, parent.ToInt32()); + #endif + XReparentWindow (DisplayHandle, hwnd.whole_window, hwnd.parent.client_window, hwnd.x, hwnd.y); + } + + return IntPtr.Zero; + } + + internal override void SetTimer (Timer timer) + { + lock (TimerList) { + TimerList.Add (timer); + } + WakeupMain (); + } + + internal bool SetTopmost (IntPtr handle, IntPtr handle_owner, bool enabled) + { + Hwnd hwnd; + Hwnd hwnd_owner; + + hwnd = Hwnd.ObjectFromHandle (handle); + + if (handle_owner != IntPtr.Zero) { + hwnd_owner = Hwnd.ObjectFromHandle (handle_owner); + } else { + hwnd_owner = null; + } + + if (enabled) { + lock (XlibLock) { + if (hwnd_owner != null) { + XSetTransientForHint (DisplayHandle, hwnd.whole_window, hwnd_owner.whole_window); + } else { + XSetTransientForHint (DisplayHandle, hwnd.whole_window, FosterParent); + } + } + } else { + lock (XlibLock) { + XDeleteProperty (DisplayHandle, hwnd.whole_window, (int)Atom.XA_WM_TRANSIENT_FOR); + } + } + return true; + } + + internal bool SetVisible (IntPtr handle, bool visible) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + hwnd.visible = visible; + + lock (XlibLock) { + if (visible) { + if (ShiftUI.Widget.FromHandle (handle) is Form) { + FormWindowState s; + + s = ((Form)ShiftUI.Widget.FromHandle (handle)).WindowState; + + XMapWindow (DisplayHandle, hwnd.whole_window); + XMapWindow (DisplayHandle, hwnd.client_window); + + switch (s) { + case FormWindowState.Minimized: SetWindowState (handle, FormWindowState.Minimized); break; + case FormWindowState.Maximized: SetWindowState (handle, FormWindowState.Maximized); break; + } + } else { + XMapWindow (DisplayHandle, hwnd.whole_window); + XMapWindow (DisplayHandle, hwnd.client_window); + } + } else { + XUnmapWindow (DisplayHandle, hwnd.whole_window); + } + } + return true; + } + + internal override void SetWindowMinMax (IntPtr handle, Rectangle maximized, Size min, Size max) + { + Hwnd hwnd; + XSizeHints hints; + + hwnd = Hwnd.ObjectFromHandle (handle); + if (hwnd == null) { + return; + } + + hints = new XSizeHints (); + + if (min != Size.Empty) { + hints.flags = (IntPtr)((int)hints.flags | (int)XSizeHintsFlags.PMinSize); + hints.min_width = min.Width; + hints.min_height = min.Height; + } + + if (max != Size.Empty) { + hints.flags = (IntPtr)((int)hints.flags | (int)XSizeHintsFlags.PMaxSize); + hints.max_width = max.Width; + hints.max_height = max.Height; + } + + XSetWMNormalHints (DisplayHandle, hwnd.whole_window, ref hints); + + if (maximized != Rectangle.Empty) { + hints.flags = (IntPtr)XSizeHintsFlags.PPosition; + hints.x = maximized.X; + hints.y = maximized.Y; + hints.width = maximized.Width; + hints.height = maximized.Height; + + // Metacity does not seem to follow this constraint for maximized (zoomed) windows + XSetZoomHints (DisplayHandle, hwnd.whole_window, ref hints); + } + } + + + internal override void SetWindowPos (IntPtr handle, int x, int y, int width, int height) + { + Hwnd hwnd; + Rectangle client_rect; + + hwnd = Hwnd.ObjectFromHandle (handle); + + // X requires a sanity check for width & height; otherwise it dies + if (hwnd.zero_sized && width > 0 && height > 0) { + if (hwnd.visible) { + XMapWindow (DisplayHandle, hwnd.whole_window); + } + hwnd.zero_sized = false; + } + + if (width < 1) { + hwnd.zero_sized = true; + XUnmapWindow (DisplayHandle, hwnd.whole_window); + } + + if (height < 1) { + hwnd.zero_sized = true; + XUnmapWindow (DisplayHandle, hwnd.whole_window); + } + + client_rect = Hwnd.GetClientRectangle (hwnd.border_style, hwnd.menu, hwnd.title_style, hwnd.caption_height, hwnd.tool_caption_height, width, height); + + // Save a server roundtrip (and prevent a feedback loop) + if ((hwnd.x == x) && (hwnd.y == y) && + (hwnd.width == width) && (hwnd.height == height) && + (hwnd.ClientRect == client_rect)) { + return; + } + + if (!hwnd.zero_sized) { + lock (XlibLock) { + XMoveResizeWindow (DisplayHandle, hwnd.whole_window, x, y, width, height); + XMoveResizeWindow (DisplayHandle, hwnd.client_window, client_rect.X, client_rect.Y, client_rect.Width, client_rect.Height); + } + } + + // Prevent an old queued ConfigureNotify from setting our width with outdated data, set it now + hwnd.width = width; + hwnd.height = height; + } + + internal override void SetWindowState (IntPtr handle, FormWindowState state) + { + FormWindowState current_state; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + current_state = GetWindowState (handle); + + if (current_state == state) { + return; + } + + switch (state) { + case FormWindowState.Normal: { + lock (XlibLock) { + if (current_state == FormWindowState.Minimized) { + XMapWindow (DisplayHandle, hwnd.whole_window); + XMapWindow (DisplayHandle, hwnd.client_window); + } else if (current_state == FormWindowState.Maximized) { + SendNetWMMessage (hwnd.whole_window, (IntPtr)(uint)NetAtoms [(int)NA._NET_WM_STATE], (IntPtr)2 /* toggle */, (IntPtr)NetAtoms [(int)NA._NET_WM_STATE_MAXIMIZED_HORZ], (IntPtr)NetAtoms [(int)NA._NET_WM_STATE_MAXIMIZED_VERT]); + } + } + Activate (handle); + return; + } + + case FormWindowState.Minimized: { + lock (XlibLock) { + if (current_state == FormWindowState.Maximized) { + SendNetWMMessage (hwnd.whole_window, (IntPtr)NetAtoms [(int)NA._NET_WM_STATE], (IntPtr)2 /* toggle */, (IntPtr)NetAtoms [(int)NA._NET_WM_STATE_MAXIMIZED_HORZ], (IntPtr)NetAtoms [(int)NA._NET_WM_STATE_MAXIMIZED_VERT]); + } + XIconifyWindow (DisplayHandle, hwnd.whole_window, ScreenNo); + } + return; + } + + case FormWindowState.Maximized: { + lock (XlibLock) { + if (current_state == FormWindowState.Minimized) { + XMapWindow (DisplayHandle, hwnd.whole_window); + XMapWindow (DisplayHandle, hwnd.client_window); + } + + SendNetWMMessage (hwnd.whole_window, (IntPtr)NetAtoms [(int)NA._NET_WM_STATE], (IntPtr)1 /* Add */, (IntPtr)NetAtoms [(int)NA._NET_WM_STATE_MAXIMIZED_HORZ], (IntPtr)NetAtoms [(int)NA._NET_WM_STATE_MAXIMIZED_VERT]); + } + Activate (handle); + return; + } + } + } + + internal override void SetWindowStyle (IntPtr handle, CreateParams cp) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + SetHwndStyles (hwnd, cp); + SetWMStyles (hwnd, cp); + } + + internal override void SetWindowTransparency (IntPtr handle, double transparency, Color key) + { + Hwnd hwnd; + uint opacity; + + hwnd = Hwnd.ObjectFromHandle (handle); + + if (hwnd == null) { + return; + } + + hwnd.opacity = (uint)(0xffffffff * transparency); + opacity = hwnd.opacity; + + if (hwnd.reparented) { + XChangeProperty (DisplayHandle, XGetParent (hwnd.whole_window), NetAtoms [(int)NA._NET_WM_WINDOW_OPACITY], Atom.XA_CARDINAL, 32, PropertyMode.Replace, ref opacity, 1); + } + } + + internal override bool SetZOrder (IntPtr handle, IntPtr after_handle, bool top, bool bottom) + { + Hwnd hwnd = Hwnd.ObjectFromHandle (handle); + + if (top) { + lock (XlibLock) { + XRaiseWindow (DisplayHandle, hwnd.whole_window); + } + return true; + } else if (!bottom) { + Hwnd after_hwnd = null; + + if (after_handle != IntPtr.Zero) { + after_hwnd = Hwnd.ObjectFromHandle (after_handle); + } + + XWindowChanges values = new XWindowChanges (); + + if (after_hwnd == null) { + throw new ArgumentNullException ("after_handle", "Need sibling to adjust z-order"); + } + values.sibling = after_hwnd.whole_window; + values.stack_mode = StackMode.Below; + + lock (XlibLock) { + XConfigureWindow (DisplayHandle, hwnd.whole_window, ChangeWindowFlags.CWStackMode | ChangeWindowFlags.CWSibling, ref values); + } + } else { + // Bottom + lock (XlibLock) { + XLowerWindow (DisplayHandle, hwnd.whole_window); + } + return true; + } + return false; + } + + internal override void ShowCursor (bool show) + { + ; // FIXME - X11 doesn't 'hide' the cursor. we could create an empty cursor + } + + internal override object StartLoop (Thread thread) + { + // Future place for prepping a new queue for this specific thread + return thread; + } + + internal override TransparencySupport SupportsTransparency () + { + // We need to check if the x compositing manager is running + return TransparencySupport.Get; + } + + internal override bool SystrayAdd (IntPtr handle, string tip, Icon icon, out ToolTip tt) + { + GetSystrayManagerWindow (); + + if (SystrayMgrWindow != IntPtr.Zero) { + uint[] atoms; + XSizeHints size_hints; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + #if DriverDebug + Console.WriteLine("Adding Systray Whole:{0:X}, Client:{1:X}", hwnd.whole_window.ToInt32(), hwnd.client_window.ToInt32()); + #endif + + XUnmapWindow (DisplayHandle, hwnd.whole_window); + XUnmapWindow (DisplayHandle, hwnd.client_window); + + // Oh boy. + gdk_window_destroy (gdk_window_lookup (hwnd.client_window)); + hwnd.client_window = hwnd.whole_window; + + size_hints = new XSizeHints (); + + size_hints.flags = (IntPtr)(XSizeHintsFlags.PMinSize | XSizeHintsFlags.PMaxSize | XSizeHintsFlags.PBaseSize); + size_hints.min_width = icon.Width; + size_hints.min_height = icon.Height; + + size_hints.max_width = icon.Width; + size_hints.max_height = icon.Height; + + size_hints.base_width = icon.Width; + size_hints.base_height = icon.Height; + XSetWMNormalHints (DisplayHandle, hwnd.whole_window, ref size_hints); + + atoms = new uint [2]; + atoms [0] = 1; // Version 1 + atoms [1] = 0; // We're not mapped + + // This line cost me 3 days... + XChangeProperty (DisplayHandle, hwnd.whole_window, NetAtoms [(int)NA._XEMBED_INFO], NetAtoms [(int)NA._XEMBED_INFO], 32, PropertyMode.Replace, atoms, 2); + + // Need to pick some reasonable defaults + tt = new ToolTip (); + tt.AutomaticDelay = 100; + tt.InitialDelay = 250; + tt.ReshowDelay = 250; + tt.ShowAlways = true; + + if ((tip != null) && (tip != string.Empty)) { + tt.SetToolTip (ShiftUI.Widget.FromHandle (handle), tip); + tt.Active = true; + } else { + tt.Active = false; + } + + // Make sure the window exists + XSync (DisplayHandle, hwnd.whole_window); + + SendNetClientMessage (SystrayMgrWindow, (IntPtr)NetAtoms [(int)NA._NET_SYSTEM_TRAY_OPCODE], IntPtr.Zero, (IntPtr)SystrayRequest.SYSTEM_TRAY_REQUEST_DOCK, hwnd.whole_window); + return true; + } + + tt = null; + return false; + } + + internal override bool SystrayChange (IntPtr handle, string tip, Icon icon, ref ToolTip tt) + { + ShiftUI.Widget Widget; + + Widget = ShiftUI.Widget.FromHandle (handle); + if (Widget != null && tt != null) { + tt.SetToolTip (Widget, tip); + tt.Active = true; + return true; + } else { + return false; + } + } + + internal override void SystrayRemove (IntPtr handle, ref ToolTip tt) + { + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + XUnmapWindow (DisplayHandle, hwnd.whole_window); + SetParent (hwnd.whole_window, FosterParent); + + // The caller can now re-dock it later... + if (tt != null) { + tt.Dispose (); + tt = null; + } + } + + internal override bool Text (IntPtr handle, string text) + { + lock (XlibLock) { + gdk_window_set_title (gdk_window_lookup (Hwnd.ObjectFromHandle (handle).whole_window), text); + } + return true; + } + + internal override bool TranslateMessage (ref MSG msg) + { + return Keyboard.TranslateMessage (ref msg); + } + + internal override void UpdateWindow (IntPtr handle) + { + XEvent xevent; + Hwnd hwnd; + + hwnd = Hwnd.ObjectFromHandle (handle); + + if (!hwnd.visible || hwnd.expose_pending) { + return; + } + + #if not + SendMessage(handle, Msg.WM_PAINT, IntPtr.Zero, IntPtr.Zero); + #else + xevent = new XEvent (); + xevent.type = XEventName.Expose; + xevent.ExposeEvent.display = DisplayHandle; + xevent.ExposeEvent.window = hwnd.client_window; + + MessageQueue.Enqueue (xevent); + hwnd.expose_pending = true; + #endif + } + + internal static IntPtr NewPixmap (IntPtr gdk_window, int width, int height) + { + return gdk_pixmap_new (gdk_window, width, height, 24); // FIXME: instead of 24, get the correct display depth + } + + internal static void BlitOffscreenPixmap (IntPtr gdk_pixmap, IntPtr dest_drawable, Rectangle area) + { + IntPtr gdk_gc = gdk_gc_new (gdk_pixmap); + + gdk_draw_drawable (dest_drawable, gdk_gc, gdk_pixmap, area.X, area.Y, area.X, area.Y, area.Width, area.Height); + + g_object_unref (gdk_gc); + } + #endregion // Public Static Methods + + #region Events + internal override event EventHandler Idle; + #endregion // Events + + #region X11 Imports + [DllImport ("libX11", EntryPoint="XSynchronize")] + internal extern static IntPtr XSynchronize (IntPtr display, bool onoff); + + [DllImport ("libX11", EntryPoint="XCreateWindow")] + internal extern static IntPtr XCreateWindow (IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, int depth, int xclass, IntPtr visual, SetWindowValuemask valuemask, ref XSetWindowAttributes attributes); + [DllImport ("libX11", EntryPoint="XCreateSimpleWindow")] + internal extern static IntPtr XCreateSimpleWindow (IntPtr display, IntPtr parent, int x, int y, int width, int height, int border_width, int border, int background); + [DllImport ("libX11", EntryPoint="XMapWindow")] + internal extern static int XMapWindow (IntPtr display, IntPtr window); + [DllImport ("libX11", EntryPoint="XUnmapWindow")] + internal extern static int XUnmapWindow (IntPtr display, IntPtr window); + [DllImport ("libX11", EntryPoint="XMapSubwindows")] + internal extern static int XMapSubindows (IntPtr display, IntPtr window); + [DllImport ("libX11", EntryPoint="XUnmapSubwindows")] + internal extern static int XUnmapSubwindows (IntPtr display, IntPtr window); + [DllImport ("libX11", EntryPoint="XRootWindow")] + internal extern static IntPtr XRootWindow (IntPtr display, int screen_number); + [DllImport ("libX11", EntryPoint="XNextEvent")] + internal extern static IntPtr XNextEvent (IntPtr display, ref XEvent xevent); + [DllImport ("libX11")] + internal extern static int XConnectionNumber (IntPtr diplay); + [DllImport ("libX11")] + internal extern static int XPending (IntPtr diplay); + [DllImport ("libX11")] + internal extern static bool XCheckWindowEvent (IntPtr display, IntPtr window, EventMask mask, ref XEvent xevent); + [DllImport ("libX11")] + internal extern static bool XCheckMaskEvent (IntPtr display, EventMask mask, ref XEvent xevent); + [DllImport ("libX11", EntryPoint="XSelectInput")] + internal extern static IntPtr XSelectInput (IntPtr display, IntPtr window, EventMask mask); + + [DllImport ("libX11", EntryPoint="XReparentWindow")] + internal extern static int XReparentWindow (IntPtr display, IntPtr window, IntPtr parent, int x, int y); + [DllImport ("libX11", EntryPoint="XMoveResizeWindow")] + internal extern static int XMoveResizeWindow (IntPtr display, IntPtr window, int x, int y, int width, int height); + + [DllImport ("libX11", EntryPoint="XResizeWindow")] + internal extern static int XResizeWindow (IntPtr display, IntPtr window, int width, int height); + + [DllImport ("libX11", EntryPoint="XGetWindowAttributes")] + internal extern static int XGetWindowAttributes (IntPtr display, IntPtr window, ref XWindowAttributes attributes); + + [DllImport ("libX11", EntryPoint="XFlush")] + internal extern static int XFlush (IntPtr display); + + [DllImport ("libX11", EntryPoint="XSetWMName")] + internal extern static int XSetWMName (IntPtr display, IntPtr window, ref XTextProperty text_prop); + + [DllImport ("libX11", EntryPoint="XStoreName")] + internal extern static int XStoreName (IntPtr display, IntPtr window, string window_name); + + [DllImport ("libX11", EntryPoint="XFetchName")] + internal extern static int XFetchName (IntPtr display, IntPtr window, ref IntPtr window_name); + + [DllImport ("libX11", EntryPoint="XSendEvent")] + internal extern static int XSendEvent (IntPtr display, IntPtr window, bool propagate, EventMask event_mask, ref XEvent send_event); + + [DllImport ("libX11", EntryPoint="XQueryTree")] + internal extern static int XQueryTree (IntPtr display, IntPtr window, out IntPtr root_return, out IntPtr parent_return, out IntPtr children_return, out int nchildren_return); + + [DllImport ("libX11", EntryPoint="XFree")] + internal extern static int XFree (IntPtr data); + + [DllImport ("libX11", EntryPoint="XRaiseWindow")] + internal extern static int XRaiseWindow (IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XLowerWindow")] + internal extern static uint XLowerWindow (IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XConfigureWindow")] + internal extern static uint XConfigureWindow (IntPtr display, IntPtr window, ChangeWindowFlags value_mask, ref XWindowChanges values); + + [DllImport ("libX11", EntryPoint="XInternAtom")] + internal extern static int XInternAtom (IntPtr display, string atom_name, bool only_if_exists); + + [DllImport ("libX11", EntryPoint="XSetWMProtocols")] + internal extern static int XSetWMProtocols (IntPtr display, IntPtr window, uint[] protocols, int count); + + [DllImport ("libX11", EntryPoint="XGrabPointer")] + internal extern static int XGrabPointer (IntPtr display, IntPtr window, bool owner_events, EventMask event_mask, GrabMode pointer_mode, GrabMode keyboard_mode, IntPtr confine_to, uint cursor, uint timestamp); + + [DllImport ("libX11", EntryPoint="XUngrabPointer")] + internal extern static int XUngrabPointer (IntPtr display, uint timestamp); + + [DllImport ("libX11", EntryPoint="XQueryPointer")] + internal extern static bool XQueryPointer (IntPtr display, IntPtr window, out IntPtr root, out IntPtr child, out int root_x, out int root_y, out int win_x, out int win_y, out int keys_buttons); + + [DllImport ("libX11", EntryPoint="XTranslateCoordinates")] + internal extern static bool XTranslateCoordinates (IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, out int intdest_x_return, out int dest_y_return, out IntPtr child_return); + + [DllImport ("libX11", EntryPoint="XWarpPointer")] + internal extern static uint XWarpPointer (IntPtr display, IntPtr src_w, IntPtr dest_w, int src_x, int src_y, uint src_width, uint src_height, int dest_x, int dest_y); + + [DllImport ("libX11", EntryPoint="XClearWindow")] + internal extern static int XClearWindow (IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XClearArea")] + internal extern static int XClearArea (IntPtr display, IntPtr window, int x, int y, int width, int height, bool exposures); + + // Colormaps + [DllImport ("libX11", EntryPoint="XDefaultScreenOfDisplay")] + internal extern static IntPtr XDefaultScreenOfDisplay (IntPtr display); + + [DllImport ("libX11", EntryPoint="XScreenNumberOfScreen")] + internal extern static int XScreenNumberOfScreen (IntPtr display, IntPtr Screen); + + [DllImport ("libX11", EntryPoint="XDefaultVisual")] + internal extern static IntPtr XDefaultVisual (IntPtr display, int screen_number); + + [DllImport ("libX11", EntryPoint="XDefaultDepth")] + internal extern static uint XDefaultDepth (IntPtr display, int screen_number); + + [DllImport ("libX11", EntryPoint="XDefaultColormap")] + internal extern static IntPtr XDefaultColormap (IntPtr display, int screen_number); + + [DllImport ("libX11", EntryPoint="XLookupColor")] + internal extern static int XLookupColor (IntPtr display, IntPtr Colormap, string Coloranem, ref XColor exact_def_color, ref XColor screen_def_color); + + [DllImport ("libX11", EntryPoint="XAllocColor")] + internal extern static int XAllocColor (IntPtr display, IntPtr Colormap, ref XColor colorcell_def); + + [DllImport ("libX11", EntryPoint="XSetTransientForHint")] + internal extern static int XSetTransientForHint (IntPtr display, IntPtr window, IntPtr prop_window); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty (IntPtr display, IntPtr window, int property, int type, int format, PropertyMode mode, ref MotifWmHints data, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty (IntPtr display, IntPtr window, int property, Atom format, int type, PropertyMode mode, uint[] atoms, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty (IntPtr display, IntPtr window, int property, Atom format, int type, PropertyMode mode, ref uint value, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty (IntPtr display, IntPtr window, int property, int format, int type, PropertyMode mode, uint[] atoms, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty (IntPtr display, IntPtr window, int property, int format, int type, PropertyMode mode, IntPtr atoms, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty")] + internal extern static int XChangeProperty (IntPtr display, IntPtr window, int property, Atom format, int type, PropertyMode mode, IntPtr atoms, int nelements); + + [DllImport ("libX11", EntryPoint="XChangeProperty", CharSet=CharSet.Ansi)] + internal extern static int XChangeProperty (IntPtr display, IntPtr window, int property, int type, int format, PropertyMode mode, string text, int text_length); + + [DllImport ("libX11", EntryPoint="XDeleteProperty")] + internal extern static int XDeleteProperty (IntPtr display, IntPtr window, int property); + + // Drawing + [DllImport ("libX11", EntryPoint="XCreateGC")] + internal extern static IntPtr XCreateGC (IntPtr display, IntPtr window, GCFunction valuemask, ref XGCValues values); + + [DllImport ("libX11", EntryPoint="XFreeGC")] + internal extern static int XFreeGC (IntPtr display, IntPtr gc); + + [DllImport ("libX11", EntryPoint="XSetFunction")] + internal extern static int XSetFunction (IntPtr display, IntPtr gc, GXFunction function); + + [DllImport ("libX11", EntryPoint="XDrawLine")] + internal extern static int XDrawLine (IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int x2, int y2); + + [DllImport ("libX11", EntryPoint="XDrawRectangle")] + internal extern static int XDrawRectangle (IntPtr display, IntPtr drawable, IntPtr gc, int x1, int y1, int width, int height); + + [DllImport ("libX11", EntryPoint="XSetWindowBackground")] + internal extern static int XSetWindowBackground (IntPtr display, IntPtr window, IntPtr background); + + [DllImport ("libX11", EntryPoint="XCopyArea")] + internal extern static int XCopyArea (IntPtr display, IntPtr src, IntPtr dest, IntPtr gc, int src_x, int src_y, int width, int height, int dest_x, int dest_y); + + [DllImport ("libX11", EntryPoint="XGetAtomName")] + internal extern static string XGetAtomName (IntPtr display, int atom); + + [DllImport ("libX11", EntryPoint="XGetWindowProperty")] + internal extern static int XGetWindowProperty (IntPtr display, IntPtr window, int atom, int long_offset, int long_length, bool delete, Atom req_type, out Atom actual_type, out int actual_format, out int nitems, out int bytes_after, ref IntPtr prop); + + [DllImport ("libX11", EntryPoint="XSetInputFocus")] + internal extern static int XSetInputFocus (IntPtr display, IntPtr window, RevertTo revert_to, IntPtr time); + + [DllImport ("libX11", EntryPoint="XIconifyWindow")] + internal extern static int XIconifyWindow (IntPtr display, IntPtr window, int screen_number); + + [DllImport ("libX11", EntryPoint="XDefineCursor")] + internal extern static int XDefineCursor (IntPtr display, IntPtr window, IntPtr cursor); + + [DllImport ("libX11", EntryPoint="XUndefineCursor")] + internal extern static int XUndefineCursor (IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XFreeCursor")] + internal extern static int XFreeCursor (IntPtr display, IntPtr cursor); + + [DllImport ("libX11", EntryPoint="XCreateFontCursor")] + internal extern static IntPtr XCreateFontCursor (IntPtr display, CursorFontShape shape); + + [DllImport ("libX11", EntryPoint="XCreatePixmapCursor")] + internal extern static IntPtr XCreatePixmapCursor (IntPtr display, IntPtr source, IntPtr mask, ref XColor foreground_color, ref XColor background_color, int x_hot, int y_hot); + + [DllImport ("libX11", EntryPoint="XCreatePixmapFromBitmapData")] + internal extern static IntPtr XCreatePixmapFromBitmapData (IntPtr display, IntPtr drawable, byte[] data, int width, int height, IntPtr fg, IntPtr bg, int depth); + + [DllImport ("libX11", EntryPoint="XFreePixmap")] + internal extern static IntPtr XFreePixmap (IntPtr display, IntPtr pixmap); + + [DllImport ("libX11", EntryPoint="XWhitePixel")] + internal extern static IntPtr XWhitePixel (IntPtr display, int screen_no); + + [DllImport ("libX11", EntryPoint="XBlackPixel")] + internal extern static IntPtr XBlackPixel (IntPtr display, int screen_no); + + [DllImport ("libX11", EntryPoint="XGrabServer")] + internal extern static void XGrabServer (IntPtr display); + + [DllImport ("libX11", EntryPoint="XUngrabServer")] + internal extern static void XUngrabServer (IntPtr display); + + [DllImport ("libX11", EntryPoint="XSetWMNormalHints")] + internal extern static void XSetWMNormalHints (IntPtr display, IntPtr window, ref XSizeHints hints); + + [DllImport ("libX11", EntryPoint="XSetZoomHints")] + internal extern static void XSetZoomHints (IntPtr display, IntPtr window, ref XSizeHints hints); + + [DllImport ("libX11", EntryPoint="XSetWMHints")] + internal extern static void XSetWMHints (IntPtr display, IntPtr window, ref XWMHints wmhints); + + [DllImport ("libX11", EntryPoint="XSync")] + internal extern static void XSync (IntPtr display, IntPtr window); + + [DllImport ("libX11", EntryPoint="XGetIconSizes")] + internal extern static int XGetIconSizes (IntPtr display, IntPtr window, out IntPtr size_list, out int count); + + [DllImport ("libX11", EntryPoint="XSetErrorHandler")] + internal extern static IntPtr XSetErrorHandler (XErrorHandler error_handler); + + [DllImport ("libX11", EntryPoint="XGetErrorText")] + internal extern static IntPtr XGetErrorText (IntPtr display, byte code, StringBuilder buffer, int length); + + [DllImport ("libX11", EntryPoint="XInitThreads")] + internal extern static int XInitThreads (); + + [DllImport ("libX11", EntryPoint="XConvertSelection")] + internal extern static int XConvertSelection (IntPtr display, int selection, int target, int property, IntPtr requestor, IntPtr time); + + [DllImport ("libX11", EntryPoint="XGetSelectionOwner")] + internal extern static IntPtr XGetSelectionOwner (IntPtr display, int selection); + + [DllImport ("libX11", EntryPoint="XSetSelectionOwner")] + internal extern static int XSetSelectionOwner (IntPtr display, int selection, IntPtr owner, IntPtr time); + + [DllImport ("libX11", EntryPoint="XSetPlaneMask")] + internal extern static int XSetPlaneMask (IntPtr display, IntPtr gc, uint mask); + + [DllImport ("libX11", EntryPoint="XSetForeground")] + internal extern static int XSetForeground (IntPtr display, IntPtr gc, uint foreground); + + [DllImport ("libX11", EntryPoint="XSetBackground")] + internal extern static int XSetBackground (IntPtr display, IntPtr gc, uint background); + + #endregion + + #region gdk imports + [DllImport("libgdk-x11-2.0.so")] + static extern bool gdk_init_check (IntPtr argc, IntPtr argv); + + [DllImport("libgdk-x11-2.0.so")] + internal static extern IntPtr gdk_x11_display_get_xdisplay (IntPtr display); + + [DllImport("libgdk-x11-2.0.so")] + internal static extern IntPtr gdk_display_get_default (); + + [DllImport("libgdk-x11-2.0.so")] + static extern IntPtr gdk_pixmap_new (IntPtr drawable, int width, int height, int depth); + + [DllImport("libgdk-x11-2.0.so")] + static extern IntPtr gdk_x11_drawable_get_xid (IntPtr gdkdrawable); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_draw_drawable (IntPtr drawable_dest, IntPtr gdk_gc, IntPtr drawable_src, int xsrc, int ysrc, int xdest, int ydest, int width, int height); + + [DllImport("libgdk-x11-2.0.so")] + static extern IntPtr gdk_gc_new (IntPtr drawable); + + [DllImport("libgdk-x11-2.0.so")] + static extern IntPtr gdk_window_foreign_new (IntPtr anid); + + [DllImport("libgdk-x11-2.0.so")] + static extern IntPtr gdk_x11_lookup_xdisplay (IntPtr xdisplay); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_display_close (IntPtr display); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_display_beep (IntPtr display); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_display_sync (IntPtr display); + + [DllImport("libgdk-x11-2.0.so")] + static extern IntPtr gdk_get_default_root_window (); + + [DllImport("libgdk-x11-2.0.so")] + static extern IntPtr gdk_colormap_get_system (); + + [DllImport("libgdk-x11-2.0.so")] + static extern IntPtr gdk_x11_colormap_get_xcolormap (IntPtr gdk_colormap); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_window_destroy (IntPtr gdk_window); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_x11_grab_server (); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_x11_ungrab_server (); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_display_flush (IntPtr gdk_display); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_window_iconify (IntPtr gdk_window); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_window_deiconify (IntPtr gdk_window); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_window_set_decorations (IntPtr gdk_window, int decorations); + + [DllImport("libgdk-x11-2.0.so")] + static extern IntPtr gdk_screen_get_default (); + + [DllImport("libgdk-x11-2.0.so")] + static extern int gdk_screen_get_number (IntPtr gdk_screen); + + [DllImport("libgdk-x11-2.0.so")] + static extern IntPtr gdk_window_lookup (IntPtr anid); + + [DllImport("libgdk-x11-2.0.so")] + static extern IntPtr gdk_window_new (IntPtr gdk_parent, ref GdkWindowAttr gdk_window_attributes, int attributes_mask); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_window_set_events (IntPtr gdk_window, int event_mask); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_window_show (IntPtr window); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_window_set_title (IntPtr gdk_window, string title); + + [DllImport("libgdk-x11-2.0.so")] + static extern int gdk_window_get_origin (IntPtr gdk_window, out int x, out int y); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_window_get_geometry (IntPtr gdk_window, out int x, out int y, out int width, out int height, out int depth); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_property_change (IntPtr gdk_window, /*GdkAtom*/IntPtr property, /*GdkAtom*/IntPtr type, int format, int gdk_prop_mode, /*const guchar **/ IntPtr data, int nelements); + + [DllImport("libgdk-x11-2.0.so")] + static extern IntPtr gdk_window_get_parent (IntPtr gdk_window); + + [DllImport("libgdk-x11-2.0.so")] + static extern void gdk_display_get_maximal_cursor_size (IntPtr gdk_display, out uint width, out uint height); + + [DllImport("libgdk-x11-2.0.so")] + static extern int gdk_visual_get_best_depth (); + #endregion + + #region gobject imports + [DllImport("libglib-2.0.so")] + static extern void g_free (IntPtr mem); + + [DllImport("libgobject-2.0.so")] + static extern void g_object_unref (IntPtr nativeObject); + #endregion + } +} |