// John Sohn jsohn@columbus.rr.com
//
-// COMPLETE
-
#undef DebugRecreate
#undef DebugFocus
namespace System.Windows.Forms
{
+#if NET_2_0
+ [ComVisible(true)]
+ [ClassInterface (ClassInterfaceType.AutoDispatch)]
+#endif
[Designer("System.Windows.Forms.Design.ControlDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
[DefaultProperty("Text")]
[DefaultEvent("Click")]
[DesignerSerializer("System.Windows.Forms.Design.ControlCodeDomSerializer, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.Serialization.CodeDomSerializer, " + Consts.AssemblySystem_Design)]
[ToolboxItemFilter("System.Windows.Forms")]
public class Control : Component, ISynchronizeInvoke, IWin32Window
+#if NET_2_0
+ , IBindableComponent, IDropTarget
+#endif
{
#region Local Variables
// Basic
internal Rectangle bounds; // bounding rectangle for control (client area + decorations)
- Rectangle explicit_bounds; // explicitly set bounds
+ Rectangle explicit_bounds; // explicitly set bounds
internal object creator_thread; // thread that created the control
- internal ControlNativeWindow window; // object for native window handle
- string name; // for object naming
+ internal ControlNativeWindow window; // object for native window handle
+ string name; // for object naming
// State
- 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 bool is_enabled; // true if control is enabled (usable/not grayed out)
- bool is_accessible; // true if the control is visible to accessibility applications
- bool is_captured; // tracks if the control has captured the mouse
+ 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 bool is_enabled; // true if control is enabled (usable/not grayed out)
+ bool is_accessible; // true if the control is visible to accessibility applications
+ bool is_captured; // tracks if the control has captured the mouse
internal bool is_toplevel; // tracks if the control is a toplevel window
- bool is_recreating; // tracks if the handle for the control is being recreated
- bool causes_validation; // tracks if validation is executed on changes
- bool is_focusing; // tracks if Focus has been called on the control and has not yet finished
- int tab_index; // position in tab order of siblings
- bool tab_stop; // is the control a tab stop?
- bool is_disposed; // has the window already been disposed?
- Size client_size; // size of the client area (window excluding decorations)
- Rectangle client_rect; // rectangle with the client area (window excluding decorations)
- ControlStyles control_style; // rather win32-specific, style bits for control
- ImeMode ime_mode;
- bool layout_pending; // true if our parent needs to re-layout us
- object control_tag; // object that contains data about our control
+ bool is_recreating; // tracks if the handle for the control is being recreated
+ bool causes_validation; // tracks if validation is executed on changes
+ bool is_focusing; // tracks if Focus has been called on the control and has not yet finished
+ bool container_selected; // true if Select() or Focus() is called on a container, to prevent child controls from raising their GotFocus event
+ int tab_index; // position in tab order of siblings
+ bool tab_stop; // is the control a tab stop?
+ bool is_disposed; // has the window already been disposed?
+ Size client_size; // size of the client area (window excluding decorations)
+ Rectangle client_rect; // rectangle with the client area (window excluding decorations)
+ ControlStyles control_style; // rather win32-specific, style bits for control
+ ImeMode ime_mode;
+ object control_tag; // object that contains data about our control
internal int mouse_clicks; // Counter for mouse clicks
- Cursor cursor; // Cursor for the window
+ Cursor cursor; // Cursor for the window
internal bool allow_drop; // true if the control accepts droping objects on it
- Region clip_region; // User-specified clip region for the window
+ Region clip_region; // User-specified clip region for the window
// Visuals
internal Color foreground_color; // foreground color for control
internal Color background_color; // background color for control
- Image background_image; // background image for control
+ Image background_image; // background image for control
internal Font font; // font for control
- string text; // window/title text for control
- internal BorderStyle border_style; // Border style of control
+ string text; // window/title text for control
+ internal BorderStyle border_style; // Border style of control
// Layout
+ internal enum LayoutType {
+ Anchor,
+ Dock
+ }
+ Layout.LayoutEngine layout_engine;
int layout_suspended;
- internal AnchorStyles anchor_style; // anchoring requirements for our control
- internal DockStyle dock_style; // docking requirements for our control (supercedes anchoring)
- // Please leave the next 4 as internal until DefaultLayout (2.0) is rewritten
- internal int dist_left; // distance to the left border of the parent
- internal int dist_top; // distance to the top border of the parent
+ bool layout_pending; // true if our parent needs to re-layout us
+ internal AnchorStyles anchor_style; // anchoring requirements for our control
+ internal DockStyle dock_style; // docking requirements for our control
+ LayoutType layout_type;
+
+ // Please leave the next 2 as internal until DefaultLayout (2.0) is rewritten
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...
- ControlCollection child_controls; // our children
- Control parent; // our parent control
- AccessibleObject accessibility_object; // object that contains accessibility information about our control
- BindingContext binding_context;
- RightToLeft right_to_left; // drawing direction for control
- ContextMenu context_menu; // Context menu associated with the control
+ ControlCollection child_controls; // our children
+ Control parent; // our parent control
+ AccessibleObject accessibility_object; // object that contains accessibility information about our control
+ BindingContext binding_context;
+ RightToLeft right_to_left; // drawing direction for control
+ ContextMenu context_menu; // Context menu associated with the control
// double buffering
- Graphics backbuffer_dc;
- object backbuffer;
- Region invalid_region;
+ DoubleBuffer backbuffer;
+
+ // to implement DeviceContext without depending on double buffering
+ Bitmap bmp;
+ Graphics bmp_g;
ControlBindingsCollection data_bindings;
internal bool use_compatible_text_rendering;
static bool verify_thread_handle;
Padding padding;
+ ImageLayout backgroundimage_layout;
Size maximum_size;
Size minimum_size;
Size preferred_size;
Padding margin;
- Layout.LayoutEngine layout_engine;
+ private ContextMenuStrip context_menu_strip;
#endif
#endregion // Local Variables
#endregion // ControlAccessibleObject Public Instance Methods
}
+ private class DoubleBuffer : IDisposable
+ {
+ public Region InvalidRegion;
+ private Stack real_graphics;
+ private object back_buffer;
+ private Control parent;
+ private bool pending_disposal;
+
+ public DoubleBuffer (Control parent)
+ {
+ this.parent = parent;
+ real_graphics = new Stack ();
+ int width = parent.Width;
+ int height = parent.Height;
+
+ if (width < 1) width = 1;
+ if (height < 1) height = 1;
+
+ XplatUI.CreateOffscreenDrawable (parent.Handle, width, height, out back_buffer);
+ Invalidate ();
+ }
+
+ public void Blit (PaintEventArgs pe)
+ {
+ Graphics buffered_graphics;
+ buffered_graphics = XplatUI.GetOffscreenGraphics (back_buffer);
+ XplatUI.BlitFromOffscreen (parent.Handle, pe.Graphics, back_buffer, buffered_graphics, pe.ClipRectangle);
+ buffered_graphics.Dispose ();
+ }
+
+ public void Start (PaintEventArgs pe)
+ {
+ // We need to get the graphics for every paint.
+ real_graphics.Push(pe.SetGraphics (XplatUI.GetOffscreenGraphics (back_buffer)));
+ }
+
+ public void End (PaintEventArgs pe)
+ {
+ Graphics buffered_graphics;
+ buffered_graphics = pe.SetGraphics ((Graphics) real_graphics.Pop ());
+
+ if (pending_disposal)
+ Dispose ();
+ else {
+ XplatUI.BlitFromOffscreen (parent.Handle, pe.Graphics, back_buffer, buffered_graphics, pe.ClipRectangle);
+ InvalidRegion.Exclude (pe.ClipRectangle);
+ }
+ buffered_graphics.Dispose ();
+ }
+
+ public void Invalidate ()
+ {
+ if (InvalidRegion != null)
+ InvalidRegion.Dispose ();
+ InvalidRegion = new Region (parent.ClientRectangle);
+ }
+
+ public void Dispose ()
+ {
+ if (real_graphics.Count > 0) {
+ pending_disposal = true;
+ return;
+ }
+
+ XplatUI.DestroyOffscreenDrawable (back_buffer);
+
+ if (InvalidRegion != null)
+ InvalidRegion.Dispose ();
+ InvalidRegion = null;
+ back_buffer = null;
+ GC.SuppressFinalize (this);
+ }
+
+ #region IDisposable Members
+ void IDisposable.Dispose ()
+ {
+ Dispose ();
+ }
+ #endregion
+
+ ~DoubleBuffer ()
+ {
+ Dispose ();
+ }
+ }
+
+ [ListBindable (false)]
+#if NET_2_0
+ [ComVisible (false)]
+ public class ControlCollection : Layout.ArrangedElementCollection, IList, ICollection, ICloneable, IEnumerable {
+#else
[DesignerSerializer("System.Windows.Forms.Design.ControlCollectionCodeDomSerializer, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.Serialization.CodeDomSerializer, " + Consts.AssemblySystem_Design)]
- [ListBindable(false)]
public class ControlCollection : IList, ICollection, ICloneable, IEnumerable {
+#endif
#region ControlCollection Local Variables
+#if !NET_2_0
ArrayList list;
+#endif
ArrayList impl_list;
Control[] all_controls;
Control owner;
#region ControlCollection Public Constructor
public ControlCollection(Control owner) {
this.owner=owner;
+#if !NET_2_0
this.list=new ArrayList();
+#endif
}
#endregion
#region ControlCollection Public Instance Properties
+ int ICollection.Count {
+ get { return Count; }
+ }
+
+
+#if !NET_2_0
public int Count {
- get {
- return list.Count;
- }
+ get { return list.Count; }
}
+#endif
- public bool IsReadOnly {
+#if NET_2_0
+ bool IList.IsReadOnly
+#else
+ public bool IsReadOnly
+#endif
+ {
get {
return list.IsReadOnly;
}
}
+#if NET_2_0
+ public Control Owner { get { return this.owner; } }
+
+ public virtual Control this[string key] {
+ get {
+ int index = IndexOfKey (key);
+
+ if (index >= 0)
+ return this[index];
+
+ return null;
+ }
+ }
+
+ new
+#endif
public virtual Control this[int index] {
get {
if (index < 0 || index >= list.Count) {
}
return (Control)list[index];
}
+
+
}
#endregion // ControlCollection Public Instance Properties
- #region ControlCollection Private Instance Methods
+ #region ControlCollection Instance Methods
public virtual void Add (Control value)
{
if (value == null)
owner.PerformLayout (control, "Parent");
owner.OnControlAdded (new ControlEventArgs (control));
}
-
+#if NET_2_0
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+#endif
public virtual void AddRange (Control[] controls)
{
if (controls == null)
}
}
+#if NET_2_0
+ new
+#endif
public virtual void Clear ()
{
all_controls = null;
return Contains (value) || ImplicitContains (value);
}
+#if NET_2_0
+ public virtual bool ContainsKey (string key)
+ {
+ return IndexOfKey (key) >= 0;
+ }
+#endif
+
+ void ICollection.CopyTo (Array array, int index)
+ {
+ CopyTo (array, index);
+ }
+
+#if !NET_2_0
public void CopyTo (Array array, int index)
{
list.CopyTo(array, index);
}
- public override bool Equals(object other) {
+ public override bool Equals (object other)
+ {
if (other is ControlCollection && (((ControlCollection)other).owner==this.owner)) {
return(true);
} else {
return(false);
}
}
+#endif
+
+#if NET_2_0
+ // LAMESPEC: MSDN says AE, MS implementation throws ANE
+ public Control[] Find (string key, bool searchAllChildren)
+ {
+ if (string.IsNullOrEmpty (key))
+ throw new ArgumentNullException ("key");
+
+ ArrayList al = new ArrayList ();
+
+ foreach (Control c in list) {
+ if (c.Name.Equals (key, StringComparison.CurrentCultureIgnoreCase))
+ al.Add (c);
+
+ if (searchAllChildren)
+ al.AddRange (c.Controls.Find (key, true));
+ }
+
+ return (Control[])al.ToArray (typeof (Control));
+ }
+#endif
public int GetChildIndex(Control child) {
return GetChildIndex(child, false);
}
- public int GetChildIndex(Control child, bool throwException) {
+#if NET_2_0
+ public virtual int
+#else
+ public int
+#endif
+ GetChildIndex(Control child, bool throwException) {
int index;
index=list.IndexOf(child);
return index;
}
- public IEnumerator GetEnumerator() {
+#if NET_2_0
+ public override IEnumerator
+#else
+ public IEnumerator
+#endif
+ GetEnumerator ()
+ {
return list.GetEnumerator();
}
return all_controls;
}
- public override int GetHashCode() {
+#if !NET_2_0
+ public override int GetHashCode()
+ {
return base.GetHashCode();
}
+#endif
- public int IndexOf(Control control) {
+ public int IndexOf(Control control)
+ {
return list.IndexOf(control);
}
- public virtual void Remove(Control value) {
+#if NET_2_0
+ public virtual int IndexOfKey (string key)
+ {
+ if (string.IsNullOrEmpty (key))
+ return -1;
+
+ for (int i = 0; i < list.Count; i++)
+ if (((Control)list[i]).Name.Equals (key, StringComparison.CurrentCultureIgnoreCase))
+ return i;
+
+ return -1;
+ }
+#endif
+
+ public virtual void Remove(Control value)
+ {
if (value == null)
return;
owner.UpdateChildrenZOrder ();
}
- public void RemoveAt(int index) {
+#if NET_2_0
+ new
+#endif
+ public void RemoveAt(int index)
+ {
if (index < 0 || index >= list.Count) {
throw new ArgumentOutOfRangeException("index", index, "ControlCollection does not have that many controls");
}
Remove ((Control)list[index]);
}
- public void SetChildIndex(Control child, int newIndex) {
+#if NET_2_0
+ public virtual void RemoveByKey (string key)
+ {
+ int index = IndexOfKey (key);
+
+ if (index >= 0)
+ RemoveAt (index);
+ }
+
+ public virtual void
+#else
+ public void
+#endif
+ SetChildIndex(Control child, int newIndex)
+ {
if (child == null)
throw new ArgumentNullException ("child");
#region Public Constructors
public Control()
{
+ layout_type = LayoutType.Anchor;
anchor_style = AnchorStyles.Top | AnchorStyles.Left;
is_created = false;
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;
tab_stop = true;
ime_mode = ImeMode.Inherit;
#if NET_2_0
+ backgroundimage_layout = ImageLayout.Tile;
use_compatible_text_rendering = Application.use_compatible_text_rendering;
padding = new Padding(0);
maximum_size = new Size();
minimum_size = new Size();
- preferred_size = new Size();
+ preferred_size = this.DefaultSize;
margin = this.DefaultMargin;
- layout_engine = this.LayoutEngine;
#endif
control_style = ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint |
child_controls = CreateControlsInstance();
client_size = new Size(DefaultSize.Width, DefaultSize.Height);
client_rect = new Rectangle(0, 0, DefaultSize.Width, DefaultSize.Height);
- XplatUI.CalculateWindowRect(ref client_rect, CreateParams.Style, CreateParams.ExStyle, null, out bounds);
+ bounds.Size = SizeFromClientSize (client_size);
+
if ((CreateParams.Style & (int)WindowStyles.WS_CHILD) == 0) {
bounds.X=-1;
bounds.Y=-1;
DisposeBackBuffer ();
- if (invalid_region!=null) {
- invalid_region.Dispose();
- invalid_region=null;
+ if (bmp != null) {
+ bmp.Dispose ();
+ bmp = null;
+ }
+ if (bmp_g != null) {
+ bmp_g.Dispose ();
+ bmp_g = null;
}
+
if (this.InvokeRequired) {
if (Application.MessageLoop) {
this.BeginInvokeInternal(new MethodInvoker(DestroyHandle), null, true);
#endregion // Public Constructors
#region Internal Properties
+ internal bool VisibleInternal {
+ get { return is_visible; }
+ }
+
+ internal LayoutType ControlLayoutType {
+ get { return layout_type; }
+ }
+
internal BorderStyle InternalBorderStyle {
get {
return border_style;
border_style = value;
if (IsHandleCreated) {
- XplatUI.SetBorderStyle(window.Handle, (FormBorderStyle)border_style);
- Refresh();
+ XplatUI.SetBorderStyle (window.Handle, (FormBorderStyle)border_style);
+ RecreateHandle ();
+ Refresh ();
}
}
}
#endregion // Internal Properties
#region Private & Internal Methods
+
+#if NET_2_0
+ void IDropTarget.OnDragDrop (DragEventArgs e)
+ {
+ OnDragDrop (e);
+ }
+
+ void IDropTarget.OnDragEnter (DragEventArgs e)
+ {
+ OnDragEnter (e);
+ }
+
+ void IDropTarget.OnDragLeave (EventArgs e)
+ {
+ OnDragLeave (e);
+ }
+
+ void IDropTarget.OnDragOver (DragEventArgs e)
+ {
+ OnDragOver (e);
+ }
+#endif
+
internal IAsyncResult BeginInvokeInternal (Delegate method, object [] args, bool disposing) {
AsyncMethodResult result;
AsyncMethodData data;
}
internal Graphics DeviceContext {
- get { return Hwnd.bmp_g; }
+ get {
+ if (bmp_g == null) {
+ bmp = new Bitmap(1, 1, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
+ bmp_g = Graphics.FromImage (bmp);
+ }
+ return bmp_g;
+ }
}
private void InvalidateBackBuffer ()
{
- if (invalid_region != null)
- invalid_region.Dispose();
- invalid_region = new Region (ClientRectangle);
+ if (backbuffer != null)
+ backbuffer.Invalidate ();
}
- private void CreateBackBuffer ()
+ private DoubleBuffer GetBackBuffer ()
{
- if (backbuffer != null)
- return;
-
- int width = Width;
- int height = Height;
-
- if (width < 1) width = 1;
- if (height < 1) height = 1;
-
- XplatUI.CreateOffscreenDrawable (Handle, width, height, out backbuffer, out backbuffer_dc);
- InvalidateBackBuffer ();
+ if (backbuffer == null)
+ backbuffer = new DoubleBuffer (this);
+ return backbuffer;
}
private void DisposeBackBuffer ()
{
- if (backbuffer == null)
- return;
-
- XplatUI.DestroyOffscreenDrawable (backbuffer, backbuffer_dc);
- backbuffer = null;
- backbuffer_dc = null;
-
-
- if (invalid_region != null)
- invalid_region.Dispose ();
- invalid_region = null;
+ if (backbuffer != null) {
+ backbuffer.Dispose ();
+ backbuffer = null;
+ }
}
internal static void SetChildColor(Control parent) {
}
container = GetContainerControl();
- if (container != null) {
+ if (container != null && (Control)container != control) {
container.ActiveControl = control;
}
if (control.IsHandleCreated) {
void DrawBackgroundImage (Graphics g)
{
+#if NET_2_0
+ Rectangle drawing_rectangle = new Rectangle ();
+ g.FillRectangle (ThemeEngine.Current.ResPool.GetSolidBrush (BackColor), ClientRectangle);
+
+ switch (backgroundimage_layout)
+ {
+ case ImageLayout.Tile:
+ using (TextureBrush b = new TextureBrush (background_image, WrapMode.Tile)) {
+ g.FillRectangle (b, ClientRectangle);
+ }
+ return;
+ case ImageLayout.Center:
+ drawing_rectangle.Location = new Point (ClientSize.Width / 2 - background_image.Width / 2, ClientSize.Height / 2 - background_image.Height / 2);
+ drawing_rectangle.Size = background_image.Size;
+ break;
+ case ImageLayout.None:
+ drawing_rectangle.Location = Point.Empty;
+ drawing_rectangle.Size = background_image.Size;
+ break;
+ case ImageLayout.Stretch:
+ drawing_rectangle = ClientRectangle;
+ break;
+ case ImageLayout.Zoom:
+ drawing_rectangle = ClientRectangle;
+ if ((float)background_image.Width / (float)background_image.Height < (float)drawing_rectangle.Width / (float) drawing_rectangle.Height) {
+ drawing_rectangle.Width = (int) (background_image.Width * ((float)drawing_rectangle.Height / (float)background_image.Height));
+ drawing_rectangle.X = (ClientRectangle.Width - drawing_rectangle.Width) / 2;
+ } else {
+ drawing_rectangle.Height = (int) (background_image.Height * ((float)drawing_rectangle.Width / (float)background_image.Width));
+ drawing_rectangle.Y = (ClientRectangle.Height - drawing_rectangle.Height) / 2;
+ }
+ break;
+ default:
+ return;
+ }
+
+ g.DrawImage (background_image, drawing_rectangle);
+
+#else
using (TextureBrush b = new TextureBrush (background_image, WrapMode.Tile)) {
g.FillRectangle (b, ClientRectangle);
}
+#endif
}
internal virtual void DndEnter (DragEventArgs e)
}
}
}
+
+ internal void CaptureWithConfine (Control ConfineWindow)
+ {
+ if (this.IsHandleCreated && !is_captured) {
+ is_captured = true;
+ XplatUI.GrabWindow (this.window.Handle, ConfineWindow.Handle);
+ }
+ }
private void CheckDataBindings ()
{
OnRightToLeftChanged(EventArgs.Empty);
}
- if ((new_parent != null) && new_parent.Created && !Created) {
+ if ((new_parent != null) && new_parent.Created && is_visible && !Created) {
CreateControl();
}
}
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;
+ if (parent != null) {
+ if (bounds.Width > 0)
+ dist_right = parent.ClientSize.Width - bounds.X - bounds.Width;
+ if (bounds.Height > 0)
+ dist_bottom = parent.ClientSize.Height - bounds.Y - bounds.Height;
+ }
+ }
+
+ private bool UseDoubleBuffering {
+ get {
+ if (!ThemeEngine.Current.DoubleBufferingSupported)
+ return false;
+
+#if NET_2_0
+ if (DoubleBuffered)
+ return true;
+#endif
+ return (control_style & ControlStyles.DoubleBuffer) != 0;
}
}
#endregion // Private & Internal Methods
}
#if NET_2_0
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [Browsable (false)]
[MonoTODO]
public static bool CheckForIllegalCrossThreadCalls
{
}
set {
+ layout_type = LayoutType.Anchor;
+
anchor_style=value;
- if (parent != null) {
- parent.PerformLayout(this, "Parent");
- }
+ UpdateDistances ();
+
+ if (parent != null)
+ parent.PerformLayout(this, "Anchor");
}
}
#if NET_2_0
// XXX: Implement me!
bool auto_size;
-
+
+ [RefreshProperties (RefreshProperties.All)]
+ [Localizable (true)]
+ [DesignerSerializationVisibility (DesignerSerializationVisibility.Hidden)]
+ [Browsable (false)]
+ [EditorBrowsable (EditorBrowsableState.Never)]
+ [DefaultValue (false)]
+ [MonoTODO("This method currently does nothing")]
public virtual bool AutoSize {
- get {
- //Console.Error.WriteLine("Unimplemented: Control::get_AutoSize()");
- return auto_size;
- }
+ get { return auto_size; }
set {
- Console.Error.WriteLine("Unimplemented: Control::set_AutoSize(bool)");
- auto_size = value;
+ if (this.auto_size != value) {
+ auto_size = value;
+ OnAutoSizeChanged (EventArgs.Empty);
+ }
}
}
-
+
+#if NET_2_0
+ [AmbientValue ("{Width=0, Height=0}")]
+#else
+ [AmbientValue (typeof(Size), "0, 0")]
+#endif
public virtual Size MaximumSize {
get {
return maximum_size;
return minimum_size;
}
set {
- minimum_size = value;
+ if (minimum_size != value) {
+ minimum_size = value;
+ PerformLayout ();
+ }
}
}
#endif // NET_2_0
}
}
+#if NET_2_0
+ [DefaultValue (ImageLayout.Tile)]
+ [Localizable (true)]
+ public virtual ImageLayout BackgroundImageLayout {
+ get {
+ return backgroundimage_layout;
+ }
+ set {
+ if (Array.IndexOf (Enum.GetValues (typeof (ImageLayout)), value) == -1)
+ throw new InvalidEnumArgumentException ("value", (int) value, typeof(ImageLayout));
+
+ if (value != backgroundimage_layout) {
+ backgroundimage_layout = value;
+ Invalidate ();
+ OnBackgroundImageLayoutChanged (EventArgs.Empty);
+ }
+
+ }
+ }
+#endif
[EditorBrowsable(EditorBrowsableState.Advanced)]
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
set {
this.SetClientSizeCore(value.Width, value.Height);
+#if NET_2_0
+ this.OnClientSizeChanged (EventArgs.Empty);
+#endif
}
}
}
}
+ internal bool ContainerSelected {
+ get { return container_selected; }
+ set { container_selected = value; }
+ }
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
return false;
}
}
-
+#if NET_2_0
+ [Browsable (false)]
+#endif
[DefaultValue(null)]
[MWFCategory("Behavior")]
public virtual ContextMenu ContextMenu {
return context_menu;
}
+#if NET_2_0
+ [DefaultValue (null)]
+ public virtual ContextMenuStrip ContextMenuStrip {
+ get { return this.context_menu_strip; }
+ set {
+ if (this.context_menu_strip != value) {
+ this.context_menu_strip = value;
+ OnContextMenuStripChanged (EventArgs.Empty);
+ }
+ }
+ }
+#endif
+
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
public ControlCollection Controls {
}
set {
+ layout_type = LayoutType.Dock;
+
if (dock_style == value) {
return;
}
}
if (parent != null) {
- parent.PerformLayout(this, "Parent");
+ parent.PerformLayout(this, "Dock");
}
OnDockChanged(EventArgs.Empty);
#if NET_2_0
protected virtual bool DoubleBuffered {
get {
- return (control_style & ControlStyles.DoubleBuffer) != 0;
+ return (control_style & ControlStyles.OptimizedDoubleBuffer) != 0;
}
set {
- SetStyle (ControlStyles.DoubleBuffer, value);
+ if (value == DoubleBuffered)
+ return;
+ if (value) {
+ SetStyle (ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);
+ } else {
+ SetStyle (ControlStyles.OptimizedDoubleBuffer, false);
+ }
+
}
}
#endif
}
set {
+ if (this.is_enabled != value) {
+ bool old_value = is_enabled;
- bool old_value = is_enabled;
+ is_enabled = value;
+ if (old_value != value && !value && this.has_focus)
+ SelectNextControl(this, true, true, true, true);
- is_enabled = value;
- if (old_value != value && !value && this.has_focus)
- SelectNextControl(this, true, true, true, true);
-
- OnEnabledChanged (EventArgs.Empty);
+ OnEnabledChanged (EventArgs.Empty);
+ }
}
}
font = value;
Invalidate();
OnFontChanged (EventArgs.Empty);
+ PerformLayout ();
}
}
}
}
+ [Browsable (false)]
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
#if NET_2_0
- public virtual Layout.LayoutEngine LayoutEngine {
- get { return new Layout.DefaultLayout (); }
- }
+ public virtual
#endif
+ Layout.LayoutEngine LayoutEngine {
+ get {
+ if (layout_engine == null)
+ layout_engine = new Layout.DefaultLayout ();
+ return layout_engine;
+ }
+ }
[EditorBrowsable(EditorBrowsableState.Always)]
[Browsable(false)]
[Localizable (true)]
public Padding Margin {
get { return this.margin; }
- set { this.margin = value; }
+ set {
+ if (this.margin != value) {
+ this.margin = value;
+ OnMarginChanged (EventArgs.Empty);
+ }
+ }
}
#endif
}
set {
- padding = value;
+ if (padding != value) {
+ padding = value;
+ OnPaddingChanged (EventArgs.Empty);
+ PerformLayout ();
+ }
}
}
#endif
}
set {
- if (value != null) {
- if (IsHandleCreated) {
- XplatUI.SetClipRegion(Handle, value);
- }
- clip_region = value;
- }
+ if (clip_region != value) {
+ if (value != null && IsHandleCreated)
+ XplatUI.SetClipRegion(Handle, value);
+
+ clip_region = value;
+#if NET_2_0
+ OnRegionChanged (EventArgs.Empty);
+#endif
+ }
}
}
if (value != right_to_left) {
right_to_left = value;
OnRightToLeftChanged(EventArgs.Empty);
+ PerformLayout ();
}
}
}
}
}
- protected virtual ImeMode DefaultImeMode {
+#if NET_2_0
+ protected virtual Cursor DefaultCursor { get { return Cursors.Default; } }
+#endif
+
+ protected virtual ImeMode DefaultImeMode {
get {
return ImeMode.Inherit;
}
protected virtual Padding DefaultMargin {
get { return new Padding (3); }
}
+
+ protected virtual Size DefaultMaximumSize { get { return new Size (); } }
+ protected virtual Size DefaultMinimumSize { get { return new Size (); } }
+ protected virtual Padding DefaultPadding { get { return new Padding (); } }
#endif
protected virtual Size DefaultSize {
;; // Nothing to do
}
}
-
+#if NET_2_0
+ [Obsolete ()]
+#endif
protected bool RenderRightToLeft {
get {
return (this.right_to_left == RightToLeft.Yes);
[EditorBrowsable(EditorBrowsableState.Advanced)]
[Browsable(false)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+#if NET_2_0
+ internal virtual
+#endif
protected bool ShowKeyboardCues {
get {
return true;
return false;
}
- public void CreateControl() {
+ public void CreateControl ()
+ {
if (is_disposed) {
throw new ObjectDisposedException(GetType().FullName.ToString());
}
Control [] controls = child_controls.GetAllControls ();
for (int i=0; i<controls.Length; i++) {
- controls [i].CreateControl ();
+ if (controls [i].is_visible)
+ controls [i].CreateControl ();
}
UpdateChildrenZOrder();
}
return null;
}
-
+#if NET_2_0
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+#endif
public bool Focus() {
if (CanFocus && IsHandleCreated && !has_focus && !is_focusing) {
is_focusing = true;
}
#if NET_2_0
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
public virtual Size GetPreferredSize (Size proposedSize) {
return preferred_size;
}
}
public void Invalidate(System.Drawing.Rectangle rc, bool invalidateChildren) {
- if (!IsHandleCreated || !Visible || rc.Width == 0 || rc.Height == 0) {
+ // Win32 invalidates control including when Width and Height is equal 0
+ // or is not visible, only Paint event must be care about this.
+ if (!IsHandleCreated)
return;
- }
- NotifyInvalidate(rc);
+ if (rc.Width > 0 && rc.Height > 0) {
- XplatUI.Invalidate(Handle, rc, false);
+ NotifyInvalidate(rc);
- if (invalidateChildren) {
- Control [] controls = child_controls.GetAllControls ();
- for (int i=0; i<controls.Length; i++)
- controls [i].Invalidate ();
+ XplatUI.Invalidate(Handle, rc, false);
+
+ if (invalidateChildren) {
+ Control [] controls = child_controls.GetAllControls ();
+ for (int i=0; i<controls.Length; i++)
+ controls [i].Invalidate ();
+ }
}
OnInvalidated(new InvalidateEventArgs(rc));
}
PerformLayout(null, null);
}
-#if !NET_2_0
- private void SetImplicitBounds (int x, int y, int width, int height)
+ internal void SetImplicitBounds (int x, int y, int width, int height)
{
Rectangle saved_bounds = explicit_bounds;
SetBounds (x, y, width, height);
explicit_bounds = saved_bounds;
}
-#endif
[EditorBrowsable(EditorBrowsableState.Advanced)]
public void PerformLayout(Control affectedControl, string affectedProperty) {
// Perform all Dock and Anchor calculations
try {
-
-#if NET_2_0
- this.layout_engine.Layout(this, levent);
-#else
- // This has been moved to Layout/DefaultLayout.cs for 2.0, please duplicate any changes/fixes there.
- Control child;
- AnchorStyles anchor;
- Rectangle space;
-
- space = DisplayRectangle;
-
- // Deal with docking; go through in reverse, MS docs say that lowest Z-order is closest to edge
- 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
- break;
- }
-
- case DockStyle.Left: {
- child.SetImplicitBounds(space.Left, space.Y, child.Width, space.Height);
- space.X+=child.Width;
- space.Width-=child.Width;
- break;
- }
-
- case DockStyle.Top: {
- child.SetImplicitBounds(space.Left, space.Y, space.Width, child.Height);
- space.Y+=child.Height;
- space.Height-=child.Height;
- break;
- }
-
- case DockStyle.Right: {
- child.SetImplicitBounds(space.Right-child.Width, space.Y, child.Width, space.Height);
- space.Width-=child.Width;
- break;
- }
-
- case DockStyle.Bottom: {
- child.SetImplicitBounds(space.Left, space.Bottom-child.Height, space.Width, child.Height);
- space.Height-=child.Height;
- break;
- }
- }
- }
-
- for (int i = controls.Length - 1; i >= 0; i--) {
- child=controls[i];
-
- //if (child.Visible && (child.Dock == DockStyle.Fill)) {
- if (child.Dock == DockStyle.Fill) {
- child.SetImplicitBounds(space.Left, space.Top, space.Width, space.Height);
- }
- }
-
- space = DisplayRectangle;
-
- for (int i=0; i < controls.Length; i++) {
- int left;
- int top;
- int width;
- int 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) {
- width = space.Width - child.dist_right - left;
- } else {
- ; // Left anchored only, nothing to be done
- }
- } else if ((anchor & AnchorStyles.Right) != 0) {
- left = space.Width - child.dist_right - width;
- } else {
- // 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 = space.Height - child.dist_bottom - top;
- } else {
- ; // Top anchored only, nothing to be done
- }
- } else if ((anchor & AnchorStyles.Bottom) != 0) {
- top = space.Height - child.dist_bottom - height;
- } else {
- // 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;
- }
-
- if (height < 0) {
- height=0;
- }
-
- child.SetImplicitBounds(left, top, width, height);
- }
-#endif
-
- // Let everyone know
OnLayout(levent);
}
return new Rectangle(PointToScreen(r.Location), r.Size);
}
- public virtual void Refresh() {
- if (IsHandleCreated == true) {
+ public virtual void Refresh() {
+ if (IsHandleCreated) {
Invalidate();
XplatUI.UpdateWindow(window.Handle);
}
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();
}
}
}
-
+#if NET_2_0
+ [EditorBrowsable (EditorBrowsableState.Never)]
+ [Obsolete ()]
+#endif
public void Scale(float ratio) {
ScaleCore(ratio, ratio);
}
-
+
+#if NET_2_0
+ [EditorBrowsable (EditorBrowsableState.Never)]
+ [Obsolete ()]
+#endif
public void Scale(float dx, float dy) {
ScaleCore(dx, dy);
}
#if NET_2_0
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
public void Scale(SizeF factor) {
ScaleCore(factor.Width, factor.Height);
}
#endif
public void Select() {
- Select(false, false);
+ if (this is ContainerControl)
+ ContainerSelected = true;
+ else {
+ Control c = this.Parent;
+ while (c != null) {
+ c.ContainerSelected = false;
+ c = c.Parent;
+ }
+ }
+ Select(false, false);
}
#if DebugFocus
}
}
- public void Show() {
+ public void Show ()
+ {
if (!is_created) {
this.CreateControl();
}
}
}
+#if NET_2_0
+ protected virtual AccessibleObject GetAccessibilityObjectById (int objectId)
+ {
+ throw new NotImplementedException ();
+ }
+#endif
+
protected internal bool GetStyle(ControlStyles flag) {
return (control_style & flag) != 0;
}
return RtlTranslateAlignment(align);
}
+#if NET_2_0
+ [EditorBrowsable (EditorBrowsableState.Never)]
+#else
[EditorBrowsable(EditorBrowsableState.Advanced)]
+#endif
protected virtual void ScaleCore(float dx, float dy) {
Point location;
Size size;
IContainerControl container;
container = GetContainerControl();
- if (container != null)
- container.ActiveControl = this;
+ if (container != null && (Control)container != this)
+ if (!this.Parent.ContainerSelected)
+ container.ActiveControl = this;
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void SetClientSizeCore(int x, int y) {
- // Calculate the actual window size from the client size (it usually stays the same or grows)
- Rectangle ClientRect;
- Rectangle WindowRect;
- CreateParams cp;
-
- ClientRect = new Rectangle(0, 0, x, y);
- cp = this.CreateParams;
-
- if (XplatUI.CalculateWindowRect(ref ClientRect, cp.Style, cp.ExStyle, null, out WindowRect)==false) {
- return;
- }
-
- SetBounds(bounds.X, bounds.Y, WindowRect.Width, WindowRect.Height, BoundsSpecified.Size);
+ Size NewSize = SizeFromClientSize (new Size (x, y));
+
+ if (NewSize != Size.Empty)
+ SetBounds (bounds.X, bounds.Y, NewSize.Width, NewSize.Height, BoundsSpecified.Size);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected void SetTopLevel(bool value) {
if ((GetTopLevel() != value) && (parent != null)) {
- throw new Exception();
+ throw new ArgumentException ("Cannot change toplevel style of a parented control.");
}
if (this is Form) {
}
} else {
if (Visible) {
- Visible = false;
+ Visible = false;
}
}
}
protected virtual void SetVisibleCore(bool value) {
if (value!=is_visible) {
- if (value && (window.Handle == IntPtr.Zero) || !is_created) {
+ if (value && ((window.Handle == IntPtr.Zero) || !is_created)) {
CreateControl();
}
if (parent != null) {
parent.PerformLayout(this, "visible");
} else {
- PerformLayout(this, "visible");
+ if (is_visible)
+ PerformLayout(this, "visible");
}
}
}
-
+
+#if NET_2_0
+ protected
+#else
+ internal
+#endif
+ virtual Size SizeFromClientSize (Size clientSize)
+ {
+ Rectangle ClientRect;
+ Rectangle WindowRect;
+ CreateParams cp;
+
+ ClientRect = new Rectangle (0, 0, clientSize.Width, clientSize.Height);
+ cp = this.CreateParams;
+
+ if (XplatUI.CalculateWindowRect (ref ClientRect, cp.Style, cp.ExStyle, null, out WindowRect))
+ return new Size (WindowRect.Width, WindowRect.Height);
+
+ return Size.Empty;
+ }
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected void UpdateBounds() {
int x;
if (resized) {
OnSizeChanged(EventArgs.Empty);
+#if NET_2_0
+ OnClientSizeChanged (EventArgs.Empty);
+#endif
}
}
if (index > 0) {
XplatUI.SetZOrder(child.Handle, child_controls[index - 1].Handle, false, false);
} else {
- XplatUI.SetZOrder(child.Handle, IntPtr.Zero, true, false);
+ IntPtr after = AfterTopMostControl ();
+ if (after != IntPtr.Zero)
+ XplatUI.SetZOrder (child.Handle, after, false, false);
+ else
+ XplatUI.SetZOrder (child.Handle, IntPtr.Zero, true, false);
}
}
}
+
+ // Override this if there is a control that shall always remain on
+ // top of other controls (such as scrollbars). If there are several
+ // of these controls, the bottom-most should be returned.
+ internal virtual IntPtr AfterTopMostControl ()
+ {
+ return IntPtr.Zero;
+ }
private void UpdateChildrenZOrder() {
Control [] controls;
if (paint_event == null) {
return;
}
-
- if (invalid_region != null && !invalid_region.IsVisible (paint_event.ClipRectangle)) {
-
- // Just blit the previous image
- XplatUI.BlitFromOffscreen (Handle, paint_event.Graphics, backbuffer, backbuffer_dc, paint_event.ClipRectangle);
- XplatUI.PaintEventEnd (Handle, true);
- return;
- }
-
- Graphics dc = null;
- Graphics back_dc = null;
- object back = null;
- if (ThemeEngine.Current.DoubleBufferingSupported) {
- if ((control_style & ControlStyles.DoubleBuffer) != 0) {
- CreateBackBuffer ();
- back = backbuffer;
- back_dc = backbuffer_dc;
- dc = paint_event.SetGraphics (back_dc);
+ DoubleBuffer current_buffer = null;
+ if (UseDoubleBuffering) {
+ current_buffer = GetBackBuffer ();
+ if (!current_buffer.InvalidRegion.IsVisible (paint_event.ClipRectangle)) {
+ // Just blit the previous image
+ current_buffer.Blit (paint_event);
+ XplatUI.PaintEventEnd (Handle, true);
+ return;
}
+ current_buffer.Start (paint_event);
}
-
+
if (!GetStyle(ControlStyles.Opaque)) {
OnPaintBackground(paint_event);
}
OnPaint(paint_event);
}
- if (ThemeEngine.Current.DoubleBufferingSupported)
- if ((control_style & ControlStyles.DoubleBuffer) != 0) {
- XplatUI.BlitFromOffscreen (Handle, dc, back, back_dc, paint_event.ClipRectangle);
- paint_event.SetGraphics (dc);
- invalid_region.Exclude (paint_event.ClipRectangle);
+ if (current_buffer != null) {
+ current_buffer.End (paint_event);
+ }
- if (back != backbuffer)
- XplatUI.DestroyOffscreenDrawable (back, back_dc);
- }
XplatUI.PaintEventEnd(Handle, true);
Point pt;
pt = new Point(LowOrder ((int) m.LParam.ToInt32 ()), HighOrder ((int) m.LParam.ToInt32 ()));
- context_menu.Show(this, PointToClient(pt));
+
+ if (pt.X == -1 || pt.Y == -1) {
+ pt.X = (this.Width / 2) + this.Left;
+ pt.Y = (this.Height / 2) + this.Top;
+ pt = this.PointToScreen (pt);
+ }
+
+ context_menu.Show (this, PointToClient (pt));
return;
}
+#if NET_2_0
+ // If there isn't a regular context menu, show the Strip version
+ if (context_menu == null && context_menu_strip != null) {
+ Point pt;
+
+ pt = new Point (LowOrder ((int)m.LParam.ToInt32 ()), HighOrder ((int)m.LParam.ToInt32 ()));
+
+ if (pt.X == -1 || pt.Y == -1) {
+ pt.X = (this.Width / 2) + this.Left;
+ pt.Y = (this.Height /2) + this.Top;
+ pt = this.PointToScreen (pt);
+ }
+
+ context_menu_strip.Show (this, PointToClient (pt));
+ return;
+ }
+#endif
DefWndProc(ref m);
return;
}
}
case Msg.WM_SETFOCUS: {
- if (!has_focus) {
- this.has_focus = true;
- OnGotFocusInternal (EventArgs.Empty);
+ if (!has_focus) {
+ if (this.Parent != null && this.Parent.ContainerSelected)
+ return;
+ this.has_focus = true;
+ OnGotFocusInternal (EventArgs.Empty);
}
return;
}
#endregion // Public Instance Methods
#region OnXXX methods
- [EditorBrowsable(EditorBrowsableState.Advanced)]
+#if NET_2_0
+ protected virtual void OnAutoSizeChanged (EventArgs e)
+ {
+ EventHandler eh = (EventHandler)(Events[AutoSizeChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+#endif
+
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
protected virtual void OnBackColorChanged(EventArgs e) {
EventHandler eh = (EventHandler)(Events [BackColorChangedEvent]);
if (eh != null)
for (int i=0; i<child_controls.Count; i++) child_controls[i].OnParentBackgroundImageChanged(e);
}
+#if NET_2_0
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnBackgroundImageLayoutChanged (EventArgs e)
+ {
+ EventHandler eh = (EventHandler)(Events[BackgroundImageLayoutChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+#endif
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnBindingContextChanged(EventArgs e) {
CheckDataBindings ();
eh (this, e);
}
+#if NET_2_0
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnClientSizeChanged (EventArgs e)
+ {
+ EventHandler eh = (EventHandler)(Events[ClientSizeChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+#endif
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnContextMenuChanged(EventArgs e) {
EventHandler eh = (EventHandler)(Events [ContextMenuChangedEvent]);
eh (this, e);
}
+#if NET_2_0
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnContextMenuStripChanged (EventArgs e) {
+ EventHandler eh = (EventHandler)(Events [ContextMenuStripChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+#endif
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnControlAdded(ControlEventArgs e) {
ControlEventHandler eh = (ControlEventHandler)(Events [ControlAddedEvent]);
eh (this, e);
}
+ internal void RaiseHelpRequested (HelpEventArgs hevent)
+ {
+ OnHelpRequested (hevent);
+ }
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnHelpRequested(HelpEventArgs hevent) {
HelpEventHandler eh = (HelpEventHandler)(Events [HelpRequestedEvent]);
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnInvalidated(InvalidateEventArgs e) {
- if (ThemeEngine.Current.DoubleBufferingSupported)
- if ((control_style & ControlStyles.DoubleBuffer) != 0) {
- // should this block be here? seems like it
- // would be more at home in
- // NotifyInvalidated..
- if (e.InvalidRect == ClientRectangle) {
- InvalidateBackBuffer ();
- }
- else {
- // we need this Inflate call here so
- // that the border of the rectangle is
- // considered Visible (the
- // invalid_region.IsVisible call) in
- // the WM_PAINT handling below.
- Rectangle r = Rectangle.Inflate(e.InvalidRect, 1,1);
- if (invalid_region == null)
- invalid_region = new Region (r);
- else
- invalid_region.Union (r);
- }
+ if (UseDoubleBuffering) {
+ // should this block be here? seems like it
+ // would be more at home in
+ // NotifyInvalidated..
+ if (e.InvalidRect == ClientRectangle) {
+ InvalidateBackBuffer ();
+ } else if (backbuffer != null){
+ // we need this Inflate call here so
+ // that the border of the rectangle is
+ // considered Visible (the
+ // invalid_region.IsVisible call) in
+ // the WM_PAINT handling below.
+ Rectangle r = Rectangle.Inflate(e.InvalidRect, 1,1);
+ backbuffer.InvalidRegion.Union (r);
}
+ }
InvalidateEventHandler eh = (InvalidateEventHandler)(Events [InvalidatedEvent]);
if (eh != null)
LayoutEventHandler eh = (LayoutEventHandler)(Events [LayoutEvent]);
if (eh != null)
eh (this, levent);
+
+ LayoutEngine.Layout (this, levent);
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
eh (this, e);
}
+#if NET_2_0
+ protected virtual void OnMarginChanged (EventArgs e)
+ {
+ EventHandler eh = (EventHandler)(Events[MarginChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnMouseCaptureChanged (EventArgs e)
+ {
+ EventHandler eh = (EventHandler)(Events [MouseCaptureChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnMouseClick (MouseEventArgs e)
+ {
+ MouseEventHandler eh = (MouseEventHandler)(Events [MouseClickEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnMouseDoubleClick (MouseEventArgs e)
+ {
+ MouseEventHandler eh = (MouseEventHandler)(Events [MouseDoubleClickEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+#endif
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnMouseDown(MouseEventArgs e) {
MouseEventHandler eh = (MouseEventHandler)(Events [MouseDownEvent]);
// Override me!
}
+#if NET_2_0
+ protected virtual void OnPaddingChanged (EventArgs e) {
+ EventHandler eh = (EventHandler) (Events [PaddingChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+#endif
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnPaint(PaintEventArgs e) {
PaintEventHandler eh = (PaintEventHandler)(Events [PaintEvent]);
eh (this, e);
}
+#if NET_2_0
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+ protected virtual void OnRegionChanged (EventArgs e)
+ {
+ EventHandler eh = (EventHandler)(Events[RegionChangedEvent]);
+ if (eh != null)
+ eh (this, e);
+ }
+#endif
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
protected virtual void OnResize(EventArgs e) {
+ PerformLayout(this, "Bounds");
+
EventHandler eh = (EventHandler)(Events [ResizeEvent]);
if (eh != null)
eh (this, e);
-
- PerformLayout(this, "bounds");
-
- if (parent != null) {
- parent.PerformLayout();
- }
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
#endregion // OnXXX methods
#region Events
+#if NET_2_0
+ static object AutoSizeChangedEvent = new object ();
+#endif
static object BackColorChangedEvent = new object ();
static object BackgroundImageChangedEvent = new object ();
+#if NET_2_0
+ static object BackgroundImageLayoutChangedEvent = new object ();
+#endif
static object BindingContextChangedEvent = new object ();
static object CausesValidationChangedEvent = new object ();
static object ChangeUICuesEvent = new object ();
static object ClickEvent = new object ();
+#if NET_2_0
+ static object ClientSizeChangedEvent = new object ();
+#endif
static object ContextMenuChangedEvent = new object ();
+#if NET_2_0
+ static object ContextMenuStripChangedEvent = new object ();
+#endif
static object ControlAddedEvent = new object ();
static object ControlRemovedEvent = new object ();
static object CursorChangedEvent = new object ();
static object LeaveEvent = new object ();
static object LocationChangedEvent = new object ();
static object LostFocusEvent = new object ();
+#if NET_2_0
+ static object MarginChangedEvent = new object ();
+ static object MouseCaptureChangedEvent = new object ();
+ static object MouseClickEvent = new object ();
+ static object MouseDoubleClickEvent = new object ();
+#endif
static object MouseDownEvent = new object ();
static object MouseEnterEvent = new object ();
static object MouseHoverEvent = new object ();
static object MouseUpEvent = new object ();
static object MouseWheelEvent = new object ();
static object MoveEvent = new object ();
+#if NET_2_0
+ static object PaddingChangedEvent = new object ();
+#endif
static object PaintEvent = new object ();
static object ParentChangedEvent = new object ();
+#if NET_2_0
+ static object PreviewKeyDownEvent = new object ();
+#endif
static object QueryAccessibilityHelpEvent = new object ();
static object QueryContinueDragEvent = new object ();
+#if NET_2_0
+ static object RegionChangedEvent = new object ();
+#endif
static object ResizeEvent = new object ();
static object RightToLeftChangedEvent = new object ();
static object SizeChangedEvent = new object ();
static object ValidatingEvent = new object ();
static object VisibleChangedEvent = new object ();
+#if NET_2_0
+ [Browsable (false)]
+ [EditorBrowsable (EditorBrowsableState.Never)]
+ public event EventHandler AutoSizeChanged {
+ add { Events.AddHandler (AutoSizeChangedEvent, value);}
+ remove {Events.RemoveHandler (AutoSizeChangedEvent, value);}
+ }
+#endif
public event EventHandler BackColorChanged {
add { Events.AddHandler (BackColorChangedEvent, value); }
remove { Events.RemoveHandler (BackColorChangedEvent, value); }
remove { Events.RemoveHandler (BackgroundImageChangedEvent, value); }
}
+#if NET_2_0
+ public event EventHandler BackgroundImageLayoutChanged {
+ add {Events.AddHandler (BackgroundImageLayoutChangedEvent, value);}
+ remove {Events.RemoveHandler (BackgroundImageLayoutChangedEvent, value);}
+ }
+#endif
+
public event EventHandler BindingContextChanged {
add { Events.AddHandler (BindingContextChangedEvent, value); }
remove { Events.RemoveHandler (BindingContextChangedEvent, value); }
add { Events.AddHandler (ClickEvent, value); }
remove { Events.RemoveHandler (ClickEvent, value); }
}
+
+#if NET_2_0
+ public event EventHandler ClientSizeChanged {
+ add {Events.AddHandler (ClientSizeChangedEvent, value);}
+ remove {Events.RemoveHandler (ClientSizeChangedEvent, value);}
+ }
+#endif
+#if NET_2_0
+ [Browsable (false)]
+#endif
public event EventHandler ContextMenuChanged {
add { Events.AddHandler (ContextMenuChangedEvent, value); }
remove { Events.RemoveHandler (ContextMenuChangedEvent, value); }
}
+#if NET_2_0
+ public event EventHandler ContextMenuStripChanged {
+ add { Events.AddHandler (ContextMenuStripChangedEvent, value); }
+ remove { Events.RemoveHandler (ContextMenuStripChangedEvent, value);}
+ }
+#endif
+
+
[EditorBrowsable(EditorBrowsableState.Advanced)]
+#if NET_2_0
+ [Browsable(true)]
+#else
[Browsable(false)]
+#endif
public event ControlEventHandler ControlAdded {
add { Events.AddHandler (ControlAddedEvent, value); }
remove { Events.RemoveHandler (ControlAddedEvent, value); }
}
[EditorBrowsable(EditorBrowsableState.Advanced)]
+#if NET_2_0
+ [Browsable(true)]
+#else
[Browsable(false)]
+#endif
public event ControlEventHandler ControlRemoved {
add { Events.AddHandler (ControlRemovedEvent, value); }
remove { Events.RemoveHandler (ControlRemovedEvent, value); }
remove { Events.RemoveHandler (LostFocusEvent, value); }
}
+#if NET_2_0
+ public event EventHandler MarginChanged {
+ add { Events.AddHandler (MarginChangedEvent, value); }
+ remove {Events.RemoveHandler (MarginChangedEvent, value); }
+ }
+
+ public event EventHandler MouseCaptureChanged {
+ add { Events.AddHandler (MouseCaptureChangedEvent, value); }
+ remove { Events.RemoveHandler (MouseCaptureChangedEvent, value); }
+ }
+
+ public event MouseEventHandler MouseClick
+ {
+ add { Events.AddHandler (MouseClickEvent, value); }
+ remove { Events.RemoveHandler (MouseClickEvent, value); }
+ }
+ public event MouseEventHandler MouseDoubleClick
+ {
+ add { Events.AddHandler (MouseDoubleClickEvent, value); }
+ remove { Events.RemoveHandler (MouseDoubleClickEvent, value); }
+ }
+#endif
public event MouseEventHandler MouseDown {
add { Events.AddHandler (MouseDownEvent, value); }
remove { Events.RemoveHandler (MouseDownEvent, value); }
add { Events.AddHandler (MoveEvent, value); }
remove { Events.RemoveHandler (MoveEvent, value); }
}
-
+#if NET_2_0
+ public event EventHandler PaddingChanged
+ {
+ add { Events.AddHandler (PaddingChangedEvent, value); }
+ remove { Events.RemoveHandler (PaddingChangedEvent, value); }
+ }
+#endif
public event PaintEventHandler Paint {
add { Events.AddHandler (PaintEvent, value); }
remove { Events.RemoveHandler (PaintEvent, value); }
remove { Events.RemoveHandler (ParentChangedEvent, value); }
}
+#if NET_2_0
+ public event PreviewKeyDownEventHandler PreviewKeyDown {
+ add { Events.AddHandler (PreviewKeyDownEvent, value); }
+ remove { Events.RemoveHandler (PreviewKeyDownEvent, value); }
+ }
+#endif
+
public event QueryAccessibilityHelpEventHandler QueryAccessibilityHelp {
add { Events.AddHandler (QueryAccessibilityHelpEvent, value); }
remove { Events.RemoveHandler (QueryAccessibilityHelpEvent, value); }
remove { Events.RemoveHandler (QueryContinueDragEvent, value); }
}
+#if NET_2_0
+ public event EventHandler RegionChanged {
+ add { Events.AddHandler (RegionChangedEvent, value); }
+ remove { Events.RemoveHandler (RegionChangedEvent, value); }
+ }
+#endif
+
+#if NET_2_0
+ [EditorBrowsable (EditorBrowsableState.Advanced)]
+#endif
public event EventHandler Resize {
add { Events.AddHandler (ResizeEvent, value); }
remove { Events.RemoveHandler (ResizeEvent, value); }
projects / mono.git / blobdiff