// 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.
+// Copyright (c) 2004-2006 Novell, Inc.
//
// Authors:
// Peter Bartok pbartok@novell.com
using System.Collections;
using System.Diagnostics;
using System.Drawing;
+using System.Drawing.Drawing2D;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Security;
internal string name; // for object naming
// State
- private bool create_handled; // true if OnCreateControl has been sent
+ internal bool is_created; // true if OnCreateControl has been sent
internal bool has_focus; // true if control has focus
internal bool is_visible; // true if control is visible
internal bool is_entered; // is the mouse inside the control?
internal object control_tag; // object that contains data about our control
internal int mouse_clicks; // Counter for mouse clicks
internal Cursor cursor; // Cursor for the window
- private bool allow_drop; // true if the control accepts droping objects on it
+ internal bool allow_drop; // true if the control accepts droping objects on it
// Visuals
internal Color foreground_color; // foreground color for control
// Layout
internal AnchorStyles anchor_style; // anchoring requirements for our control
internal DockStyle dock_style; // docking requirements for our control (supercedes anchoring)
- internal SizeF size_ratio; // size ratio of our control to it's parent; required for anchoring
- internal Size prev_size; // previous size of the control; required for anchoring
+ internal int dist_left; // distance to the left border of the parent
+ internal int dist_top; // distance to the top border of the parent
+ internal int dist_right; // distance to the right border of the parent
+ internal int dist_bottom; // distance to the bottom border of the parent
// to be categorized...
static internal ArrayList controls = new ArrayList(); // All of the application's controls, in a flat list
private ControlBindingsCollection data_bindings;
+#if NET_2_0
+ internal bool use_compatible_text_rendering;
+ static internal bool verify_thread_handle;
+ private Padding padding;
+#endif
+
#endregion // Local Variables
#region Private Classes
ControlNativeWindow window;
window = (ControlNativeWindow)window_collection[hWnd];
+ if (window != null) {
+ return window.owner;
+ }
- return window.owner;
+ return null;
}
protected override void WndProc(ref Message m) {
#region Public Classes
[ComVisible(true)]
public class ControlAccessibleObject : AccessibleObject {
- #region ControlAccessibleObject Local Variables
- private Control owner;
- #endregion // ControlAccessibleObject Local Variables
-
#region ControlAccessibleObject Constructors
public ControlAccessibleObject(Control ownerControl) {
this.owner = ownerControl;
[ListBindable(false)]
public class ControlCollection : IList, ICollection, ICloneable, IEnumerable {
#region ControlCollection Local Variables
- internal ArrayList list;
+ private ArrayList list;
+ internal ArrayList impl_list;
+ private Control [] all_controls;
internal Control owner;
#endregion // ControlCollection Local Variables
if (value == null)
return;
- for (int i = list.Count; i > 0; ) {
- i--;
-
- if (list [i] == value) {
- // Do we need to do anything here?
- return;
- }
+ if (Contains (value)) {
+ owner.PerformLayout();
+ return;
}
if (value.tab_index == -1) {
value.tab_index = use;
}
+ if (value.parent != null) {
+ value.parent.Controls.Remove(value);
+ }
+
+ all_controls = null;
list.Add (value);
- value.Parent = owner;
+
+ value.ChangeParent(owner);
+
+ value.InitLayout();
+
owner.UpdateZOrder();
+ owner.PerformLayout(value, "Parent");
owner.OnControlAdded(new ControlEventArgs(value));
}
+ internal void AddToList (Control c)
+ {
+ all_controls = null;
+ list.Add (c);
+ }
+
+ internal virtual void AddImplicit (Control control)
+ {
+ if (impl_list == null)
+ impl_list = new ArrayList ();
+ all_controls = null;
+ impl_list.Add (control);
+
+ control.ChangeParent (owner);
+ control.InitLayout ();
+ owner.UpdateZOrder ();
+ owner.PerformLayout (control, "Parent");
+ owner.OnControlAdded (new ControlEventArgs (control));
+ }
+
public virtual void AddRange (Control[] controls)
{
if (controls == null)
}
}
+ internal virtual void AddRangeImplicit (Control [] controls)
+ {
+ if (controls == null)
+ throw new ArgumentNullException ("controls");
+
+ owner.SuspendLayout ();
+
+ try {
+ for (int i = 0; i < controls.Length; i++)
+ AddImplicit (controls [i]);
+ } finally {
+ owner.ResumeLayout ();
+ }
+ }
+
public virtual void Clear ()
{
- owner.SuspendLayout();
- for (int i = 0; i < list.Count; i++) {
- owner.OnControlRemoved(new ControlEventArgs((Control)list[i]));
+ all_controls = null;
+
+ // MS sends remove events in reverse order
+ while (list.Count > 0) {
+ RemoveAt(list.Count - 1);
}
- list.Clear();
- owner.ResumeLayout();
+ }
+
+ internal virtual void ClearImplicit ()
+ {
+ if (impl_list == null)
+ return;
+ all_controls = null;
+ impl_list.Clear ();
}
public bool Contains (Control value)
{
- return list.Contains (value);
+ for (int i = list.Count; i > 0; ) {
+ i--;
+
+ if (list [i] == value) {
+ // Do we need to do anything here?
+ return true;
+ }
+ }
+ return false;
+ }
+
+ internal bool ImplicitContains (Control value)
+ {
+ if (impl_list == null)
+ return false;
+
+ for (int i = impl_list.Count; i > 0; ) {
+ i--;
+
+ if (impl_list [i] == value) {
+ // Do we need to do anything here?
+ return true;
+ }
+ }
+ return false;
+ }
+
+ internal bool AllContains (Control value)
+ {
+ return Contains (value) || ImplicitContains (value);
}
public void CopyTo (Array array, int index)
return list.GetEnumerator();
}
+ internal IEnumerator GetAllEnumerator ()
+ {
+ Control [] res = GetAllControls ();
+ return res.GetEnumerator ();
+ }
+
+ internal Control [] GetAllControls ()
+ {
+ if (all_controls != null)
+ return all_controls;
+
+ if (impl_list == null)
+ return (Control []) list.ToArray (typeof (Control));
+
+ Control [] res = new Control [list.Count + impl_list.Count];
+ impl_list.CopyTo (res);
+ list.CopyTo (res, impl_list.Count);
+
+ return res;
+ }
+
public override int GetHashCode() {
return base.GetHashCode();
}
}
public virtual void Remove(Control value) {
+ all_controls = null;
+
+ owner.PerformLayout(value, "Parent");
owner.OnControlRemoved(new ControlEventArgs(value));
list.Remove(value);
- value.parent = null;
+
+ value.ChangeParent(null);
+
owner.UpdateZOrder();
}
+ internal virtual void RemoveImplicit (Control control)
+ {
+ if (impl_list != null) {
+ all_controls = null;
+ owner.PerformLayout (control, "Parent");
+ owner.OnControlRemoved (new ControlEventArgs (control));
+ impl_list.Remove (control);
+ }
+ control.ChangeParent (null);
+ owner.UpdateZOrder ();
+ }
+
public void RemoveAt(int index) {
if (index < 0 || index >= list.Count) {
throw new ArgumentOutOfRangeException("index", index, "ControlCollection does not have that many controls");
return;
}
- RemoveAt(old_index);
+ list.RemoveAt(old_index);
if (newIndex>list.Count) {
list.Add(child);
}
}
- bool IList.IsReadOnly {
- get {
- return list.IsReadOnly;
- }
- }
-
bool ICollection.IsSynchronized {
get {
return list.IsSynchronized;
if (!(value is Control)) {
throw new ArgumentException("Object of type Control required", "value");
}
+ all_controls = null;
list.Insert(index, value);
}
if (!(value is Control)) {
throw new ArgumentException("Object of type Control required", "value");
}
+ all_controls = null;
list.Remove(value);
}
- void ICollection.CopyTo(Array array, int index) {
- if (list.Count>0) {
- list.CopyTo(array, index);
- }
- }
-
Object ICloneable.Clone() {
ControlCollection clone = new ControlCollection(this.owner);
clone.list=(ArrayList)list.Clone(); // FIXME: Do we need this?
#region Public Constructors
public Control() {
- creator_thread = Thread.CurrentThread;
- prev_size = Size.Empty;
anchor_style = AnchorStyles.Top | AnchorStyles.Left;
- create_handled = false;
+ is_created = false;
is_visible = true;
is_captured = false;
is_disposed = false;
tab_index = -1;
cursor = null;
right_to_left = RightToLeft.Inherit;
+ border_style = BorderStyle.None;
+ background_color = Color.Empty;
+ dist_left = 0;
+ dist_right = 0;
+ dist_top = 0;
+ dist_bottom = 0;
+
+#if NET_2_0
+ use_compatible_text_rendering = Application.use_compatible_text_rendering;
+ padding = new Padding(0);
+#endif
- control_style = ControlStyles.Selectable | ControlStyles.StandardClick | ControlStyles.StandardDoubleClick;
+ control_style = ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint |
+ ControlStyles.Selectable | ControlStyles.StandardClick |
+ ControlStyles.StandardDoubleClick;
parent = null;
background_image = null;
child_controls = CreateControlsInstance();
client_size = new Size(DefaultSize.Width, DefaultSize.Height);
client_rect = new Rectangle(0, 0, DefaultSize.Width, DefaultSize.Height);
- XplatUI.CalculateWindowRect(IntPtr.Zero, ref client_rect, CreateParams.Style, CreateParams.ExStyle, IntPtr.Zero, out bounds);
+ XplatUI.CalculateWindowRect(ref client_rect, CreateParams.Style, CreateParams.ExStyle, null, out bounds);
if ((CreateParams.Style & (int)WindowStyles.WS_CHILD) == 0) {
bounds.X=-1;
bounds.Y=-1;
Text=text;
}
+ private delegate void RemoveDelegate(object c);
+
protected override void Dispose(bool disposing) {
- is_disposed = true;
if (dc_mem!=null) {
dc_mem.Dispose();
dc_mem=null;
bmp_mem=null;
}
- DestroyHandle();
- controls.Remove(this);
+ if (this.InvokeRequired) {
+ if (Application.MessageLoop) {
+ this.BeginInvokeInternal(new MethodInvoker(DestroyHandle), null, true);
+ this.BeginInvokeInternal(new RemoveDelegate(controls.Remove), new object[] {this}, true);
+ }
+ } else {
+ DestroyHandle();
+ controls.Remove(this);
+ }
+ is_disposed = true;
+ base.Dispose(disposing);
}
#endregion // Public Constructors
}
set {
+ if (!Enum.IsDefined (typeof (BorderStyle), value))
+ throw new InvalidEnumArgumentException (string.Format("Enum argument value '{0}' is not valid for BorderStyle", value));
+
if (border_style != value) {
border_style = value;
- XplatUI.SetBorderStyle(window.Handle, border_style);
+ if (IsHandleCreated) {
+ XplatUI.SetBorderStyle(window.Handle, (FormBorderStyle)border_style);
+ Refresh();
+ }
}
}
}
#endregion // Internal Properties
#region Private & Internal Methods
- internal IAsyncResult BeginInvokeInternal (Delegate method, object [] args) {
+ internal IAsyncResult BeginInvokeInternal (Delegate method, object [] args, bool disposing) {
AsyncMethodResult result;
AsyncMethodData data;
- Control p;
- p = this;
- do {
- if (!p.IsHandleCreated) {
- throw new InvalidOperationException("Cannot call Invoke or InvokeAsync on a control until the window handle is created");
- }
- p = p.parent;
- } while (p != null);
+ if (!disposing) {
+ Control p;
+
+ p = this;
+ do {
+ if (!p.IsHandleCreated) {
+ throw new InvalidOperationException("Cannot call Invoke or InvokeAsync on a control until the window handle is created");
+ }
+ p = p.parent;
+ } while (p != null);
+ }
result = new AsyncMethodResult ();
data = new AsyncMethodData ();
data.Method = method;
data.Args = args;
- data.Result = new WeakReference (result);
+ data.Result = result;
#if NET_2_0
if (!ExecutionContext.IsFlowSuppressed ()) {
return result;
}
+
+ internal void PointToClient (ref int x, ref int y)
+ {
+ XplatUI.ScreenToClient (Handle, ref x, ref y);
+ }
+
+ internal void PointToScreen (ref int x, ref int y)
+ {
+ XplatUI.ClientToScreen (Handle, ref x, ref y);
+ }
+
+ private bool IsRecreating {
+ get {
+ if (is_recreating) {
+ return true;
+ }
+
+ if (parent != null) {
+ return parent.IsRecreating;
+ }
+
+ return false;
+ }
+ }
+
+ private bool ParentIsRecreating {
+ get {
+ if (parent != null) {
+ return parent.IsRecreating;
+ }
+ return false;
+ }
+ }
+
internal Graphics DeviceContext {
get {
if (dc_mem==null) {
for (int i=0; i < parent.child_controls.Count; i++) {
child=parent.child_controls[i];
- if (child.IsHandleCreated) {
- XplatUI.SetWindowBackground(child.window.Handle, child.BackColor);
- }
if (child.child_controls.Count>0) {
SetChildColor(child);
}
}
// This method exists so controls overriding OnPaintBackground can have default background painting done
- internal void PaintControlBackground (PaintEventArgs pevent)
+ internal virtual void PaintControlBackground (PaintEventArgs pevent)
{
- if (background_image == null)
+ if (GetStyle(ControlStyles.SupportsTransparentBackColor) && (BackColor.A != 0xff)) {
+ if (parent != null) {
+ PaintEventArgs parent_pe;
+ GraphicsState state;
+
+ parent_pe = new PaintEventArgs(pevent.Graphics, new Rectangle(pevent.ClipRectangle.X + Left, pevent.ClipRectangle.Y + Top, pevent.ClipRectangle.Width, pevent.ClipRectangle.Height));
+
+ state = parent_pe.Graphics.Save();
+ parent_pe.Graphics.TranslateTransform(-Left, -Top);
+ parent.OnPaintBackground(parent_pe);
+ parent_pe.Graphics.Restore(state);
+
+ state = parent_pe.Graphics.Save();
+ parent_pe.Graphics.TranslateTransform(-Left, -Top);
+ parent.OnPaint(parent_pe);
+ parent_pe.Graphics.Restore(state);
+ parent_pe.SetGraphics(null);
+ }
+ }
+
+ if (background_image == null) {
+ pevent.Graphics.FillRectangle(ThemeEngine.Current.ResPool.GetSolidBrush(BackColor), new Rectangle(pevent.ClipRectangle.X - 1, pevent.ClipRectangle.Y - 1, pevent.ClipRectangle.Width + 2, pevent.ClipRectangle.Height + 2));
return;
+ }
DrawBackgroundImage (pevent.Graphics);
}
void DrawBackgroundImage (Graphics g)
{
- using (TextureBrush b = new TextureBrush (background_image)) {
+ using (TextureBrush b = new TextureBrush (background_image, WrapMode.Tile)) {
g.FillRectangle (b, ClientRectangle);
}
}
- internal void DndEnter (DragEventArgs e)
+ internal virtual void DndEnter (DragEventArgs e)
{
- OnDragEnter (e);
+ try {
+ OnDragEnter (e);
+ } catch { }
}
- internal void DndOver (DragEventArgs e)
+ internal virtual void DndOver (DragEventArgs e)
{
- OnDragOver (e);
+ try {
+ OnDragOver (e);
+ } catch { }
}
- internal void DndDrop (DragEventArgs e)
+ internal virtual void DndDrop (DragEventArgs e)
{
- OnDragDrop (e);
+ try {
+ OnDragDrop (e);
+ } catch (Exception exc) {
+ Console.Error.WriteLine ("MWF: Exception while dropping:");
+ Console.Error.WriteLine (exc);
+ }
}
- internal void DndLeave (EventArgs e)
+ internal virtual void DndLeave (EventArgs e)
{
- OnDragLeave (e);
+ try {
+ OnDragLeave (e);
+ } catch { }
}
- internal void DnDFeedback(GiveFeedbackEventArgs e)
+ internal virtual void DndFeedback(GiveFeedbackEventArgs e)
{
- OnGiveFeedback(e);
+ try {
+ OnGiveFeedback(e);
+ } catch { }
}
- internal void DnDContinueDrag(QueryContinueDragEventArgs e) {
- OnQueryContinueDrag(e);
+ internal virtual void DndContinueDrag(QueryContinueDragEventArgs e)
+ {
+ try {
+ OnQueryContinueDrag(e);
+ } catch { }
}
internal static MouseButtons FromParamToMouseButtons (int param) {
return found;
}
- private void HandleClick(int clicks) {
+ private void HandleClick(int clicks, MouseEventArgs me) {
if (GetStyle(ControlStyles.StandardClick)) {
- if (clicks > 1) {
- if (GetStyle(ControlStyles.StandardDoubleClick)) {
- OnDoubleClick(EventArgs.Empty);
- } else {
- OnClick(EventArgs.Empty);
- }
+ if ((clicks > 1) && GetStyle(ControlStyles.StandardDoubleClick)) {
+#if !NET_2_0
+ OnDoubleClick(EventArgs.Empty);
} else {
OnClick(EventArgs.Empty);
+#else
+ OnDoubleClick(me);
+ } else {
+ OnClick(me);
+#endif
}
}
}
}
}
+
+ private void ChangeParent(Control new_parent) {
+ bool pre_enabled;
+ bool pre_visible;
+ Font pre_font;
+ Color pre_fore_color;
+ Color pre_back_color;
+ RightToLeft pre_rtl;
+
+ // These properties are inherited from our parent
+ // Get them pre parent-change and then send events
+ // if they are changed after we have our new parent
+ pre_enabled = Enabled;
+ pre_visible = Visible;
+ pre_font = Font;
+ pre_fore_color = ForeColor;
+ pre_back_color = BackColor;
+ pre_rtl = RightToLeft;
+ // MS doesn't seem to send a CursorChangedEvent
+
+ parent = new_parent;
+
+ if (IsHandleCreated && (new_parent != null) && new_parent.IsHandleCreated) {
+ XplatUI.SetParent(Handle, new_parent.Handle);
+ }
+
+ OnParentChanged(EventArgs.Empty);
+
+ if (pre_enabled != Enabled) {
+ OnEnabledChanged(EventArgs.Empty);
+ }
+
+ if (pre_visible != Visible) {
+ OnVisibleChanged(EventArgs.Empty);
+ }
+
+ if (pre_font != Font) {
+ OnFontChanged(EventArgs.Empty);
+ }
+
+ if (pre_fore_color != ForeColor) {
+ OnForeColorChanged(EventArgs.Empty);
+ }
+
+ if (pre_back_color != BackColor) {
+ OnBackColorChanged(EventArgs.Empty);
+ }
+
+ if (pre_rtl != RightToLeft) {
+ // MS sneaks a OnCreateControl and OnHandleCreated in here, I guess
+ // because when RTL changes they have to recreate the win32 control
+ // We don't really need that (until someone runs into compatibility issues)
+ OnRightToLeftChanged(EventArgs.Empty);
+ }
+
+ if ((new_parent != null) && new_parent.Created && !Created) {
+ CreateControl();
+ }
+
+ if ((binding_context == null) && Created) {
+ OnBindingContextChanged(EventArgs.Empty);
+ }
+ }
+
+ private void UpdateDistances() {
+ if ((parent != null) && (parent.layout_suspended == 0)) {
+ dist_left = bounds.X;
+ dist_top = bounds.Y;
+ dist_right = parent.ClientSize.Width - bounds.X - bounds.Width;
+ dist_bottom = parent.ClientSize.Height - bounds.Y - bounds.Height;
+ }
+ }
#endregion // Private & Internal Methods
#region Public Static Properties
[MonoTODO]
public static bool CheckForIllegalCrossThreadCalls
{
- set {
- }
get {
- return false;
+ return verify_thread_handle;
+ }
+
+ set {
+ verify_thread_handle = value;
}
}
#endif
[Localizable(true)]
[DefaultValue(null)]
+ [MWFCategory("Accessibility")]
public string AccessibleDescription {
get {
return AccessibilityObject.description;
[Localizable(true)]
[DefaultValue(null)]
+ [MWFCategory("Accessibility")]
public string AccessibleName {
get {
return AccessibilityObject.Name;
}
[DefaultValue(false)]
+ [MWFCategory("Behavior")]
public virtual bool AllowDrop {
get {
return allow_drop;
if (allow_drop == value)
return;
allow_drop = value;
- UpdateStyles();
- XplatUI.SetAllowDrop (Handle, value);
+ if (IsHandleCreated) {
+ UpdateStyles();
+ XplatUI.SetAllowDrop (Handle, value);
+ }
}
}
[Localizable(true)]
[RefreshProperties(RefreshProperties.Repaint)]
- [DefaultValue(AnchorStyles.Top | AnchorStyles.Left)]
+ [DefaultValue(AnchorStyles.Top | AnchorStyles.Left)]
+ [MWFCategory("Layout")]
public virtual AnchorStyles Anchor {
get {
return anchor_style;
}
}
+#if NET_2_0
+ // XXX: Implement me!
+ bool auto_size;
+
+ public virtual bool AutoSize {
+ get {
+ Console.Error.WriteLine("Unimplemented: Control::get_AutoSize()");
+ return auto_size;
+ }
+ set {
+ Console.Error.WriteLine("Unimplemented: Control::set_AutoSize(bool)");
+ auto_size = value;
+ }
+ }
+#endif // NET_2_0
+
[DispId(-501)]
+ [MWFCategory("Appearance")]
public virtual Color BackColor {
get {
if (background_color.IsEmpty) {
if (parent!=null) {
- return parent.BackColor;
+ Color pcolor = parent.BackColor;
+ if (pcolor.A == 0xff || GetStyle(ControlStyles.SupportsTransparentBackColor))
+ return pcolor;
}
return DefaultBackColor;
}
}
set {
- background_color=value;
- if (this.IsHandleCreated) {
- XplatUI.SetWindowBackground(this.window.Handle, value);
+ if (!value.IsEmpty && (value.A != 0xff) && !GetStyle(ControlStyles.SupportsTransparentBackColor)) {
+ throw new ArgumentException("Transparent background colors are not supported on this control");
}
+
+ background_color=value;
SetChildColor(this);
OnBackColorChanged(EventArgs.Empty);
Invalidate();
[Localizable(true)]
[DefaultValue(null)]
+ [MWFCategory("Appearance")]
public virtual Image BackgroundImage {
get {
return background_image;
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool CanFocus {
get {
- if (Visible && is_enabled && GetStyle(ControlStyles.Selectable)) {
+ if (IsHandleCreated && Visible && Enabled) {
return true;
}
return false;
get {
Control parent;
- if (!GetStyle(ControlStyles.Selectable) || this.parent == null) {
+ if (!GetStyle(ControlStyles.Selectable)) {
return false;
}
- parent = this.parent;
+ parent = this;
while (parent != null) {
if (!parent.is_visible || !parent.is_enabled) {
return false;
}
}
+ internal virtual bool InternalCapture {
+ get {
+ return Capture;
+ }
+
+ set {
+ Capture = value;
+ }
+ }
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
}
[DefaultValue(true)]
+ [MWFCategory("Focus")]
public bool CausesValidation {
get {
return this.causes_validation;
}
[DefaultValue(null)]
+ [MWFCategory("Behavior")]
public virtual ContextMenu ContextMenu {
get {
return context_menu;
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool Created {
get {
- if (!this.is_disposed && (this.window.Handle != IntPtr.Zero)) {
- return true;
- }
- return false;
+ return (!is_disposed && is_created);
}
}
[AmbientValue(null)]
+ [MWFCategory("Appearance")]
public virtual Cursor Cursor {
get {
if (cursor != null) {
cursor = value;
- pt = Cursor.Position;
- if (bounds.Contains(pt)) {
- if (GetChildAtPoint(pt) == null) {
- if (cursor != null) {
- XplatUI.SetCursor(window.Handle, cursor.handle);
- } else {
- if (parent != null) {
- XplatUI.SetCursor(window.Handle, parent.Cursor.handle);
+ if (IsHandleCreated) {
+ pt = Cursor.Position;
+
+ if (bounds.Contains(pt)) {
+ if (GetChildAtPoint(pt) == null) {
+ if (cursor != null) {
+ XplatUI.SetCursor(window.Handle, cursor.handle);
} else {
- XplatUI.SetCursor(window.Handle, Cursors.def.handle);
+ if (parent != null) {
+ XplatUI.SetCursor(window.Handle, parent.Cursor.handle);
+ } else {
+ XplatUI.SetCursor(window.Handle, Cursors.def.handle);
+ }
}
}
}
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
[ParenthesizePropertyName(true)]
[RefreshProperties(RefreshProperties.All)]
+ [MWFCategory("Data")]
public ControlBindingsCollection DataBindings {
get {
if (data_bindings == null)
[Localizable(true)]
[RefreshProperties(RefreshProperties.Repaint)]
[DefaultValue(DockStyle.None)]
+ [MWFCategory("Layout")]
public virtual DockStyle Dock {
get {
return dock_style;
[DispId(-514)]
[Localizable(true)]
+ [MWFCategory("Behavior")]
public bool Enabled {
get {
- return is_enabled;
+ if (!is_enabled) {
+ return false;
+ }
+
+ if (parent != null) {
+ return parent.Enabled;
+ }
+
+ return true;
}
set {
return;
}
+ if (IsHandleCreated) {
+ if (this is Form) {
+ if (((Form)this).context == null) {
+ XplatUI.EnableWindow(window.Handle, value);
+ }
+ } else {
+ XplatUI.EnableWindow(window.Handle, value);
+ }
+ }
is_enabled = value;
Refresh();
OnEnabledChanged (EventArgs.Empty);
[DispId(-512)]
[AmbientValue(null)]
[Localizable(true)]
+ [MWFCategory("Appearance")]
public virtual Font Font {
get {
if (font != null) {
return DefaultFont;
}
+ [param:MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Font))]
set {
if (font != null && font.Equals (value)) {
return;
}
[DispId(-513)]
+ [MWFCategory("Appearance")]
public virtual Color ForeColor {
get {
if (foreground_color.IsEmpty) {
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public IntPtr Handle { // IWin32Window
get {
+#if NET_2_0
+ if (verify_thread_handle) {
+ if (this.InvokeRequired) {
+ throw new InvalidOperationException("Cross-thread access of handle detected. Handle access only valid on thread that created the control");
+ }
+ }
+#endif
if (!IsHandleCreated) {
CreateHandle();
}
[AmbientValue(ImeMode.Inherit)]
[Localizable(true)]
+ [MWFCategory("Behavior")]
public ImeMode ImeMode {
get {
if (ime_mode == DefaultImeMode) {
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool InvokeRequired { // ISynchronizeInvoke
get {
- if (creator_thread!=Thread.CurrentThread) {
+ if (creator_thread != null && creator_thread!=Thread.CurrentThread) {
return true;
}
return false;
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public bool IsHandleCreated {
get {
- if ((window!=null) && (window.Handle!=IntPtr.Zero)) {
+ if ((window != null) && (window.Handle != IntPtr.Zero)) {
return true;
}
}
[Localizable(true)]
+ [MWFCategory("Layout")]
public Point Location {
get {
return new Point(bounds.X, bounds.Y);
[Browsable(false)]
public string Name {
get {
- return this.name;
+ return name;
}
set {
- this.name=value;
+ name = value;
}
}
+#if NET_2_0
+ [Localizable(true)]
+ public Padding Padding {
+ get {
+ return padding;
+ }
+
+ set {
+ padding = value;
+ }
+ }
+#endif
+
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public Control Parent {
return;
}
- parent=value;
-
- if (!parent.Controls.Contains(this)) {
- parent.Controls.Add(this);
- }
-
- if (IsHandleCreated) {
- XplatUI.SetParent(Handle, value.Handle);
- }
-
- OnParentChanged(EventArgs.Empty);
- InitLayout();
+ value.Controls.Add(this);
}
}
}
[AmbientValue(RightToLeft.Inherit)]
[Localizable(true)]
+ [MWFCategory("Appearance")]
public virtual RightToLeft RightToLeft {
get {
if (right_to_left == RightToLeft.Inherit) {
set {
base.Site = value;
+
+ AmbientProperties ap = (AmbientProperties) value.GetService (typeof (AmbientProperties));
+ if (ap != null) {
+ BackColor = ap.BackColor;
+ ForeColor = ap.ForeColor;
+ Cursor = ap.Cursor;
+ Font = ap.Font;
+ }
}
}
[Localizable(true)]
+ [MWFCategory("Layout")]
public Size Size {
get {
return new Size(Width, Height);
[Localizable(true)]
[MergableProperty(false)]
+ [MWFCategory("Behavior")]
public int TabIndex {
get {
if (tab_index != -1) {
[DispId(-516)]
[DefaultValue(true)]
+ [MWFCategory("Behavior")]
public bool TabStop {
get {
return tab_stop;
[Bindable(true)]
[TypeConverter(typeof(StringConverter))]
[DefaultValue(null)]
+ [MWFCategory("Data")]
public object Tag {
get {
return control_tag;
[DispId(-517)]
[Localizable(true)]
[BindableAttribute(true)]
+ [MWFCategory("Appearance")]
public virtual string Text {
get {
+ // Our implementation ignores ControlStyles.CacheText - we always cache
return this.text;
}
text=value;
if (IsHandleCreated) {
XplatUI.Text(Handle, text);
- } else {
- // FIXME: Do we need a Refresh() here?
- Refresh();
}
OnTextChanged (EventArgs.Empty);
}
}
[Localizable(true)]
+ [MWFCategory("Behavior")]
public bool Visible {
get {
if (!is_visible) {
create_params.Param = 0;
if (allow_drop) {
- create_params.ExStyle |= (int)WindowStyles.WS_EX_ACCEPTFILES;
+ create_params.ExStyle |= (int)WindowExStyles.WS_EX_ACCEPTFILES;
}
- if (parent!=null) {
+ if ((parent!=null) && (parent.IsHandleCreated)) {
create_params.Parent = parent.Handle;
}
create_params.Style |= (int)WindowStyles.WS_VISIBLE;
}
+ if (!is_enabled) {
+ create_params.Style |= (int)WindowStyles.WS_DISABLED;
+ }
+
+ switch (border_style) {
+ case BorderStyle.FixedSingle:
+ create_params.Style |= (int) WindowStyles.WS_BORDER;
+ break;
+ case BorderStyle.Fixed3D:
+ create_params.ExStyle |= (int) WindowExStyles.WS_EX_CLIENTEDGE;
+ break;
+ }
+
return create_params;
}
}
protected virtual Size DefaultSize {
get {
- return new Size(100, 23);
+ return new Size(0, 0);
}
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
public static Control FromHandle(IntPtr handle) {
+#if not
IEnumerator control = Control.controls.GetEnumerator();
while (control.MoveNext()) {
return ((Control)control.Current);
}
}
+
return null;
+#else
+ return Control.ControlNativeWindow.ControlFromHandle(handle);
+#endif
}
public static bool IsMnemonic(char charCode, string text) {
#region Public Instance Methods
[EditorBrowsable(EditorBrowsableState.Advanced)]
public IAsyncResult BeginInvoke(Delegate method) {
- return BeginInvokeInternal(method, null);
+ object [] prms = null;
+ if (method is EventHandler)
+ prms = new object [] { this, EventArgs.Empty };
+ return BeginInvokeInternal(method, prms, false);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
public IAsyncResult BeginInvoke (Delegate method, object[] args) {
- return BeginInvokeInternal (method, args);
+ return BeginInvokeInternal (method, args, false);
}
public void BringToFront() {
if (parent.child_controls.Contains(this)) {
parent.child_controls.SetChildIndex(this, 0);
}
+ } else if (parent != null) {
+ if (parent.child_controls.impl_list != null) {
+ Control last_impl = (Control) parent.child_controls.impl_list [parent.child_controls.impl_list.Count - 1];
+ if (IsHandleCreated) {
+ XplatUI.SetZOrder (this.window.Handle, last_impl.Handle, false, false);
+ }
+ } else {
+ if (IsHandleCreated) {
+ XplatUI.SetZOrder(this.window.Handle, IntPtr.Zero, true, false);
+ }
+ }
}
- XplatUI.SetZOrder(this.window.Handle, IntPtr.Zero, true, false);
-
if (parent != null) {
parent.Refresh();
}
}
public void CreateControl() {
+ if (is_created) {
+ return;
+ }
if (!IsHandleCreated) {
CreateHandle();
}
- if (!create_handled) {
- create_handled = true;
- OnCreateControl();
+ if (!is_created) {
+ is_created = true;
}
- for (int i=0; i<child_controls.Count; i++) {
- child_controls[i].CreateControl();
+ Control [] controls = child_controls.GetAllControls ();
+ for (int i=0; i<controls.Length; i++) {
+ controls [i].CreateControl ();
+ }
+
+ UpdateZOrder();
+
+ if (binding_context == null) { // seem to be sent whenever it's null?
+ OnBindingContextChanged(EventArgs.Empty);
}
+
+ OnCreateControl();
}
public Graphics CreateGraphics() {
if (!IsHandleCreated) {
- this.CreateControl();
+ this.CreateHandle();
}
return Graphics.FromHwnd(this.window.Handle);
}
}
public bool Focus() {
- if (IsHandleCreated && !has_focus) {
- has_focus = true;
+ if (CanFocus && IsHandleCreated && !has_focus) {
XplatUI.SetFocus(window.Handle);
}
- return true;
+ return has_focus;
}
public Control GetChildAtPoint(Point pt) {
}
public void Invalidate(System.Drawing.Rectangle rc, bool invalidateChildren) {
- if (!IsHandleCreated || !Visible) {
+ if (!IsHandleCreated || !Visible || rc.Width == 0 || rc.Height == 0) {
return;
}
XplatUI.Invalidate(Handle, rc, false);
if (invalidateChildren) {
- for (int i=0; i<child_controls.Count; i++) child_controls[i].Invalidate();
+ Control [] controls = child_controls.GetAllControls ();
+ for (int i=0; i<controls.Length; i++)
+ controls [i].Invalidate ();
}
OnInvalidated(new InvalidateEventArgs(rc));
}
Invalidate(region, false);
}
- [MonoTODO("Figure out if GetRegionScans is usable")]
public void Invalidate(System.Drawing.Region region, bool invalidateChildren) {
- throw new NotImplementedException();
-
- // FIXME - should use the GetRegionScans function of the region to invalidate each area
- //if (invalidateChildren) {
- // for (int i=0; i<child_controls.Count; i++) child_controls[i].Invalidate();
- //}
+ RectangleF bounds = region.GetBounds (CreateGraphics ());
+ Invalidate (new Rectangle ((int) bounds.X, (int) bounds.Y, (int) bounds.Width, (int) bounds.Height),
+ invalidateChildren);
}
public object Invoke (Delegate method) {
- return Invoke(method, null);
+ object [] prms = null;
+ if (method is EventHandler)
+ prms = new object [] { this, EventArgs.Empty };
+
+ return Invoke(method, prms);
}
public object Invoke (Delegate method, object[] args) {
return EndInvoke(result);
}
+ internal object InvokeInternal (Delegate method, bool disposing) {
+ return InvokeInternal(method, null, disposing);
+ }
+
+ internal object InvokeInternal (Delegate method, object[] args, bool disposing) {
+ if (!this.InvokeRequired) {
+ return method.DynamicInvoke(args);
+ }
+
+ IAsyncResult result = BeginInvokeInternal (method, args, disposing);
+ return EndInvoke(result);
+ }
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
public void PerformLayout() {
PerformLayout(null, null);
public void PerformLayout(Control affectedControl, string affectedProperty) {
LayoutEventArgs levent = new LayoutEventArgs(affectedControl, affectedProperty);
- if (layout_suspended>0) {
+ if (layout_suspended > 0) {
layout_pending = true;
return;
}
Control child;
AnchorStyles anchor;
Rectangle space;
- int diff_width;
- int diff_height;
- space=this.DisplayRectangle;
- if (prev_size != Size.Empty) {
- diff_width = space.Width - prev_size.Width;
- diff_height = space.Height - prev_size.Height;
- } else {
- diff_width = 0;
- diff_height = 0;
- }
+ space= DisplayRectangle;
// Deal with docking; go through in reverse, MS docs say that lowest Z-order is closest to edge
- for (int i = child_controls.Count - 1; i >= 0; i--) {
- child=child_controls[i];
+ Control [] controls = child_controls.GetAllControls ();
+ for (int i = controls.Length - 1; i >= 0; i--) {
+ child = controls [i];
+
+ if (!child.Visible) {
+ continue;
+ }
+
switch (child.Dock) {
case DockStyle.None: {
// Do nothing
}
}
- for (int i = child_controls.Count - 1; i >= 0; i--) {
- child=child_controls[i];
+ for (int i = controls.Length - 1; i >= 0; i--) {
+ child=controls[i];
- if (child.Dock == DockStyle.Fill) {
+ if (child.Visible && (child.Dock == DockStyle.Fill)) {
child.SetBounds(space.Left, space.Top, space.Width, space.Height);
space.Width=0;
space.Height=0;
}
}
- space=this.DisplayRectangle;
+ space=DisplayRectangle;
- // Deal with anchoring
- for (int i=0; i < child_controls.Count; i++) {
+ for (int i=0; i < controls.Length; i++) {
int left;
int top;
int width;
int height;
- child=child_controls[i];
- anchor=child.Anchor;
-
- left=child.Left;
- top=child.Top;
- width=child.Width;
- height=child.Height;
+ child = controls[i];
// If the control is docked we don't need to do anything
if (child.Dock != DockStyle.None) {
continue;
}
+ anchor = child.Anchor;
+
+ left = child.Left;
+ top = child.Top;
+ width = child.Width;
+ height = child.Height;
+
if ((anchor & AnchorStyles.Left) !=0 ) {
if ((anchor & AnchorStyles.Right) != 0) {
- // Anchoring to left and right
- width=width+diff_width;
+ width = space.Width - child.dist_right - left;
} else {
- ; // nothing to do
+ ; // Left anchored only, nothing to be done
}
} else if ((anchor & AnchorStyles.Right) != 0) {
- left+=diff_width;
+ left = space.Width - child.dist_right - width;
} else {
- left+=diff_width/2;
+ // left+=diff_width/2 will introduce rounding errors (diff_width removed from svn after r51780)
+ // This calculates from scratch every time:
+ left = child.dist_left + (space.Width - (child.dist_left + width + child.dist_right)) / 2;
}
if ((anchor & AnchorStyles.Top) !=0 ) {
if ((anchor & AnchorStyles.Bottom) != 0) {
- height+=diff_height;
+ height = space.Height - child.dist_bottom - top;
} else {
- ; // nothing to do
+ ; // Top anchored only, nothing to be done
}
} else if ((anchor & AnchorStyles.Bottom) != 0) {
- top+=diff_height;
+ top = space.Height - child.dist_bottom - height;
} else {
- top+=diff_height/2;
+ // top += diff_height/2 will introduce rounding errors (diff_height removed from after r51780)
+ // This calculates from scratch every time:
+ top = child.dist_top + (space.Height - (child.dist_top + height + child.dist_bottom)) / 2;
}
-
+
// Sanity
if (width < 0) {
width=0;
Keys key_data;
if ((msg.Msg == (int)Msg.WM_KEYDOWN) || (msg.Msg == (int)Msg.WM_SYSKEYDOWN)) {
- key_data = (Keys)msg.WParam.ToInt32();
+ key_data = (Keys)msg.WParam.ToInt32() | XplatUI.State.ModifierKeys;
+
if (!ProcessCmdKey(ref msg, key_data)) {
if (IsInputKey(key_data)) {
- return true;
+ return false;
}
return ProcessDialogKey(key_data);
return true;
} else if (msg.Msg == (int)Msg.WM_CHAR) {
if (IsInputChar((char)msg.WParam)) {
- return true;
+ return false;
}
} else if (msg.Msg == (int)Msg.WM_SYSCHAR) {
if (IsInputChar((char)msg.WParam)) {
- return true;
+ return false;
}
return ProcessDialogChar((char)msg.WParam);
}
public virtual void Refresh() {
if (IsHandleCreated == true) {
- int end;
-
Invalidate();
XplatUI.UpdateWindow(window.Handle);
- end = child_controls.Count;
- for (int i=0; i < end; i++) {
- child_controls[i].Refresh();
+ Control [] controls = child_controls.GetAllControls ();
+ for (int i=0; i < controls.Length; i++) {
+ controls[i].Refresh();
}
}
}
[EditorBrowsable(EditorBrowsableState.Never)]
- [MonoTODO]
public void ResetBindings() {
- // Do something
+ data_bindings.Clear();
}
[EditorBrowsable(EditorBrowsableState.Never)]
public virtual void ResetCursor() {
- cursor = null;
+ Cursor = null;
}
[EditorBrowsable(EditorBrowsableState.Never)]
}
public void ResumeLayout(bool performLayout) {
- layout_suspended--;
-
if (layout_suspended > 0) {
- return;
+ layout_suspended--;
}
- if (performLayout || layout_pending) {
- PerformLayout();
+ if (layout_suspended == 0) {
+ Control [] controls = child_controls.GetAllControls ();
+ for (int i=0; i<controls.Length; i++) {
+ controls [i].UpdateDistances ();
+ }
+
+ if (performLayout && layout_pending) {
+ PerformLayout();
+ }
}
}
}
}
- XplatUI.SetZOrder(this.window.Handle, IntPtr.Zero, false, true);
+ if (IsHandleCreated) {
+ XplatUI.SetZOrder(this.window.Handle, IntPtr.Zero, false, true);
+ }
+
if (parent != null) {
parent.Refresh();
}
}
public void Show() {
- if (!IsHandleCreated) {
+ if (!is_created) {
this.CreateControl();
}
public void Update() {
needs_redraw = true;
- XplatUI.UpdateWindow(window.Handle);
+ if (IsHandleCreated) {
+ XplatUI.UpdateWindow(window.Handle);
+ }
}
#endregion // Public Instance Methods
throw new ObjectDisposedException(Name);
}
- if (IsHandleCreated) {
+ if (IsHandleCreated && !is_recreating) {
return;
}
window.CreateHandle(CreateParams);
- // Find out where the window manager placed us
- UpdateBounds();
- UpdateStyles();
-
- if (window.Handle!=IntPtr.Zero) {
+ if (window.Handle != IntPtr.Zero) {
if (!controls.Contains(window.Handle)) {
controls.Add(this);
}
creator_thread = Thread.CurrentThread;
- XplatUI.SetWindowBackground(window.Handle, this.BackColor);
+ XplatUI.EnableWindow(window.Handle, is_enabled);
+
+ // Set our handle with our parent
+ if ((parent != null) && (parent.IsHandleCreated)) {
+ XplatUI.SetParent(window.Handle, parent.Handle);
+ }
+
+ // Set our handle as parent for our children
+ Control [] children;
+
+ children = child_controls.GetAllControls ();
+ for (int i = 0; i < children.Length; i++ ) {
+ if (children[i].IsHandleCreated) {
+ XplatUI.SetParent(children[i].Handle, window.Handle);
+ }
+ }
+
+ UpdateStyles();
+ XplatUI.SetAllowDrop (Handle, allow_drop);
+
+ // Find out where the window manager placed us
+ if ((CreateParams.Style & (int)WindowStyles.WS_CHILD) != 0) {
+ XplatUI.SetBorderStyle(window.Handle, (FormBorderStyle)border_style);
+ }
+ UpdateBounds();
OnHandleCreated(EventArgs.Empty);
}
+
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void DestroyHandle() {
if (IsHandleCreated) {
- // Destroy our children before we destroy ourselves, to prevent them from
- // being implictly (without us knowing) destroyed
- for (int i=0; i < child_controls.Count; i++) {
- child_controls[i].DestroyHandle();
- }
-
-
if (window != null) {
window.DestroyHandle();
}
- OnHandleDestroyed(EventArgs.Empty);
}
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void InitLayout() {
- if (parent != null) {
- parent.PerformLayout(this, "parent");
- }
+ UpdateDistances();
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
}
protected virtual bool IsInputChar (char charCode) {
- if (parent != null) {
- return parent.IsInputChar(charCode);
- }
-
- return false;
+ return true;
}
protected virtual bool IsInputKey (Keys keyData) {
KeyEventArgs key_event;
switch (msg.Msg) {
+ case (int)Msg.WM_SYSKEYDOWN:
case (int)Msg.WM_KEYDOWN: {
key_event = new KeyEventArgs ((Keys)msg.WParam.ToInt32 ());
OnKeyDown (key_event);
return key_event.Handled;
}
+
+ case (int)Msg.WM_SYSKEYUP:
case (int)Msg.WM_KEYUP: {
key_event = new KeyEventArgs ((Keys)msg.WParam.ToInt32 ());
OnKeyUp (key_event);
return key_event.Handled;
}
+ case (int)Msg.WM_SYSCHAR:
case (int)Msg.WM_CHAR: {
KeyPressEventArgs key_press_event;
}
}
- return false;
+ return ProcessKeyEventArgs(ref msg);
}
protected virtual bool ProcessKeyPreview(ref Message msg) {
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected void RecreateHandle() {
- IEnumerator child = child_controls.GetEnumerator();
-
is_recreating=true;
if (IsHandleCreated) {
DestroyHandle();
- CreateHandle();
-
- // FIXME ZOrder?
-
- while (child.MoveNext()) {
- ((Control)child.Current).RecreateHandle();
- }
+ // WM_DESTROY will CreateHandle for us
} else {
- CreateControl();
+ if (!is_created) {
+ CreateControl();
+ } else {
+ CreateHandle();
+ }
}
is_recreating = false;
location = new Point((int)(Left * dx), (int)(Top * dy));
size = this.ClientSize;
-
if (!GetStyle(ControlStyles.FixedWidth)) {
size.Width = (int)(size.Width * dx);
size.Height = (int)(size.Height * dy);
}
- Location = location;
- ClientSize = size;
+ SetBoundsCore(location.X, location.Y, size.Width, size.Height, BoundsSpecified.All);
/* Now scale our children */
- for (int i=0; i < child_controls.Count; i++) {
- child_controls[i].Scale(dx, dy);
+ Control [] controls = child_controls.GetAllControls ();
+ for (int i=0; i < controls.Length; i++) {
+ controls[i].Scale(dx, dy);
}
ResumeLayout();
if (IsHandleCreated) {
XplatUI.SetWindowPos(Handle, x, y, width, height);
}
+
UpdateBounds(x, y, width, height);
+
+ UpdateDistances();
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
ClientRect = new Rectangle(0, 0, x, y);
cp = this.CreateParams;
- if (XplatUI.CalculateWindowRect(Handle, ref ClientRect, cp.Style, cp.ExStyle, IntPtr.Zero, out WindowRect)==false) {
+ if (XplatUI.CalculateWindowRect(ref ClientRect, cp.Style, cp.ExStyle, null, out WindowRect)==false) {
return;
}
} else {
control_style &= ~flag;
}
- OnStyleChanged(EventArgs.Empty);
}
protected void SetTopLevel(bool value) {
protected virtual void SetVisibleCore(bool value) {
if (value!=is_visible) {
+ if (value && !is_created) {
+ CreateControl();
+ }
+
is_visible=value;
if (IsHandleCreated) {
OnVisibleChanged(EventArgs.Empty);
- if (!is_visible) {
- if (dc_mem != null) {
- dc_mem.Dispose();
- dc_mem = null;
- }
-
- if (bmp_mem != null) {
- bmp_mem.Dispose();
- bmp_mem = null;
- }
- } else {
- this.CreateBuffers(bounds.Width, bounds.Height);
- CreateControl();
- }
-
if (value == false && parent != null) {
Control container;
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected void UpdateBounds(int x, int y, int width, int height) {
+ CreateParams cp;
+ Rectangle rect;
+
+ // Calculate client rectangle
+ rect = new Rectangle(0, 0, 0, 0);
+ cp = CreateParams;
+
+ XplatUI.CalculateWindowRect(ref rect, cp.Style, cp.ExStyle, cp.menu, out rect);
+ UpdateBounds(x, y, width, height, width - (rect.Right - rect.Left), height - (rect.Bottom - rect.Top));
+ }
+
+ [EditorBrowsable(EditorBrowsableState.Advanced)]
+ protected void UpdateBounds(int x, int y, int width, int height, int clientWidth, int clientHeight) {
// UpdateBounds only seems to set our sizes and fire events but not update the GUI window to match
bool moved = false;
bool resized = false;
- int client_x_diff = this.bounds.Width-this.client_size.Width;
- int client_y_diff = this.bounds.Height-this.client_size.Height;
-
// Needed to generate required notifications
if ((this.bounds.X!=x) || (this.bounds.Y!=y)) {
moved=true;
bounds.Width=width;
bounds.Height=height;
- // Update client rectangle as well
- if (this.layout_suspended==0) {
- prev_size.Width=client_size.Width;
- prev_size.Height=client_size.Height;
- }
-
- client_size.Width=width-client_x_diff;
- client_size.Height=height-client_y_diff;
+ client_size.Width=clientWidth;
+ client_size.Height=clientHeight;
if (moved) {
OnLocationChanged(EventArgs.Empty);
}
}
- [EditorBrowsable(EditorBrowsableState.Advanced)]
- protected void UpdateBounds(int x, int y, int width, int height, int clientWidth, int clientHeight) {
- UpdateBounds(x, y, width, height);
-
- this.client_size.Width=clientWidth;
- this.client_size.Height=clientHeight;
- }
-
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected void UpdateStyles() {
if (!IsHandleCreated) {
}
XplatUI.SetWindowStyle(window.Handle, CreateParams);
+ OnStyleChanged(EventArgs.Empty);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected void UpdateZOrder() {
- int children;
-#if not
- Control ctl;
-
- if (parent == null) {
- return;
- }
-
- ctl = parent;
-
- children = ctl.child_controls.Count;
- for (int i = 1; i < children; i++ ) {
- XplatUI.SetZOrder(ctl.child_controls[i].window.Handle, ctl.child_controls[i-1].window.Handle, false, false);
- }
-#else
+ Control [] controls;
if (!IsHandleCreated) {
return;
}
- children = child_controls.Count;
- for (int i = 1; i < children; i++ ) {
- XplatUI.SetZOrder(child_controls[i].Handle, child_controls[i-1].Handle, false, false);
+ controls = child_controls.GetAllControls ();
+ for (int i = 1; i < controls.Length; i++ ) {
+ XplatUI.SetZOrder(controls[i].Handle, controls[i-1].Handle, false, false);
}
-#endif
}
protected virtual void WndProc(ref Message m) {
#if debug
- Console.WriteLine("Control received message {0}", (Msg)m.Msg);
+ Console.WriteLine("Control {0} received message {1}", window.Handle == IntPtr.Zero ? this.Text : XplatUI.Window(window.Handle), (Msg)m.Msg);
#endif
if ((this.control_style & ControlStyles.EnableNotifyMessage) != 0) {
OnNotifyMessage(m);
}
switch((Msg)m.Msg) {
+ case Msg.WM_DESTROY: {
+ OnHandleDestroyed(EventArgs.Empty);
+ window.InvalidateHandle();
+
+ if (ParentIsRecreating) {
+ RecreateHandle();
+ } else if (is_recreating) {
+ CreateHandle();
+ }
+ return;
+ }
+
case Msg.WM_WINDOWPOSCHANGED: {
if (Visible) {
UpdateBounds();
return;
}
- case Msg.WM_PAINT: {
+ // Nice description of what should happen when handling WM_PAINT
+ // can be found here: http://pluralsight.com/wiki/default.aspx/Craig/FlickerFreeControlDrawing.html
+ // and here http://msdn.microsoft.com/msdnmag/issues/06/03/WindowsFormsPerformance/
+ case Msg.WM_PAINT: {
PaintEventArgs paint_event;
paint_event = XplatUI.PaintEventStart(Handle, true);
}
Graphics dc = null;
- if ((control_style & ControlStyles.DoubleBuffer) != 0) {
- dc = paint_event.SetGraphics (DeviceContext);
- }
+ if (ThemeEngine.Current.DoubleBufferingSupported)
+ if ((control_style & ControlStyles.DoubleBuffer) != 0) {
+ dc = paint_event.SetGraphics (DeviceContext);
+ }
- if ((control_style & (ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint)) != (ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint)) {
+ if (!GetStyle(ControlStyles.Opaque)) {
OnPaintBackground(paint_event);
}
- OnPaint(paint_event);
+ // Button-derived controls choose to ignore their Opaque style, give them a chance to draw their background anyways
+ OnPaintBackgroundInternal(paint_event);
- if ((control_style & ControlStyles.DoubleBuffer) != 0) {
- dc.DrawImage (ImageBuffer, paint_event.ClipRectangle, paint_event.ClipRectangle, GraphicsUnit.Pixel);
- paint_event.SetGraphics (dc);
- needs_redraw = false;
+ OnPaintInternal(paint_event);
+ if (!paint_event.Handled) {
+ OnPaint(paint_event);
}
+ if (ThemeEngine.Current.DoubleBufferingSupported)
+ if ((control_style & ControlStyles.DoubleBuffer) != 0) {
+ dc.DrawImage (ImageBuffer, paint_event.ClipRectangle, paint_event.ClipRectangle, GraphicsUnit.Pixel);
+ paint_event.SetGraphics (dc);
+ needs_redraw = false;
+ }
+
XplatUI.PaintEventEnd(Handle, true);
- if (!GetStyle(ControlStyles.UserPaint)) {
- DefWndProc(ref m);
- }
-
return;
}
case Msg.WM_ERASEBKGND: {
- if (GetStyle (ControlStyles.UserPaint)) {
- if (!GetStyle(ControlStyles.AllPaintingInWmPaint)) {
- PaintEventArgs eraseEventArgs = new PaintEventArgs (m.WParam == IntPtr.Zero ? Graphics.FromHwnd (m.HWnd) :
- Graphics.FromHdc (m.WParam), new Rectangle (new Point (0,0),Size));
- OnPaintBackground (eraseEventArgs);
- }
- } else {
- XplatUI.EraseWindowBackground(m.HWnd, m.WParam);
- }
- // The DefWndProc will never have to handle this, we don't ever set hbr on the window
+ // The DefWndProc will never have to handle this, we always paint the background in managed code
+ // In theory this code would look at ControlStyles.AllPaintingInWmPaint and and call OnPaintBackground
+ // here but it just makes things more complicated...
m.Result = (IntPtr)1;
return;
}
case Msg.WM_LBUTTONUP: {
- HandleClick(mouse_clicks);
- OnMouseUp (new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()) | MouseButtons.Left,
+ MouseEventArgs me;
+
+ me = new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()) | MouseButtons.Left,
mouse_clicks,
LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()),
- 0));
+ 0);
+
+ HandleClick(mouse_clicks, me);
+ OnMouseUp (me);
+
+ if (InternalCapture) {
+ InternalCapture = false;
+ }
+
if (mouse_clicks > 1) {
mouse_clicks = 1;
}
if (CanSelect && !is_selected) {
Select(this);
}
+ InternalCapture = true;
OnMouseDown (new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()),
mouse_clicks, LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()),
0));
}
case Msg.WM_LBUTTONDBLCLK: {
+ InternalCapture = true;
mouse_clicks++;
OnMouseDown (new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()),
mouse_clicks, LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()),
}
case Msg.WM_MBUTTONUP: {
- HandleClick(mouse_clicks);
- OnMouseUp (new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()) | MouseButtons.Middle,
+ MouseEventArgs me;
+
+ me = new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()) | MouseButtons.Middle,
mouse_clicks,
LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()),
- 0));
+ 0);
+
+ HandleClick(mouse_clicks, me);
+ OnMouseUp (me);
+ if (InternalCapture) {
+ InternalCapture = false;
+ }
if (mouse_clicks > 1) {
mouse_clicks = 1;
}
}
case Msg.WM_MBUTTONDOWN: {
+ InternalCapture = true;
OnMouseDown (new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()),
mouse_clicks, LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()),
0));
}
case Msg.WM_MBUTTONDBLCLK: {
+ InternalCapture = true;
mouse_clicks++;
OnMouseDown (new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()),
mouse_clicks, LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()),
}
case Msg.WM_RBUTTONUP: {
- if (context_menu != null) {
- context_menu.Show(this, new Point(LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ())));
- }
+ MouseEventArgs me;
+ Point pt;
+
+ pt = new Point(LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()));
+ pt = PointToScreen(pt);
- HandleClick(mouse_clicks);
- OnMouseUp (new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()) | MouseButtons.Right,
+ XplatUI.SendMessage(m.HWnd, Msg.WM_CONTEXTMENU, m.HWnd, (IntPtr)(pt.X + (pt.Y << 16)));
+
+ me = new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()) | MouseButtons.Right,
mouse_clicks,
LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()),
- 0));
+ 0);
+
+ HandleClick(mouse_clicks, me);
+ OnMouseUp (me);
+
+ if (InternalCapture) {
+ InternalCapture = false;
+ }
+
if (mouse_clicks > 1) {
mouse_clicks = 1;
}
}
case Msg.WM_RBUTTONDOWN: {
+ InternalCapture = true;
OnMouseDown (new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()),
mouse_clicks, LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()),
0));
}
case Msg.WM_RBUTTONDBLCLK: {
+ InternalCapture = true;
mouse_clicks++;
OnMouseDown (new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()),
mouse_clicks, LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()),
return;
}
+ case Msg.WM_CONTEXTMENU: {
+ if (context_menu != null) {
+ Point pt;
+
+ pt = new Point(LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()));
+ context_menu.Show(this, PointToClient(pt));
+ return;
+ }
+
+ DefWndProc(ref m);
+ return;
+ }
+
case Msg.WM_MOUSEWHEEL: {
OnMouseWheel (new MouseEventArgs (FromParamToMouseButtons ((int) m.WParam.ToInt32()),
return;
}
- case Msg.WM_SYSKEYDOWN:
- case Msg.WM_KEYDOWN:
- case Msg.WM_SYSKEYUP:
- case Msg.WM_KEYUP:
- case Msg.WM_SYSCHAR:
- case Msg.WM_CHAR: {
-Console.WriteLine("Got {0}", (Msg)m.Msg);
- if (ProcessKeyEventArgs(ref m)) {
+ case Msg.WM_SYSKEYUP: {
+ if (ProcessKeyMessage(ref m)) {
+ m.Result = IntPtr.Zero;
return;
}
- if (PreProcessMessage(ref m)) {
- return;
+ if ((m.WParam.ToInt32() & (int)Keys.KeyCode) == (int)Keys.Menu) {
+ Form form;
+
+ form = FindForm();
+ if (form != null && form.ActiveMenu != null) {
+ form.ActiveMenu.ProcessCmdKey(ref m, (Keys)m.WParam.ToInt32());
+ }
}
+ DefWndProc (ref m);
+ return;
+ }
+
+ case Msg.WM_SYSKEYDOWN:
+ case Msg.WM_KEYDOWN:
+ case Msg.WM_KEYUP:
+ case Msg.WM_SYSCHAR:
+ case Msg.WM_CHAR: {
if (ProcessKeyMessage(ref m)) {
+ m.Result = IntPtr.Zero;
return;
}
DefWndProc (ref m);
case Msg.WM_SETCURSOR: {
- if (cursor == null) {
+ if ((cursor == null) || ((HitTest)(m.LParam.ToInt32() & 0xffff) != HitTest.HTCLIENT)) {
DefWndProc(ref m);
return;
}
if (Paint!=null) Paint(this, e);
}
+ internal virtual void OnPaintBackgroundInternal(PaintEventArgs e) {
+ // Override me
+ }
+
+ internal virtual void OnPaintInternal(PaintEventArgs e) {
+ // Override me
+ }
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnPaintBackground(PaintEventArgs pevent) {
PaintControlBackground (pevent);
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnVisibleChanged(EventArgs e) {
- if (!is_visible) {
- if (dc_mem!=null) {
- dc_mem.Dispose ();
- dc_mem=null;
- }
-
- if (bmp_mem!=null) {
- bmp_mem.Dispose();
- bmp_mem=null;
- }
- } else {
+ if ((parent != null) && !Created && Visible) {
if (!is_disposed) {
- if (!this.IsHandleCreated) {
- this.CreateControl();
- }
+ CreateControl();
PerformLayout();
}
}
+
+ needs_redraw = true;
if (VisibleChanged!=null) VisibleChanged(this, e);
// We need to tell our kids
for (int i=0; i<child_controls.Count; i++) {
- child_controls[i].OnParentVisibleChanged(e);
+ if (child_controls[i].Visible) {
+ child_controls[i].OnParentVisibleChanged(e);
+ }
}
}
#endregion // OnXXX methods
projects / mono.git / blobdiff